package item

import (
	"log"

	customization "example.com/database/customization"
	function "example.com/database/function"
	group "example.com/database/group"
	itemtag "example.com/database/itemtag"

	"gorm.io/gorm"
)

type Item struct {
	gorm.Model
	Name                string                        `gorm:"primaryKey uniqueIndex" json:"name"`
	Functions           []function.Function           `gorm:"many2many:item_function_associations" json:"functions"`
	FlavorText          string                        `json:"flavor_text"`
	RulesDescription    string                        `json:"rules_description"`
	PhysrepRequirements string                        `json:"physrep_requirements"`
	Tags                []itemtag.ItemTag             `gorm:"many2many:item_tag_associations" json:"tags"` // Unique
	Customizations      []customization.Customization `gorm:"many2many:item_customization_associations" json:"customizations"`
	Visibility          []group.Group                 `gorm:"many2many:item_visibility_associations" json:"visibility"` // Unique
}

func (item Item) Create(db *gorm.DB) error {
	result := db.Create(&item)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func (item Item) getAssociations(db *gorm.DB) {
	db.Model(&item).Association("Functions").Find(&item.Functions)
	db.Model(&item).Association("Tags").Find(&item.Tags)
	db.Model(&item).Association("Customizations").Find(&item.Customizations)
	db.Model(&item).Association("Visibility").Find(&item.Visibility)
}

func (item Item) Get(db *gorm.DB, inputItem string) {
	db.Where("name = ?", inputItem).Take(&item)
	item.getAssociations(db)
}

func (item Item) Update(db *gorm.DB) error {
	var originalItem Item
	originalItem.Get(db, item.Name)
	functionsError := db.Model(&originalItem).Association("Functions").Find(&originalItem.Functions)
	if functionsError != nil {
		return functionsError
	}
	tagsError := db.Model(&originalItem).Association("Tags").Find(&originalItem.Tags)
	if tagsError != nil {
		return tagsError
	}
	customizationsError := db.Model(&originalItem).Association("Customizations").Find(&originalItem.Customizations)
	if customizationsError != nil {
		return customizationsError
	}
	visibilityError := db.Model(&originalItem).Association("Visibility").Find(&originalItem.Visibility)
	if visibilityError != nil {
		return visibilityError
	}
	return nil
}

func (item Item) Delete(db *gorm.DB) error {
	result := db.Delete(&item)
	if result.Error != nil {
		return result.Error
	}
	return nil
}

func Create(db *gorm.DB, name string, functions []uint, flavorText string, rulesDescription string, physrepRequirements string, tags []string, customizations []string, visibility []string) error {
	return Item{
		Name:                name,
		Functions:           *function.Get(db, functions),
		FlavorText:          flavorText,
		RulesDescription:    rulesDescription,
		PhysrepRequirements: physrepRequirements,
		Tags:                *itemtag.Get(db, tags),
		Customizations:      *customization.Get(db, customizations),
		Visibility:          *group.Get(db, visibility),
	}.Create(db)
}

func Get(db *gorm.DB, inputItems []string) *[]Item {
	var outputItems []Item
	for _, inputItem := range inputItems {
		var outputItem Item
		outputItem.Get(db, inputItem)
		outputItems = append(outputItems, outputItem)
	}
	return &outputItems
}

func GetAll(db *gorm.DB) *[]Item {
	var outputItemNames []string
	result := db.Model(&Item{}).Select("name").Find(&outputItemNames)
	if result.Error != nil {
		log.Println(result.Error)
	}
	return Get(db, outputItemNames)
}

func Update(db *gorm.DB, name string, functions []uint, flavorText string, rulesDescription string, physrepRequirements string, tags []string, customizations []string, visibility []string) error {
	return Item{
		Name:                name,
		Functions:           *function.Get(db, functions),
		FlavorText:          flavorText,
		RulesDescription:    rulesDescription,
		PhysrepRequirements: physrepRequirements,
		Tags:                *itemtag.Get(db, tags),
		Customizations:      *customization.Get(db, customizations),
		Visibility:          *group.Get(db, visibility),
	}.Update(db)
}

func Delete(db *gorm.DB, inputItem []string) {
	items := Get(db, inputItem)
	for _, item := range *items {
		item.Delete(db)
	}
}