package items

import (
	"fmt"

	"dk/internal/database"
	"dk/internal/helpers/scanner"

	"zombiezen.com/go/sqlite"
)

// Item represents an item in the database
type Item struct {
	database.BaseModel

	ID      int    `db:"id" json:"id"`
	Type    int    `db:"type" json:"type"`
	Name    string `db:"name" json:"name"`
	Value   int    `db:"value" json:"value"`
	Att     int    `db:"att" json:"att"`
	Special string `db:"special" json:"special"`
}

func (i *Item) GetTableName() string {
	return "items"
}

func (i *Item) GetID() int {
	return i.ID
}

func (i *Item) SetID(id int) {
	i.ID = id
}

func (i *Item) Set(field string, value any) error {
	return database.Set(i, field, value)
}

func (i *Item) Save() error {
	return database.Save(i)
}

func (i *Item) Delete() error {
	return database.Delete(i)
}

// Creates a new Item with sensible defaults
func New() *Item {
	return &Item{
		Type:    TypeWeapon, // Default to weapon
		Name:    "",
		Value:   0,
		Att:     0,
		Special: "",
	}
}

var itemScanner = scanner.New[Item]()

// Returns the column list for item queries
func itemColumns() string {
	return itemScanner.Columns()
}

// Populates an Item struct using the fast scanner
func scanItem(stmt *sqlite.Stmt) *Item {
	item := &Item{}
	itemScanner.Scan(stmt, item)
	return item
}

// ItemType constants for item types
const (
	TypeWeapon = 1
	TypeArmor  = 2
	TypeShield = 3
)

// Retrieves an item by ID
func Find(id int) (*Item, error) {
	var item *Item

	query := `SELECT ` + itemColumns() + ` FROM items WHERE id = ?`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		item = scanItem(stmt)
		return nil
	}, id)

	if err != nil {
		return nil, fmt.Errorf("failed to find item: %w", err)
	}

	if item == nil {
		return nil, fmt.Errorf("item with ID %d not found", id)
	}

	return item, nil
}

// Retrieves all items
func All() ([]*Item, error) {
	var items []*Item

	query := `SELECT ` + itemColumns() + ` FROM items ORDER BY id`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		item := scanItem(stmt)
		items = append(items, item)
		return nil
	})

	if err != nil {
		return nil, fmt.Errorf("failed to retrieve all items: %w", err)
	}

	return items, nil
}

// Retrieves items by type
func ByType(itemType int) ([]*Item, error) {
	var items []*Item

	query := `SELECT ` + itemColumns() + ` FROM items WHERE type = ? ORDER BY id`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		item := scanItem(stmt)
		items = append(items, item)
		return nil
	}, itemType)

	if err != nil {
		return nil, fmt.Errorf("failed to retrieve items by type: %w", err)
	}

	return items, nil
}

// Saves a new item to the database and sets the ID
func (i *Item) Insert() error {
	columns := `type, name, value, att, special`
	values := []any{i.Type, i.Name, i.Value, i.Att, i.Special}
	return database.Insert(i, columns, values...)
}

// Returns true if the item is a weapon
func (i *Item) IsWeapon() bool {
	return i.Type == TypeWeapon
}

// Returns true if the item is armor
func (i *Item) IsArmor() bool {
	return i.Type == TypeArmor
}

// Returns true if the item is a shield
func (i *Item) IsShield() bool {
	return i.Type == TypeShield
}

// Returns the string representation of the item type
func (i *Item) TypeName() string {
	switch i.Type {
	case TypeWeapon:
		return "Weapon"
	case TypeArmor:
		return "Armor"
	case TypeShield:
		return "Shield"
	default:
		return "Unknown"
	}
}

// Returns true if the item has special properties
func (i *Item) HasSpecial() bool {
	return i.Special != ""
}

// Returns true if the item can be equipped
func (i *Item) IsEquippable() bool {
	return i.Type == TypeWeapon || i.Type == TypeArmor || i.Type == TypeShield
}