package users

import (
	"fmt"
	"strings"
	"time"

	"dk/internal/database"
	"dk/internal/utils/scanner"

	"zombiezen.com/go/sqlite"
)

// User represents a user in the database
type User struct {
	ID            int    `db:"id" json:"id"`
	Username      string `db:"username" json:"username"`
	Password      string `db:"password" json:"password"`
	Email         string `db:"email" json:"email"`
	Verified      int    `db:"verified" json:"verified"`
	Token         string `db:"token" json:"token"`
	Registered    int64  `db:"registered" json:"registered"`
	LastOnline    int64  `db:"last_online" json:"last_online"`
	Auth          int    `db:"auth" json:"auth"`
	X             int    `db:"x" json:"x"`
	Y             int    `db:"y" json:"y"`
	ClassID       int    `db:"class_id" json:"class_id"`
	Currently     string `db:"currently" json:"currently"`
	Fighting      int    `db:"fighting" json:"fighting"`
	MonsterID     int    `db:"monster_id" json:"monster_id"`
	MonsterHP     int    `db:"monster_hp" json:"monster_hp"`
	MonsterSleep  int    `db:"monster_sleep" json:"monster_sleep"`
	MonsterImmune int    `db:"monster_immune" json:"monster_immune"`
	UberDamage    int    `db:"uber_damage" json:"uber_damage"`
	UberDefense   int    `db:"uber_defense" json:"uber_defense"`
	HP            int    `db:"hp" json:"hp"`
	MP            int    `db:"mp" json:"mp"`
	TP            int    `db:"tp" json:"tp"`
	MaxHP         int    `db:"max_hp" json:"max_hp"`
	MaxMP         int    `db:"max_mp" json:"max_mp"`
	MaxTP         int    `db:"max_tp" json:"max_tp"`
	Level         int    `db:"level" json:"level"`
	Gold          int    `db:"gold" json:"gold"`
	Exp           int    `db:"exp" json:"exp"`
	GoldBonus     int    `db:"gold_bonus" json:"gold_bonus"`
	ExpBonus      int    `db:"exp_bonus" json:"exp_bonus"`
	Strength      int    `db:"strength" json:"strength"`
	Dexterity     int    `db:"dexterity" json:"dexterity"`
	Attack        int    `db:"attack" json:"attack"`
	Defense       int    `db:"defense" json:"defense"`
	WeaponID      int    `db:"weapon_id" json:"weapon_id"`
	ArmorID       int    `db:"armor_id" json:"armor_id"`
	ShieldID      int    `db:"shield_id" json:"shield_id"`
	Slot1ID       int    `db:"slot_1_id" json:"slot_1_id"`
	Slot2ID       int    `db:"slot_2_id" json:"slot_2_id"`
	Slot3ID       int    `db:"slot_3_id" json:"slot_3_id"`
	WeaponName    string `db:"weapon_name" json:"weapon_name"`
	ArmorName     string `db:"armor_name" json:"armor_name"`
	ShieldName    string `db:"shield_name" json:"shield_name"`
	Slot1Name     string `db:"slot_1_name" json:"slot_1_name"`
	Slot2Name     string `db:"slot_2_name" json:"slot_2_name"`
	Slot3Name     string `db:"slot_3_name" json:"slot_3_name"`
	DropCode      int    `db:"drop_code" json:"drop_code"`
	Spells        string `db:"spells" json:"spells"`
	Towns         string `db:"towns" json:"towns"`
}

var userScanner = scanner.New[User]()

// userColumns returns the column list for user queries
func userColumns() string {
	return userScanner.Columns()
}

// scanUser populates a User struct using the fast scanner
func scanUser(stmt *sqlite.Stmt) *User {
	user := &User{}
	userScanner.Scan(stmt, user)
	return user
}

// Find retrieves a user by ID
func Find(id int) (*User, error) {
	var user *User

	query := `SELECT ` + userColumns() + ` FROM users WHERE id = ?`

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

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

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

	return user, nil
}

// All retrieves all users ordered by registration date (newest first)
func All() ([]*User, error) {
	var users []*User

	query := `SELECT ` + userColumns() + ` FROM users ORDER BY registered DESC, id DESC`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		user := scanUser(stmt)
		users = append(users, user)
		return nil
	})

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

	return users, nil
}

// ByUsername retrieves a user by username (case-insensitive)
func ByUsername(username string) (*User, error) {
	var user *User

	query := `SELECT ` + userColumns() + ` FROM users WHERE LOWER(username) = LOWER(?) LIMIT 1`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		user = scanUser(stmt)
		return nil
	}, username)

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

	if user == nil {
		return nil, fmt.Errorf("user with username '%s' not found", username)
	}

	return user, nil
}

// ByEmail retrieves a user by email address
func ByEmail(email string) (*User, error) {
	var user *User

	query := `SELECT ` + userColumns() + ` FROM users WHERE email = ? LIMIT 1`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		user = scanUser(stmt)
		return nil
	}, email)

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

	if user == nil {
		return nil, fmt.Errorf("user with email '%s' not found", email)
	}

	return user, nil
}

// ByLevel retrieves users at a specific level
func ByLevel(level int) ([]*User, error) {
	var users []*User

	query := `SELECT ` + userColumns() + ` FROM users WHERE level = ? ORDER BY exp DESC, id ASC`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		user := scanUser(stmt)
		users = append(users, user)
		return nil
	}, level)

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

	return users, nil
}

// Online retrieves users who have been online within the specified duration
func Online(within time.Duration) ([]*User, error) {
	var users []*User
	cutoff := time.Now().Add(-within).Unix()

	query := `SELECT ` + userColumns() + ` FROM users WHERE last_online >= ? ORDER BY last_online DESC, id ASC`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		user := scanUser(stmt)
		users = append(users, user)
		return nil
	}, cutoff)

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

	return users, nil
}

// Save updates an existing user in the database
func (u *User) Save() error {
	if u.ID == 0 {
		return fmt.Errorf("cannot save user without ID")
	}

	query := `UPDATE users SET username = ?, password = ?, email = ?, verified = ?, token = ?,
		         registered = ?, last_online = ?, auth = ?, x = ?, y = ?, class_id = ?, currently = ?,
		         fighting = ?, monster_id = ?, monster_hp = ?, monster_sleep = ?, monster_immune = ?,
		         uber_damage = ?, uber_defense = ?, hp = ?, mp = ?, tp = ?, max_hp = ?, max_mp = ?, max_tp = ?,
		         level = ?, gold = ?, exp = ?, gold_bonus = ?, exp_bonus = ?, strength = ?, dexterity = ?,
		         attack = ?, defense = ?, weapon_id = ?, armor_id = ?, shield_id = ?, slot_1_id = ?,
		         slot_2_id = ?, slot_3_id = ?, weapon_name = ?, armor_name = ?, shield_name = ?,
		         slot_1_name = ?, slot_2_name = ?, slot_3_name = ?, drop_code = ?, spells = ?, towns = ?
		      WHERE id = ?`

	return database.Exec(query, u.Username, u.Password, u.Email, u.Verified, u.Token,
		u.Registered, u.LastOnline, u.Auth, u.X, u.Y, u.ClassID, u.Currently,
		u.Fighting, u.MonsterID, u.MonsterHP, u.MonsterSleep, u.MonsterImmune,
		u.UberDamage, u.UberDefense, u.HP, u.MP, u.TP, u.MaxHP, u.MaxMP, u.MaxTP,
		u.Level, u.Gold, u.Exp, u.GoldBonus, u.ExpBonus, u.Strength, u.Dexterity,
		u.Attack, u.Defense, u.WeaponID, u.ArmorID, u.ShieldID, u.Slot1ID,
		u.Slot2ID, u.Slot3ID, u.WeaponName, u.ArmorName, u.ShieldName,
		u.Slot1Name, u.Slot2Name, u.Slot3Name, u.DropCode, u.Spells, u.Towns, u.ID)
}

// Delete removes the user from the database
func (u *User) Delete() error {
	if u.ID == 0 {
		return fmt.Errorf("cannot delete user without ID")
	}

	return database.Exec("DELETE FROM users WHERE id = ?", u.ID)
}

// RegisteredTime returns the registration timestamp as a time.Time
func (u *User) RegisteredTime() time.Time {
	return time.Unix(u.Registered, 0)
}

// LastOnlineTime returns the last online timestamp as a time.Time
func (u *User) LastOnlineTime() time.Time {
	return time.Unix(u.LastOnline, 0)
}

// UpdateLastOnline sets the last online timestamp to current time
func (u *User) UpdateLastOnline() {
	u.LastOnline = time.Now().Unix()
}

// IsVerified returns true if the user's email is verified
func (u *User) IsVerified() bool {
	return u.Verified == 1
}

// IsAdmin returns true if the user has admin privileges (auth >= 4)
func (u *User) IsAdmin() bool {
	return u.Auth >= 4
}

// IsModerator returns true if the user has moderator privileges (auth >= 2)
func (u *User) IsModerator() bool {
	return u.Auth >= 2
}

// IsFighting returns true if the user is currently fighting
func (u *User) IsFighting() bool {
	return u.Fighting == 1
}

// IsAlive returns true if the user has HP > 0
func (u *User) IsAlive() bool {
	return u.HP > 0
}

// GetSpellIDs returns spell IDs as a slice of strings
func (u *User) GetSpellIDs() []string {
	if u.Spells == "" {
		return []string{}
	}
	return strings.Split(u.Spells, ",")
}

// SetSpellIDs sets spell IDs from a slice of strings
func (u *User) SetSpellIDs(spells []string) {
	u.Spells = strings.Join(spells, ",")
}

// HasSpell returns true if the user knows the specified spell ID
func (u *User) HasSpell(spellID string) bool {
	spells := u.GetSpellIDs()
	for _, spell := range spells {
		if strings.TrimSpace(spell) == spellID {
			return true
		}
	}
	return false
}

// GetTownIDs returns town IDs as a slice of strings
func (u *User) GetTownIDs() []string {
	if u.Towns == "" {
		return []string{}
	}
	return strings.Split(u.Towns, ",")
}

// SetTownIDs sets town IDs from a slice of strings
func (u *User) SetTownIDs(towns []string) {
	u.Towns = strings.Join(towns, ",")
}

// HasVisitedTown returns true if the user has visited the specified town ID
func (u *User) HasVisitedTown(townID string) bool {
	towns := u.GetTownIDs()
	for _, town := range towns {
		if strings.TrimSpace(town) == townID {
			return true
		}
	}
	return false
}

// GetEquipment returns all equipped item information
func (u *User) GetEquipment() map[string]any {
	return map[string]any{
		"weapon": map[string]any{"id": u.WeaponID, "name": u.WeaponName},
		"armor":  map[string]any{"id": u.ArmorID, "name": u.ArmorName},
		"shield": map[string]any{"id": u.ShieldID, "name": u.ShieldName},
		"slot1":  map[string]any{"id": u.Slot1ID, "name": u.Slot1Name},
		"slot2":  map[string]any{"id": u.Slot2ID, "name": u.Slot2Name},
		"slot3":  map[string]any{"id": u.Slot3ID, "name": u.Slot3Name},
	}
}

// GetStats returns combat-relevant stats
func (u *User) GetStats() map[string]int {
	return map[string]int{
		"level":        u.Level,
		"hp":           u.HP,
		"mp":           u.MP,
		"tp":           u.TP,
		"max_hp":       u.MaxHP,
		"max_mp":       u.MaxMP,
		"max_tp":       u.MaxTP,
		"strength":     u.Strength,
		"dexterity":    u.Dexterity,
		"attack":       u.Attack,
		"defense":      u.Defense,
		"uber_damage":  u.UberDamage,
		"uber_defense": u.UberDefense,
	}
}

// GetPosition returns the user's coordinates
func (u *User) GetPosition() (int, int) {
	return u.X, u.Y
}

// SetPosition sets the user's coordinates
func (u *User) SetPosition(x, y int) {
	u.X = x
	u.Y = y
}

// GetByUsername retrieves a user by username
func GetByUsername(username string) (*User, error) {
	var user *User

	query := `SELECT ` + userColumns() + ` FROM users WHERE LOWER(username) = LOWER(?) LIMIT 1`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		user = scanUser(stmt)
		return nil
	}, username)

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

	if user == nil {
		return nil, fmt.Errorf("user not found: %s", username)
	}

	return user, nil
}

// GetByEmail retrieves a user by email
func GetByEmail(email string) (*User, error) {
	var user *User

	query := `SELECT ` + userColumns() + ` FROM users WHERE LOWER(email) = LOWER(?) LIMIT 1`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		user = scanUser(stmt)
		return nil
	}, email)

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

	if user == nil {
		return nil, fmt.Errorf("user not found: %s", email)
	}

	return user, nil
}

// ToMap converts the user to a map for efficient template rendering
func (u *User) ToMap() map[string]any {
	return map[string]any{
		"ID":            u.ID,
		"Username":      u.Username,
		"Email":         u.Email,
		"Verified":      u.Verified,
		"Token":         u.Token,
		"Registered":    u.Registered,
		"LastOnline":    u.LastOnline,
		"Auth":          u.Auth,
		"X":             u.X,
		"Y":             u.Y,
		"ClassID":       u.ClassID,
		"Currently":     u.Currently,
		"Fighting":      u.Fighting,
		"MonsterID":     u.MonsterID,
		"MonsterHP":     u.MonsterHP,
		"MonsterSleep":  u.MonsterSleep,
		"MonsterImmune": u.MonsterImmune,
		"UberDamage":    u.UberDamage,
		"UberDefense":   u.UberDefense,
		"HP":            u.HP,
		"MP":            u.MP,
		"TP":            u.TP,
		"MaxHP":         u.MaxHP,
		"MaxMP":         u.MaxMP,
		"MaxTP":         u.MaxTP,
		"Level":         u.Level,
		"Gold":          u.Gold,
		"Exp":           u.Exp,
		"GoldBonus":     u.GoldBonus,
		"ExpBonus":      u.ExpBonus,
		"Strength":      u.Strength,
		"Dexterity":     u.Dexterity,
		"Attack":        u.Attack,
		"Defense":       u.Defense,
		"WeaponID":      u.WeaponID,
		"ArmorID":       u.ArmorID,
		"ShieldID":      u.ShieldID,
		"Slot1ID":       u.Slot1ID,
		"Slot2ID":       u.Slot2ID,
		"Slot3ID":       u.Slot3ID,
		"WeaponName":    u.WeaponName,
		"ArmorName":     u.ArmorName,
		"ShieldName":    u.ShieldName,
		"Slot1Name":     u.Slot1Name,
		"Slot2Name":     u.Slot2Name,
		"Slot3Name":     u.Slot3Name,
		"DropCode":      u.DropCode,
		"Spells":        u.Spells,
		"Towns":         u.Towns,

		// Computed values
		"IsVerified":     u.IsVerified(),
		"IsAdmin":        u.IsAdmin(),
		"IsModerator":    u.IsModerator(),
		"IsFighting":     u.IsFighting(),
		"IsAlive":        u.IsAlive(),
		"RegisteredTime": u.RegisteredTime(),
		"LastOnlineTime": u.LastOnlineTime(),
		"Equipment":      u.GetEquipment(),
		"Stats":          u.GetStats(),
		"Position":       map[string]int{"X": u.X, "Y": u.Y},
		"SpellIDs":       u.GetSpellIDs(),
		"TownIDs":        u.GetTownIDs(),
	}
}