package drops

import (
	"fmt"

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

	"zombiezen.com/go/sqlite"
)

// Drop represents a drop item in the database
type Drop struct {
	database.BaseModel

	ID    int    `db:"id" json:"id"`
	Name  string `db:"name" json:"name"`
	Level int    `db:"level" json:"level"`
	Type  int    `db:"type" json:"type"`
	Att   string `db:"att" json:"att"`
}

func (d *Drop) GetTableName() string {
	return "drops"
}

func (d *Drop) GetID() int {
	return d.ID
}

func (d *Drop) SetID(id int) {
	d.ID = id
}

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

func (d *Drop) Save() error {
	return database.Save(d)
}

func (d *Drop) Delete() error {
	return database.Delete(d)
}

// Creates a new Drop with sensible defaults
func New() *Drop {
	return &Drop{
		Name:  "",
		Level: 1,              // Default minimum level
		Type:  TypeConsumable, // Default to consumable
		Att:   "",
	}
}

var dropScanner = scanner.New[Drop]()

// Returns the column list for drop queries
func dropColumns() string {
	return dropScanner.Columns()
}

// Populates a Drop struct using the fast scanner
func scanDrop(stmt *sqlite.Stmt) *Drop {
	drop := &Drop{}
	dropScanner.Scan(stmt, drop)
	return drop
}

// DropType constants for drop types
const (
	TypeConsumable = 1
)

// Retrieves a drop by ID
func Find(id int) (*Drop, error) {
	var drop *Drop

	query := `SELECT ` + dropColumns() + ` FROM drops WHERE id = ?`

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

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

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

	return drop, nil
}

// Retrieves all drops
func All() ([]*Drop, error) {
	var drops []*Drop

	query := `SELECT ` + dropColumns() + ` FROM drops ORDER BY id`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		drop := scanDrop(stmt)
		drops = append(drops, drop)
		return nil
	})

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

	return drops, nil
}

// Retrieves drops by minimum level requirement
func ByLevel(minLevel int) ([]*Drop, error) {
	var drops []*Drop

	query := `SELECT ` + dropColumns() + ` FROM drops WHERE level <= ? ORDER BY level, id`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		drop := scanDrop(stmt)
		drops = append(drops, drop)
		return nil
	}, minLevel)

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

	return drops, nil
}

// Retrieves drops by type
func ByType(dropType int) ([]*Drop, error) {
	var drops []*Drop

	query := `SELECT ` + dropColumns() + ` FROM drops WHERE type = ? ORDER BY level, id`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		drop := scanDrop(stmt)
		drops = append(drops, drop)
		return nil
	}, dropType)

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

	return drops, nil
}

// Saves a new drop to the database and sets the ID
func (d *Drop) Insert() error {
	columns := `name, level, type, att`
	values := []any{d.Name, d.Level, d.Type, d.Att}
	return database.Insert(d, columns, values...)
}

// Returns true if the drop is a consumable item
func (d *Drop) IsConsumable() bool {
	return d.Type == TypeConsumable
}

// Returns the string representation of the drop type
func (d *Drop) TypeName() string {
	switch d.Type {
	case TypeConsumable:
		return "Consumable"
	default:
		return "Unknown"
	}
}