package functions

import (
	"fmt"

	"eq2emu/internal/events"
)

// Attribute and Stats Management Functions

// SetInt sets the spawn's Intelligence attribute
func SetInt(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	value := ctx.GetParameterInt("value", 0)
	if value < 0 {
		value = 0
	}

	// TODO: Implement INT stat when InfoStruct is available
	ctx.Debug("Set INT to %d for spawn %s (not yet implemented)", value, spawn.GetName())
	ctx.SetResult("int", value)
	return nil
}

// SetWis sets the spawn's Wisdom attribute
func SetWis(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	value := ctx.GetParameterInt("value", 0)
	if value < 0 {
		value = 0
	}

	// TODO: Implement WIS stat when InfoStruct is available
	ctx.Debug("Set WIS to %d for spawn %s (not yet implemented)", value, spawn.GetName())
	ctx.SetResult("wis", value)
	return nil
}

// SetSta sets the spawn's Stamina attribute
func SetSta(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	value := ctx.GetParameterInt("value", 0)
	if value < 0 {
		value = 0
	}

	// TODO: Implement STA stat when InfoStruct is available
	ctx.Debug("Set STA to %d for spawn %s (not yet implemented)", value, spawn.GetName())
	ctx.SetResult("sta", value)
	return nil
}

// SetStr sets the spawn's Strength attribute
func SetStr(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	value := ctx.GetParameterInt("value", 0)
	if value < 0 {
		value = 0
	}

	// TODO: Implement STR stat when InfoStruct is available
	ctx.Debug("Set STR to %d for spawn %s (not yet implemented)", value, spawn.GetName())
	ctx.SetResult("str", value)
	return nil
}

// SetAgi sets the spawn's Agility attribute
func SetAgi(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	value := ctx.GetParameterInt("value", 0)
	if value < 0 {
		value = 0
	}

	// TODO: Implement AGI stat when InfoStruct is available
	ctx.Debug("Set AGI to %d for spawn %s (not yet implemented)", value, spawn.GetName())
	ctx.SetResult("agi", value)
	return nil
}

// SetIntBase sets the spawn's base Intelligence (before bonuses)
func SetIntBase(ctx *events.EventContext) error {
	// TODO: Implement base stats system
	return SetInt(ctx) // Fallback for now
}

// SetWisBase sets the spawn's base Wisdom (before bonuses)
func SetWisBase(ctx *events.EventContext) error {
	// TODO: Implement base stats system
	return SetWis(ctx) // Fallback for now
}

// SetStaBase sets the spawn's base Stamina (before bonuses)
func SetStaBase(ctx *events.EventContext) error {
	// TODO: Implement base stats system
	return SetSta(ctx) // Fallback for now
}

// SetStrBase sets the spawn's base Strength (before bonuses)
func SetStrBase(ctx *events.EventContext) error {
	// TODO: Implement base stats system
	return SetStr(ctx) // Fallback for now
}

// SetAgiBase sets the spawn's base Agility (before bonuses)
func SetAgiBase(ctx *events.EventContext) error {
	// TODO: Implement base stats system
	return SetAgi(ctx) // Fallback for now
}

// GetInt gets the spawn's Intelligence attribute
func GetInt(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	// TODO: Implement INT stat retrieval when InfoStruct is available
	ctx.SetResult("int", 10) // Default value
	return nil
}

// GetWis gets the spawn's Wisdom attribute
func GetWis(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	// TODO: Implement WIS stat retrieval when InfoStruct is available
	ctx.SetResult("wis", 10) // Default value
	return nil
}

// GetSta gets the spawn's Stamina attribute
func GetSta(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	// TODO: Implement STA stat retrieval when InfoStruct is available
	ctx.SetResult("sta", 10) // Default value
	return nil
}

// GetStr gets the spawn's Strength attribute
func GetStr(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	// TODO: Implement STR stat retrieval when InfoStruct is available
	ctx.SetResult("str", 10) // Default value
	return nil
}

// GetAgi gets the spawn's Agility attribute
func GetAgi(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	// TODO: Implement AGI stat retrieval when InfoStruct is available
	ctx.SetResult("agi", 10) // Default value
	return nil
}

// GetIntBase gets the spawn's base Intelligence (before bonuses)
func GetIntBase(ctx *events.EventContext) error {
	// TODO: Implement base stats system
	return GetInt(ctx) // Fallback for now
}

// GetWisBase gets the spawn's base Wisdom (before bonuses)
func GetWisBase(ctx *events.EventContext) error {
	// TODO: Implement base stats system
	return GetWis(ctx) // Fallback for now
}

// GetStaBase gets the spawn's base Stamina (before bonuses)
func GetStaBase(ctx *events.EventContext) error {
	// TODO: Implement base stats system
	return GetSta(ctx) // Fallback for now
}

// GetStrBase gets the spawn's base Strength (before bonuses)
func GetStrBase(ctx *events.EventContext) error {
	// TODO: Implement base stats system
	return GetStr(ctx) // Fallback for now
}

// GetAgiBase gets the spawn's base Agility (before bonuses)
func GetAgiBase(ctx *events.EventContext) error {
	// TODO: Implement base stats system
	return GetAgi(ctx) // Fallback for now
}

// GetLevel gets the spawn's level
func GetLevel(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	ctx.SetResult("level", spawn.GetLevel())
	return nil
}

// SetLevel sets the spawn's level
func SetLevel(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	level := ctx.GetParameterInt("level", 1)
	if level < 1 {
		level = 1
	}
	if level > 100 {
		level = 100
	}

	spawn.SetLevel(int16(level))
	ctx.Debug("Set level to %d for spawn %s", level, spawn.GetName())
	return nil
}

// SetPlayerLevel sets the player's level (with additional processing)
func SetPlayerLevel(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	if !spawn.IsPlayer() {
		return fmt.Errorf("spawn is not a player")
	}

	// TODO: Add player-specific level processing (skill updates, etc.)
	return SetLevel(ctx)
}

// GetDifficulty gets the spawn's difficulty rating
func GetDifficulty(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	// TODO: Implement difficulty calculation based on level, class, etc.
	difficulty := int(spawn.GetLevel()) // Simple implementation for now
	ctx.SetResult("difficulty", difficulty)
	return nil
}

// AddSpellBonus adds a spell bonus to the spawn
func AddSpellBonus(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	bonusType := ctx.GetParameterInt("bonus_type", 0)
	value := ctx.GetParameterFloat("value", 0)
	spellID := ctx.GetParameterInt("spell_id", 0)

	// TODO: Implement spell bonus system when available
	ctx.Debug("Added spell bonus (type: %d, value: %f, spell: %d) to spawn %s (not yet implemented)", 
		bonusType, value, spellID, spawn.GetName())
	
	return nil
}

// RemoveSpellBonus removes a spell bonus from the spawn
func RemoveSpellBonus(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	bonusType := ctx.GetParameterInt("bonus_type", 0)
	spellID := ctx.GetParameterInt("spell_id", 0)

	// TODO: Implement spell bonus system when available
	ctx.Debug("Removed spell bonus (type: %d, spell: %d) from spawn %s (not yet implemented)", 
		bonusType, spellID, spawn.GetName())
	
	return nil
}

// AddSkillBonus adds a skill bonus to the spawn
func AddSkillBonus(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	skillType := ctx.GetParameterInt("skill_type", 0)
	value := ctx.GetParameterFloat("value", 0)

	// TODO: Implement skill bonus system when available
	ctx.Debug("Added skill bonus (type: %d, value: %f) to spawn %s (not yet implemented)", 
		skillType, value, spawn.GetName())
	
	return nil
}

// RemoveSkillBonus removes a skill bonus from the spawn
func RemoveSkillBonus(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	skillType := ctx.GetParameterInt("skill_type", 0)

	// TODO: Implement skill bonus system when available
	ctx.Debug("Removed skill bonus (type: %d) from spawn %s (not yet implemented)", 
		skillType, spawn.GetName())
	
	return nil
}

// GetClass gets the spawn's class
func GetClass(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	ctx.SetResult("class", spawn.GetClass())
	return nil
}

// SetClass sets the spawn's class
func SetClass(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	class := ctx.GetParameterInt("class", 0)
	spawn.SetClass(int8(class))
	ctx.Debug("Set class to %d for spawn %s", class, spawn.GetName())
	return nil
}

// SetAdventureClass sets the spawn's adventure class
func SetAdventureClass(ctx *events.EventContext) error {
	return SetClass(ctx) // Alias for SetClass
}

// GetTradeskillClass gets the spawn's tradeskill class
func GetTradeskillClass(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	ctx.SetResult("tradeskill_class", spawn.GetTradeskillClass())
	return nil
}

// SetTradeskillClass sets the spawn's tradeskill class
func SetTradeskillClass(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	tsClass := ctx.GetParameterInt("tradeskill_class", 0)
	spawn.SetTradeskillClass(int8(tsClass))
	ctx.Debug("Set tradeskill class to %d for spawn %s", tsClass, spawn.GetName())
	return nil
}

// GetTradeskillLevel gets the spawn's tradeskill level
func GetTradeskillLevel(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	// TODO: Implement tradeskill level when available
	ctx.SetResult("tradeskill_level", 1) // Default value
	return nil
}

// SetTradeskillLevel sets the spawn's tradeskill level
func SetTradeskillLevel(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	level := ctx.GetParameterInt("level", 1)
	if level < 1 {
		level = 1
	}
	if level > 100 {
		level = 100
	}

	// TODO: Implement tradeskill level when available
	ctx.Debug("Set tradeskill level to %d for spawn %s (not yet implemented)", level, spawn.GetName())
	return nil
}

// GetRace gets the spawn's race
func GetRace(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	ctx.SetResult("race", spawn.GetRace())
	return nil
}

// GetGender gets the spawn's gender
func GetGender(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	ctx.SetResult("gender", spawn.GetGender())
	return nil
}

// GetModelType gets the spawn's model type
func GetModelType(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	// TODO: Implement model type when available
	ctx.SetResult("model_type", 0) // Default value
	return nil
}

// SetModelType sets the spawn's model type
func SetModelType(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	modelType := ctx.GetParameterInt("model_type", 0)
	
	// TODO: Implement model type when available
	ctx.Debug("Set model type to %d for spawn %s (not yet implemented)", modelType, spawn.GetName())
	return nil
}

// GetDeity gets the spawn's deity
func GetDeity(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	// TODO: Implement deity system when available
	ctx.SetResult("deity", 0) // Default value
	return nil
}

// SetDeity sets the spawn's deity
func SetDeity(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	deity := ctx.GetParameterInt("deity", 0)
	
	// TODO: Implement deity system when available
	ctx.Debug("Set deity to %d for spawn %s (not yet implemented)", deity, spawn.GetName())
	return nil
}

// GetAlignment gets the spawn's alignment
func GetAlignment(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	// TODO: Implement alignment system when available
	ctx.SetResult("alignment", 0) // Default value (neutral)
	return nil
}

// SetAlignment sets the spawn's alignment
func SetAlignment(ctx *events.EventContext) error {
	spawn := ctx.GetSpawn()
	if spawn == nil {
		return fmt.Errorf("no spawn in context")
	}

	alignment := ctx.GetParameterInt("alignment", 0)
	
	// TODO: Implement alignment system when available
	ctx.Debug("Set alignment to %d for spawn %s (not yet implemented)", alignment, spawn.GetName())
	return nil
}