package gorm_models

import (
	"errors"
	"log"

	"gorm.io/gorm"
)

type AttributeOption struct {
	ID           uint `gorm:"primaryKey"`
	AttributeID  uint
	AdminName    string
	SortOrder    int `sql:"DEFAULT:NULL" gorm:"default:null"`
	Translations []AttributeOptionTranslation
}

type AttributeOptionTranslation struct {
	ID                uint `gorm:"primaryKey"`
	AttributeOptionID uint
	Locale            string
	Label             string
}

type Attribute struct {
	ID               uint `gorm:"primaryKey"`
	Code             string
	AttributeOptions []AttributeOption
}

type AttributeFamily struct {
	ID     uint `gorm:"primaryKey"`
	Code   string
	Groups []AttributeGroup
}

type AttributeGroup struct {
	ID                uint `gorm:"primaryKey"`
	Name              string
	AttributeFamilyID uint
	Attributes        []Attribute `gorm:"many2many:attribute_group_mappings;"`
}

func GetFamilies(db *gorm.DB) ([]AttributeFamily, error) {
	var families []AttributeFamily

	err := db.Model(&AttributeFamily{}).Preload("Groups").Order("id ASC").Find(&families).Error

	return families, err
}

func GetGroups(db *gorm.DB) []AttributeGroup {
	var groups []AttributeGroup
	err := db.Model(&AttributeGroup{}).Preload("Family").Find(&groups).Error

	if err != nil {
		log.Println(err.Error())

	}
	return groups
}

func GetAttributes(db *gorm.DB) ([]Attribute, error) {
	var attributes []Attribute

	err := db.Model(&Attribute{}).Find(&attributes).Error

	return attributes, err
}

func GetAttributeOption(db *gorm.DB, attrbuteID uint, value string) AttributeOption {
	var option AttributeOption

	err := db.Where("attribute_id=? and admin_name=?", attrbuteID, value).First(&option).Error

	if err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
		option = AttributeOption{
			AttributeID: attrbuteID,
			AdminName:   value,
			SortOrder:   1000,
			Translations: []AttributeOptionTranslation{
				{Locale: "tm", Label: value},
				{Locale: "ru", Label: value},
				{Locale: "tr", Label: value},
			},
		}

		if err := db.Create(&option).Error; err != nil {
			log.Println(err.Error())

		}
	}

	return option
}

func GetAttrOptions(db *gorm.DB, attrbuteID uint) ([]AttributeOption, error) {

	var options []AttributeOption

	err := db.Find(&options, AttributeOption{AttributeID: attrbuteID}).Error

	if err != nil {
		log.Println(err.Error())
	}

	return options, err
}