package item

import (
	"encoding/json"
	"errors"

	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
}

type ItemParams struct {
	// ID(s) of the object being modified
	IDArray []uint
	// New fields
	Name                string `json:"name"`
	Functions           []uint `json:"functions"`
	FlavorText          string `json:"flavor_text"`
	RulesDescription    string `json:"rules_description"`
	PhysrepRequirements string `json:"phyrep_requirements"`
	Tags                []uint `json:"tags"`
	Customizations      []uint `json:"customizations"`
	Visibility          []uint `json:"visibility"`
}

func (params *ItemParams) parse(IDUintArray *[]uint, body *[]byte) error {
	var inputParams ItemParams
	params.IDArray = *IDUintArray
	if len(*body) == 0 {
		return nil
	}
	err := json.Unmarshal(*body, &inputParams)
	if err != nil {
		return err
	}
	if inputParams.Name == "" {
		return errors.New("input name cannot be empty")
	}
	params.Name = inputParams.Name
	params.Functions = inputParams.Functions
	params.FlavorText = inputParams.FlavorText
	params.RulesDescription = inputParams.RulesDescription
	params.PhysrepRequirements = inputParams.PhysrepRequirements
	params.Tags = inputParams.Tags
	params.Customizations = inputParams.Customizations
	params.Visibility = inputParams.Visibility
	return nil
}

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 uint) {
	db.Where("id = ?", inputItem).Take(&item)
	item.getAssociations(db)
}

func (item Item) update(db *gorm.DB) error {
	// Get the original Item object
	var originalItem Item
	result := db.Model(&Item{}).Where("id = ?", item.Model.ID).Take(&originalItem)
	if result.Error != nil {
		return result.Error
	}
	// Set the static values
	originalItem.Name = item.Name
	originalItem.FlavorText = item.FlavorText
	originalItem.RulesDescription = item.RulesDescription
	originalItem.PhysrepRequirements = item.PhysrepRequirements
	// Set the associated values by grabbing them from the database
	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
	}
	result = db.Model(&originalItem).Update("name", originalItem.Name)
	if result.Error != nil {
		err := errors.New("new name already exists")
		return err
	}
	db.Save(&originalItem)
	return nil
}

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

func Create(db *gorm.DB, params ItemParams) error {
	var err error
	var newFunctions []function.Function
	if len(params.Functions) > 0 {
		newFunctions, err = function.Get(db, params.Functions)
		if err != nil {
			return err
		}
	}
	var newTags []itemtag.ItemTag
	if len(params.Tags) > 0 {
		newTags = *itemtag.Get(db, params.Tags)
	}
	var newCustomizations []customization.Customization
	if len(params.Customizations) > 0 {
		newCustomizations = *customization.Get(db, params.Customizations)
	}
	var newVisibility []group.Group
	if len(params.Visibility) > 0 {
		newVisibility, err = group.Get(db, params.Visibility)
		if err != nil {
			return err
		}
	}
	return Item{
		Name:                params.Name,
		Functions:           newFunctions,
		FlavorText:          params.FlavorText,
		RulesDescription:    params.RulesDescription,
		PhysrepRequirements: params.PhysrepRequirements,
		Tags:                newTags,
		Customizations:      newCustomizations,
		Visibility:          newVisibility,
	}.create(db)
}

func Get(db *gorm.DB, inputItems []uint) *[]Item {
	var outputItems []Item
	if len(inputItems) < 1 {
		db.Model(&Item{}).Select("id").Find(&inputItems)
	}
	for _, inputItem := range inputItems {
		var outputItem Item
		outputItem.get(db, inputItem)
		outputItems = append(outputItems, outputItem)
	}
	return &outputItems
}

func Update(db *gorm.DB, params ItemParams) error {
	var err error
	var newFunctions []function.Function
	if len(params.Functions) > 0 {
		newFunctions, err = function.Get(db, params.Functions)
		if err != nil {
			return err
		}
	}
	var newTags []itemtag.ItemTag
	if len(params.Tags) > 0 {
		newTags = *itemtag.Get(db, params.Tags)
	}
	var newCustomizations []customization.Customization
	if len(params.Customizations) > 0 {
		newCustomizations = *customization.Get(db, params.Customizations)
	}
	var newVisibility []group.Group
	if len(params.Visibility) > 0 {
		newVisibility, err = group.Get(db, params.Visibility)
		if err != nil {
			return err
		}
	}
	return Item{
		Name:                params.Name,
		Functions:           newFunctions,
		FlavorText:          params.FlavorText,
		RulesDescription:    params.RulesDescription,
		PhysrepRequirements: params.PhysrepRequirements,
		Tags:                newTags,
		Customizations:      newCustomizations,
		Visibility:          newVisibility,
	}.update(db)
}

func Delete(db *gorm.DB, inputItems []uint) error {
	var items []Item
	// if len(inputItem) < 1 {
	// 	result := db.Model(&Item{}).Select("id").Find(&inputItem)
	// 	if result.Error != nil {
	// 		return result.Error
	// 	}
	// }
	for _, inputItem := range inputItems {
		var item Item
		item.get(db, inputItem)
		items = append(items, item)
	}
	for _, item := range items {
		err := item.delete(db)
		if err != nil {
			return err
		}
	}
	return nil
}

func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]Item, error) {
	var err error
	var params ItemParams
	err = params.parse(IDUintArray, body)
	if err != nil {
		return nil, err
	}
	var result *[]Item
	switch method {
	case "GET":
		result = Get(db, params.IDArray)
	case "POST":
		err = Create(db, params)
	case "PUT":
		err = Update(db, params)
	case "DELETE":
		err = Delete(db, params.IDArray)
	}
	return result, err
}