package inventoryslot

import (
	"encoding/json"
	"errors"

	item "example.com/database/item"

	"gorm.io/gorm"
)

type InventorySlot struct {
	gorm.Model
	Item     item.Item `gorm:"foreignKey:Name" json:"item"`
	Quantity int64     `json:"quantity"` // Positive
}

type InventorySlotParams struct {
	// ID(s) of the object being modified
	IDArray []uint
	// New fields
	Item     uint  `json:"item"`
	Quantity int64 `json:"quantity"`
}

func (params *InventorySlotParams) parse(IDUintArray *[]uint, body *[]byte) error {
	var inputParams InventorySlotParams
	params.IDArray = *IDUintArray
	if len(*body) == 0 {
		return nil
	}
	err := json.Unmarshal(*body, &inputParams)
	if err != nil {
		return err
	}
	params.Item = inputParams.Item
	params.Quantity = inputParams.Quantity
	return nil
}

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

func (inventorySlot *InventorySlot) getAssociations(db *gorm.DB) {
	db.Model(&inventorySlot).Association("Item").Find(&inventorySlot.Item)

}

func (inventorySlot *InventorySlot) get(db *gorm.DB, inputInventorySlot uint) {
	db.Where("id = ?", inputInventorySlot).Take(&inventorySlot)
	inventorySlot.getAssociations(db)
}

func (inventorySlot InventorySlot) update(db *gorm.DB) error {
	// Get the original InventorySlot object
	var originalInventorySlot InventorySlot
	result := db.Model(&InventorySlot{}).Where("id = ?", inventorySlot.Model.ID).Take(&originalInventorySlot)
	if result.Error != nil {
		return result.Error
	}
	// Set the static values
	originalInventorySlot.Quantity = inventorySlot.Quantity
	// Set the associated values by grabbing them from the database
	itemsError := db.Model(&originalInventorySlot).Association("Item").Replace(&inventorySlot.Item)
	if itemsError != nil {
		return itemsError
	}
	result = db.Model(&originalInventorySlot).Update("item", originalInventorySlot.Item)
	if result.Error != nil {
		err := errors.New("new item already exists")
		return err
	}
	db.Save(&originalInventorySlot)
	return nil
}

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

func Create(db *gorm.DB, params InventorySlotParams) error {
	newItem := (*item.Get(db, []uint{params.Item}))[0]
	return InventorySlot{
		Item:     newItem,
		Quantity: params.Quantity,
	}.create(db)
}

func Get(db *gorm.DB, inputInventorySlots []uint) *[]InventorySlot {
	var outputInventorySlots []InventorySlot
	if len(inputInventorySlots) < 1 {
		db.Model(&InventorySlot{}).Select("id").Find(&inputInventorySlots)
	}
	for _, inputInventorySlot := range inputInventorySlots {
		var outputInventorySlot InventorySlot
		outputInventorySlot.get(db, inputInventorySlot)
		outputInventorySlots = append(outputInventorySlots, outputInventorySlot)
	}
	return &outputInventorySlots
}

func Update(db *gorm.DB, params InventorySlotParams) error {
	newItem := (*item.Get(db, []uint{params.Item}))[0]
	return InventorySlot{
		Item:     newItem,
		Quantity: params.Quantity,
	}.update(db)
}

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

func HandleRequest(method string, db *gorm.DB, IDUintArray *[]uint, body *[]byte) (*[]InventorySlot, error) {
	var err error
	var params InventorySlotParams
	err = params.parse(IDUintArray, body)
	if err != nil {
		return nil, err
	}
	var result *[]InventorySlot
	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
}