Dragon-Knight/internal/monsters/monsters.go

package monsters

import (
	"fmt"

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

	"zombiezen.com/go/sqlite"
)

// Monster represents a monster in the database
type Monster struct {
	ID      int    `db:"id" json:"id"`
	Name    string `db:"name" json:"name"`
	MaxHP   int    `db:"max_hp" json:"max_hp"`
	MaxDmg  int    `db:"max_dmg" json:"max_dmg"`
	Armor   int    `db:"armor" json:"armor"`
	Level   int    `db:"level" json:"level"`
	MaxExp  int    `db:"max_exp" json:"max_exp"`
	MaxGold int    `db:"max_gold" json:"max_gold"`
	Immune  int    `db:"immune" json:"immune"`
}

// New creates a new Monster with sensible defaults
func New() *Monster {
	return &Monster{
		Name:    "",
		MaxHP:   10,        // Default HP
		MaxDmg:  5,         // Default damage
		Armor:   0,         // Default armor
		Level:   1,         // Default level
		MaxExp:  10,        // Default exp reward
		MaxGold: 5,         // Default gold reward
		Immune:  ImmuneNone, // No immunity by default
	}
}

var monsterScanner = scanner.New[Monster]()

// monsterColumns returns the column list for monster queries
func monsterColumns() string {
	return monsterScanner.Columns()
}

// scanMonster populates a Monster struct using the fast scanner
func scanMonster(stmt *sqlite.Stmt) *Monster {
	monster := &Monster{}
	monsterScanner.Scan(stmt, monster)
	return monster
}

// Immunity constants for monster immunity types
const (
	ImmuneNone  = 0
	ImmuneHurt  = 1 // Immune to Hurt spells
	ImmuneSleep = 2 // Immune to Sleep spells
)

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

	query := `SELECT ` + monsterColumns() + ` FROM monsters WHERE id = ?`

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

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

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

	return monster, nil
}

// All retrieves all monsters
func All() ([]*Monster, error) {
	var monsters []*Monster

	query := `SELECT ` + monsterColumns() + ` FROM monsters ORDER BY level, id`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		monster := scanMonster(stmt)
		monsters = append(monsters, monster)
		return nil
	})

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

	return monsters, nil
}

// ByLevel retrieves monsters by level
func ByLevel(level int) ([]*Monster, error) {
	var monsters []*Monster

	query := `SELECT ` + monsterColumns() + ` FROM monsters WHERE level = ? ORDER BY id`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		monster := scanMonster(stmt)
		monsters = append(monsters, monster)
		return nil
	}, level)

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

	return monsters, nil
}

// ByLevelRange retrieves monsters within a level range (inclusive)
func ByLevelRange(minLevel, maxLevel int) ([]*Monster, error) {
	var monsters []*Monster

	query := `SELECT ` + monsterColumns() + ` FROM monsters WHERE level BETWEEN ? AND ? ORDER BY level, id`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		monster := scanMonster(stmt)
		monsters = append(monsters, monster)
		return nil
	}, minLevel, maxLevel)

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

	return monsters, nil
}

// ByImmunity retrieves monsters by immunity type
func ByImmunity(immunityType int) ([]*Monster, error) {
	var monsters []*Monster

	query := `SELECT ` + monsterColumns() + ` FROM monsters WHERE immune = ? ORDER BY level, id`

	err := database.Query(query, func(stmt *sqlite.Stmt) error {
		monster := scanMonster(stmt)
		monsters = append(monsters, monster)
		return nil
	}, immunityType)

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

	return monsters, nil
}

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

	query := `UPDATE monsters SET name = ?, max_hp = ?, max_dmg = ?, armor = ?, level = ?, max_exp = ?, max_gold = ?, immune = ? WHERE id = ?`
	return database.Exec(query, m.Name, m.MaxHP, m.MaxDmg, m.Armor, m.Level, m.MaxExp, m.MaxGold, m.Immune, m.ID)
}

// Insert saves a new monster to the database and sets the ID
func (m *Monster) Insert() error {
	if m.ID != 0 {
		return fmt.Errorf("monster already has ID %d, use Save() to update", m.ID)
	}

	// Use a transaction to ensure we can get the ID
	err := database.Transaction(func(tx *database.Tx) error {
		query := `INSERT INTO monsters (name, max_hp, max_dmg, armor, level, max_exp, max_gold, immune) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`

		if err := tx.Exec(query, m.Name, m.MaxHP, m.MaxDmg, m.Armor, m.Level, m.MaxExp, m.MaxGold, m.Immune); err != nil {
			return fmt.Errorf("failed to insert monster: %w", err)
		}

		// Get the last insert ID
		var id int
		err := tx.Query("SELECT last_insert_rowid()", func(stmt *sqlite.Stmt) error {
			id = stmt.ColumnInt(0)
			return nil
		})
		if err != nil {
			return fmt.Errorf("failed to get insert ID: %w", err)
		}

		m.ID = id
		return nil
	})

	return err
}

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

	query := "DELETE FROM monsters WHERE id = ?"
	return database.Exec(query, m.ID)
}

// IsHurtImmune returns true if the monster is immune to Hurt spells
func (m *Monster) IsHurtImmune() bool {
	return m.Immune == ImmuneHurt
}

// IsSleepImmune returns true if the monster is immune to Sleep spells
func (m *Monster) IsSleepImmune() bool {
	return m.Immune == ImmuneSleep
}

// HasImmunity returns true if the monster has any immunity
func (m *Monster) HasImmunity() bool {
	return m.Immune != ImmuneNone
}

// ImmunityName returns the string representation of the monster's immunity
func (m *Monster) ImmunityName() string {
	switch m.Immune {
	case ImmuneNone:
		return "None"
	case ImmuneHurt:
		return "Hurt Spells"
	case ImmuneSleep:
		return "Sleep Spells"
	default:
		return "Unknown"
	}
}

// DifficultyRating calculates a simple difficulty rating based on stats
func (m *Monster) DifficultyRating() float64 {
	// Simple formula: (HP + Damage + Armor) / Level
	// Higher values indicate tougher monsters relative to their level
	if m.Level == 0 {
		return 0
	}
	return float64(m.MaxHP+m.MaxDmg+m.Armor) / float64(m.Level)
}

// ExpPerHP returns the experience reward per hit point (efficiency metric)
func (m *Monster) ExpPerHP() float64 {
	if m.MaxHP == 0 {
		return 0
	}
	return float64(m.MaxExp) / float64(m.MaxHP)
}

// GoldPerHP returns the gold reward per hit point (efficiency metric)
func (m *Monster) GoldPerHP() float64 {
	if m.MaxHP == 0 {
		return 0
	}
	return float64(m.MaxGold) / float64(m.MaxHP)
}

// ToMap converts the monster to a map for efficient template rendering
func (m *Monster) ToMap() map[string]any {
	return map[string]any{
		"ID":      m.ID,
		"Name":    m.Name,
		"MaxHP":   m.MaxHP,
		"MaxDmg":  m.MaxDmg,
		"Armor":   m.Armor,
		"Level":   m.Level,
		"MaxExp":  m.MaxExp,
		"MaxGold": m.MaxGold,
		"Immune":  m.Immune,
		
		// Computed values
		"IsHurtImmune":    m.IsHurtImmune(),
		"IsSleepImmune":   m.IsSleepImmune(),
		"HasImmunity":     m.HasImmunity(),
		"ImmunityName":    m.ImmunityName(),
		"DifficultyRating": m.DifficultyRating(),
		"ExpPerHP":        m.ExpPerHP(),
		"GoldPerHP":       m.GoldPerHP(),
	}
}