package d2records

import (
	"fmt"
	"log"

	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2data"

	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2enum"
	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2fileformats/d2txt"
	"github.com/OpenDiablo2/OpenDiablo2/d2common/d2resource"
)

// NewRecordManager creates a new record manager (no loaders are bound!)
func NewRecordManager() (*RecordManager, error) {
	rm := &RecordManager{
		boundLoaders: make(map[string][]recordLoader),
	}

	err := rm.init()
	if err != nil {
		return nil, err
	}

	return rm, nil
}

// RecordManager stores all of the records loaded from txt files
type RecordManager struct {
	boundLoaders map[string][]recordLoader // there can be more than one loader bound for a file
	Animations   d2data.AnimationData
	BodyLocations
	Calculation struct {
		Skills   Calculations
		Missiles Calculations
	}
	Character struct {
		Classes PlayerClasses
		Events
		Experience ExperienceBreakpoints
		MaxLevel   ExperienceMaxLevels
		Modes      PlayerModes
		Stats      CharStats
	}
	ComponentCodes
	DifficultyLevels
	ElemTypes
	Hirelings
	Item struct {
		All CommonItems // NOTE: populated when armor, weapons, and misc items are ALL loaded

		Armors  CommonItems
		Misc    CommonItems
		Weapons CommonItems

		Equivalency         ItemEquivalenceMap      // NOTE: populated when all items are loaded
		EquivalenceByRecord ItemEquivalenceByRecord // NOTE: populated when all items are loaded

		AutoMagic
		Books
		Gems
		Magic struct {
			Prefix MagicPrefix
			Suffix MagicSuffix
		}
		MagicPrefixGroups ItemAffixGroups
		MagicSuffixGroups ItemAffixGroups
		Quality           ItemQualities
		Rare              struct {
			Prefix RarePrefixes
			Suffix RareSuffixes
		}
		Ratios  ItemRatios
		Recipes CubeRecipes
		Runewords
		Sets
		SetItems
		Stats ItemStatCosts
		TreasureClass
		Types  ItemTypes
		Unique UniqueItems
	}
	Layout struct {
		Inventory
		Overlays
	}
	Level struct {
		AutoMaps
		Details LevelDetails
		Maze    LevelMazeDetails
		Presets LevelPresets
		Sub     LevelSubstitutions
		Types   LevelTypes
		Warp    LevelWarps
	}
	Missiles
	missilesByName
	Monster struct {
		AI         MonsterAI
		Equipment  MonsterEquipment
		Levels     MonsterLevels
		Modes      MonModes
		Placements MonsterPlacements
		Presets    MonPresets
		Props      MonsterProperties
		Sequences  MonsterSequences
		Sounds     MonsterSounds
		Stats      MonStats
		Stats2     MonStats2
		Types      MonsterTypes
		Unique     struct {
			Appellations UniqueAppellations
			Mods         MonsterUniqueModifiers
			Constants    MonsterUniqueModifierConstants
			Super        SuperUniques
		}
	}
	NPCs
	Object struct {
		Details ObjectDetails
		Lookup  IndexedObjects
		Shrines
		Types ObjectTypes
	}
	PetTypes
	Properties
	Skill struct {
		Details      SkillDetails
		Descriptions SkillDescriptions
	}
	Sound struct {
		Details     SoundDetails
		Environment SoundEnvironments
	}
	States
}

func (r *RecordManager) init() error {
	loaders := []struct {
		path   string
		loader recordLoader
	}{
		{d2resource.LevelType, levelTypesLoader},
		{d2resource.LevelPreset, levelPresetLoader},
		{d2resource.LevelWarp, levelWarpsLoader},
		{d2resource.ObjectType, objectTypesLoader},
		{d2resource.ObjectDetails, objectDetailsLoader},
		{d2resource.Weapons, weaponsLoader},
		{d2resource.Armor, armorLoader},
		{d2resource.Misc, miscItemsLoader},
		{d2resource.Books, booksLoader},
		{d2resource.ItemTypes, itemTypesLoader}, // WARN: needs to be after weapons, armor, and misc
		{d2resource.UniqueItems, uniqueItemsLoader},
		{d2resource.Missiles, missilesLoader},
		{d2resource.SoundSettings, soundDetailsLoader},
		{d2resource.MonStats, monsterStatsLoader},
		{d2resource.MonStats2, monsterStats2Loader},
		{d2resource.MonPreset, monsterPresetLoader},
		{d2resource.MonProp, monsterPropertiesLoader},
		{d2resource.MonType, monsterTypesLoader},
		{d2resource.MonMode, monsterModeLoader},
		{d2resource.MagicPrefix, magicPrefixLoader},
		{d2resource.MagicSuffix, magicSuffixLoader},
		{d2resource.ItemStatCost, itemStatCostLoader},
		{d2resource.ItemRatio, itemRatioLoader},
		{d2resource.Overlays, overlaysLoader},
		{d2resource.CharStats, charStatsLoader},
		{d2resource.Hireling, hirelingLoader},
		{d2resource.Experience, experienceLoader},
		{d2resource.Gems, gemsLoader},
		{d2resource.QualityItems, itemQualityLoader},
		{d2resource.Runes, runewordLoader},
		{d2resource.DifficultyLevels, difficultyLevelsLoader},
		{d2resource.AutoMap, autoMapLoader},
		{d2resource.LevelDetails, levelDetailsLoader},
		{d2resource.LevelMaze, levelMazeDetailsLoader},
		{d2resource.LevelSubstitutions, levelSubstitutionsLoader},
		{d2resource.CubeRecipes, cubeRecipeLoader},
		{d2resource.SuperUniques, monsterSuperUniqeLoader},
		{d2resource.Inventory, inventoryLoader},
		{d2resource.Skills, skillDetailsLoader},
		{d2resource.SkillCalc, skillCalcLoader},
		{d2resource.MissileCalc, missileCalcLoader},
		{d2resource.Properties, propertyLoader},
		{d2resource.SkillDesc, skillDescriptionLoader},
		{d2resource.BodyLocations, bodyLocationsLoader},
		{d2resource.Sets, setLoader},
		{d2resource.SetItems, setItemLoader},
		{d2resource.AutoMagic, autoMagicLoader},
		{d2resource.TreasureClass, treasureClassLoader},
		{d2resource.States, statesLoader},
		{d2resource.SoundEnvirons, soundEnvironmentLoader},
		{d2resource.Shrines, shrineLoader},
		{d2resource.ElemType, elemTypesLoader},
		{d2resource.PlrMode, playerModesLoader},
		{d2resource.PetType, petTypesLoader},
		{d2resource.NPC, npcLoader},
		{d2resource.MonsterUniqueModifier, monsterUniqModifiersLoader},
		{d2resource.MonsterEquipment, monsterEquipmentLoader},
		{d2resource.UniqueAppellation, uniqueAppellationsLoader},
		{d2resource.MonsterLevel, monsterLevelsLoader},
		{d2resource.MonsterSound, monsterSoundsLoader},
		{d2resource.MonsterSequence, monsterSequencesLoader},
		{d2resource.PlayerClass, playerClassLoader},
		{d2resource.MonsterPlacement, monsterPlacementsLoader},
		{d2resource.ObjectGroup, objectGroupsLoader},
		{d2resource.CompCode, componentCodesLoader},
		{d2resource.MonsterAI, monsterAiLoader},
		{d2resource.RarePrefix, rareItemPrefixLoader},
		{d2resource.RareSuffix, rareItemSuffixLoader},
		{d2resource.Events, eventsLoader},
	}

	for idx := range loaders {
		err := r.AddLoader(loaders[idx].path, loaders[idx].loader)
		if err != nil {
			return err
		}
	}

	r.initObjectRecords(objectLookups)

	return nil
}

// AddLoader associates a file path with a record loader
func (r *RecordManager) AddLoader(path string, loader recordLoader) error {
	if _, found := r.boundLoaders[path]; !found {
		r.boundLoaders[path] = make([]recordLoader, 0)
	}

	r.boundLoaders[path] = append(r.boundLoaders[path], loader)

	return nil
}

// Load will pass the dictionary to any bound loaders and populate the record entries
func (r *RecordManager) Load(path string, dict *d2txt.DataDictionary) error {
	loaders, found := r.boundLoaders[path]
	if !found {
		return fmt.Errorf("no loader bound for `%s`", path)
	}

	for idx := range loaders {
		err := loaders[idx](r, dict)
		if err != nil {
			return err
		}
	}

	// as soon as Armor, Weapons, and Misc items are loaded, we merge into r.Item.All
	if r.Item.All == nil && r.Item.Armors != nil && r.Item.Weapons != nil && r.Item.Misc != nil {
		r.Item.All = make(CommonItems)

		for code := range r.Item.Armors {
			r.Item.All[code] = r.Item.Armors[code]
		}

		for code := range r.Item.Weapons {
			r.Item.All[code] = r.Item.Weapons[code]
		}

		for code := range r.Item.Misc {
			r.Item.All[code] = r.Item.Misc[code]
		}
	}

	return nil
}

// GetMaxLevelByHero returns the highest level attainable for a hero type
func (r *RecordManager) GetMaxLevelByHero(heroType d2enum.Hero) int {
	return r.Character.MaxLevel[heroType]
}

// GetExperienceBreakpoint given a hero type and a level, returns the experience required for the level
func (r *RecordManager) GetExperienceBreakpoint(heroType d2enum.Hero, level int) int {
	return r.Character.Experience[level].HeroBreakpoints[heroType]
}

// GetLevelDetails gets a LevelDetailsRecord by the record Id
func (r *RecordManager) GetLevelDetails(id int) *LevelDetailsRecord {
	for i := 0; i < len(r.Level.Details); i++ {
		if r.Level.Details[i].ID == id {
			return r.Level.Details[i]
		}
	}

	return nil
}

// LevelPreset looks up a LevelPresetRecord by ID
func (r *RecordManager) LevelPreset(id int) LevelPresetRecord {
	for i := 0; i < len(r.Level.Presets); i++ {
		if r.Level.Presets[i].DefinitionID == id {
			return r.Level.Presets[i]
		}
	}

	panic("Unknown level preset")
}

// FindEquivalentTypesByItemCommonRecord returns itemtype codes that are equivalent
// to the given item common record
func (r *RecordManager) FindEquivalentTypesByItemCommonRecord(
	icr *ItemCommonRecord,
) []string {
	if r.Item.EquivalenceByRecord == nil {
		r.Item.EquivalenceByRecord = make(map[*ItemCommonRecord][]string)
	}

	// the first lookup generates the lookup table entry, next time will just use the table
	if r.Item.EquivalenceByRecord[icr] == nil {
		r.Item.EquivalenceByRecord[icr] = make([]string, 0)

		for code := range r.Item.Equivalency {
			icrList := r.Item.Equivalency[code]
			for idx := range icrList {
				if icr == icrList[idx] {
					r.Item.EquivalenceByRecord[icr] = append(r.Item.EquivalenceByRecord[icr], code)
					break
				}
			}
		}
	}

	return r.Item.EquivalenceByRecord[icr]
}

func (r *RecordManager) initObjectRecords(lookups []ObjectLookupRecord) {
	// Allocating 6 to allow Acts 1-5 without requiring a -1 at every read.
	records := make(IndexedObjects, 6)

	for i := range lookups {
		record := &lookups[i]
		if records[record.Act] == nil {
			// Likewise allocating 3 so a -1 isn't necessary.
			records[record.Act] = make([][]*ObjectLookupRecord, 3)
		}

		if records[record.Act][record.Type] == nil {
			// For simplicity, allocating with length 1000 then filling the values in by index.
			// If ids in the dictionary ever surpass 1000, raise this number.
			records[record.Act][record.Type] = make([]*ObjectLookupRecord, 1000)
		}

		records[record.Act][record.Type][record.Id] = record
	}

	r.Object.Lookup = records
}

// LookupObject looks up an object record
func (r *RecordManager) LookupObject(act, typ, id int) *ObjectLookupRecord {
	object := r.lookupObject(act, typ, id)
	if object == nil {
		log.Panicf("Failed to look up object Act: %d, Type: %d, ID: %d", act, typ, id)
	}

	return object
}

func (r *RecordManager) lookupObject(act, typ, id int) *ObjectLookupRecord {
	if len(r.Object.Lookup) < act {
		return nil
	}

	if len(r.Object.Lookup[act]) < typ {
		return nil
	}

	if len(r.Object.Lookup[act][typ]) < id {
		return nil
	}

	return r.Object.Lookup[act][typ][id]
}

// SelectSoundByIndex selects a sound by its ID
func (r *RecordManager) SelectSoundByIndex(index int) *SoundDetailsRecord {
	for idx := range r.Sound.Details {
		if r.Sound.Details[idx].Index == index {
			return r.Sound.Details[idx]
		}
	}

	return nil
}

// GetSkillByName returns the skill record for the given Skill name.
func (r *RecordManager) GetSkillByName(skillName string) *SkillRecord {
	for idx := range r.Skill.Details {
		if r.Skill.Details[idx].Skill == skillName {
			return r.Skill.Details[idx]
		}
	}

	return nil
}

// GetMissileByName allows lookup of a MissileRecord by a given name. The name will be lowercased and stripped of whitespaces.
func (r *RecordManager) GetMissileByName(missileName string) *MissileRecord {
	return r.missilesByName[sanitizeMissilesKey(missileName)]
}