using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Windows.Forms;
using Base;
using Base.Data_Classes;
using Base.IO_Classes;
using Base.Master_Classes;
using HeroDesigner.Schema;

public static class DatabaseAPI
{
    static readonly IDictionary<string, int> AttribMod = new Dictionary<string, int>();

    static readonly IDictionary<string, int> Classes = new Dictionary<string, int>();

    public const int HeroAccolades = 3257;
    public const int VillainAccolades = 3258;
    public const int TempPowers = 3259;

    public static IDatabase Database
        => Base.Data_Classes.Database.Instance;

    static void ClearLookups()
    {
        AttribMod.Clear();
        Classes.Clear();
    }

    public static int NidFromUidAttribMod(string uID)
    {
        if (string.IsNullOrEmpty(uID))
            return -1;
        if (AttribMod.ContainsKey(uID))
            return AttribMod[uID];
        for (int index = 0; index <= Database.AttribMods.Modifier.Length - 1; ++index)
        {
            if (!string.Equals(uID, Database.AttribMods.Modifier[index].ID, StringComparison.OrdinalIgnoreCase))
                continue;
            AttribMod.Add(uID, index);
            return index;
        }
        return -1;
    }

    public static int NidFromUidClass(string uidClass)
    {
        if (string.IsNullOrEmpty(uidClass))
            return -1;
        if (Classes.ContainsKey(uidClass))
            return Classes[uidClass];
        var index = Database.Classes.TryFindIndex(cls => string.Equals(uidClass, cls.ClassName, StringComparison.OrdinalIgnoreCase));
        if (index >= 0)
            Classes.Add(uidClass, index);
        return index;
    }

    public static string UidFromNidClass(int nIDClass) => nIDClass < 0 || nIDClass > Database.Classes.Length ? string.Empty : Database.Classes[nIDClass].ClassName;

    public static int NidFromUidOrigin(string uidOrigin, int nIDClass)
    {
        if (nIDClass < 0)
            return -1;
        return Database.Classes[nIDClass].Origin.TryFindIndex(o => string.Equals(o, uidOrigin, StringComparison.OrdinalIgnoreCase));
    }

    static void FillGroupArray()
    {
        Database.PowersetGroups = new Dictionary<string, PowersetGroup>();
        foreach (IPowerset powerset in Database.Powersets)
        {
            if (string.IsNullOrEmpty(powerset.GroupName))
                continue;
            if (!Database.PowersetGroups.TryGetValue(powerset.GroupName, out PowersetGroup powersetGroup))
            {
                powersetGroup = new PowersetGroup(powerset.GroupName);
                Database.PowersetGroups.Add(powerset.GroupName, powersetGroup);
            }
            powersetGroup.Powersets.Add(powerset.FullName, powerset);
            powerset.SetGroup(powersetGroup);
        }
    }

    public static int NidFromUidPowerset(string uidPowerset)
         => GetPowersetByName(uidPowerset)?.nID ?? -1;

    public static int NidFromStaticIndexPower(int sidPower)
    {
        if (sidPower < 0)
            return -1;
        return Database.Power.TryFindIndex(p => p.StaticIndex == sidPower);
    }

    public static int NidFromUidPower(string name)
        => GetPowerByName(name)?.PowerIndex ?? -1;

    public static int NidFromUidEntity(string uidEntity)
        => Database.Entities.TryFindIndex(se => string.Equals(se.UID, uidEntity, StringComparison.OrdinalIgnoreCase));

    public static int[] NidSets(PowersetGroup group, int nIDClass, Enums.ePowerSetType nType) // clsI12Lookup.vb
    {
        if ((nType == Enums.ePowerSetType.Inherent || nType == Enums.ePowerSetType.Pool) && nIDClass > -1 && !Database.Classes[nIDClass].Playable)
            return Array.Empty<int>();


        IPowerset[] powersetArray = Database.Powersets;
        if (group != null)
        {
            powersetArray = group.Powersets.Select(powerset => powerset.Value).ToArray();
        }

        List<int> intList = new List<int>();
        bool checkType = nType != Enums.ePowerSetType.None;
        bool checkClass = nIDClass > -1;
        foreach (IPowerset powerset in powersetArray)
        {
            bool isOk = !checkType || powerset.SetType == nType;
            if (checkClass & isOk)
            {
                if ((powerset.SetType == Enums.ePowerSetType.Primary || powerset.SetType == Enums.ePowerSetType.Secondary) && powerset.nArchetype != nIDClass & powerset.nArchetype > -1)
                    isOk = false;
                if (powerset.Powers.Length > 0 && isOk && (powerset.SetType != Enums.ePowerSetType.Inherent && powerset.SetType != Enums.ePowerSetType.Accolade) && powerset.SetType != Enums.ePowerSetType.Temp && !powerset.Powers[0].Requires.ClassOk(nIDClass))
                    isOk = false;
            }
            if (isOk)
                intList.Add(powerset.nID);
        }
        return intList.ToArray();
    }

    public static int[] NidSets(string uidGroup, string uidClass, Enums.ePowerSetType nType)
        => NidSets(Database.PowersetGroups.ContainsKey(uidGroup) ? Database.PowersetGroups[uidGroup] : null, NidFromUidClass(uidClass), nType);

    public static int[] NidPowers(int nIDPowerset, int nIDClass = -1)
    {
        if (nIDPowerset < 0 || nIDPowerset > Database.Powersets.Length - 1)
        {
            //return Enumerable.Range(0, Database.Powersets.Length).ToArray();
            var array = new int[Database.Power.Length];
            for (int index = 0; index < Database.Power.Length; ++index)
                array[index] = index;
            return array;
        }

        var powerset = Database.Powersets[nIDPowerset];
        return powerset.Powers.FindIndexes(pow => pow.Requires.ClassOk(nIDClass)).Select(idx => powerset.Power[idx]).ToArray();
    }

    public static int[] NidPowers(string uidPowerset, string uidClass = "") => NidPowers(NidFromUidPowerset(uidPowerset), NidFromUidClass(uidClass));

    public static string[] UidPowers(string uidPowerset, string uidClass = "")
    {
        if (!string.IsNullOrEmpty(uidPowerset))
            return Database.Power.Where(pow => string.Equals(pow.FullSetName, uidPowerset, StringComparison.OrdinalIgnoreCase) && pow.Requires.ClassOk(uidClass)).Select(pow => pow.FullName).ToArray();
        var array = new string[Database.Power.Length];
        for (int index = 0; index < Database.Power.Length; ++index)
            array[index] = Database.Power[index].FullName;
        return array;
    }

    static int[] NidPowersAtLevel(int iLevel, int nIDPowerset)
        => nIDPowerset < 0 ?
            Array.Empty<int>() :
            Database.Powersets[nIDPowerset].Powers.Where(pow => pow.Level - 1 == iLevel).Select(pow => pow.PowerIndex).ToArray();

    public static int[] NidPowersAtLevelBranch(int iLevel, int nIDPowerset)
    {
        if (nIDPowerset < 0)
            return Array.Empty<int>();
        if (Database.Powersets[nIDPowerset].nIDTrunkSet < 0)
            return NidPowersAtLevel(iLevel, nIDPowerset);

        int[] powerset1 = NidPowersAtLevel(iLevel, nIDPowerset);
        int[] powerset2 = NidPowersAtLevel(iLevel, Database.Powersets[nIDPowerset].nIDTrunkSet);
        return powerset2.Concat(powerset1).ToArray();
    }

    public static string[] UidMutexAll()
    {
        var items = Database.Power.SelectMany(pow => pow.GroupMembership).Distinct(StringComparer.OrdinalIgnoreCase).ToList();
        items.Sort();
        return items.ToArray();
    }

    public static IPowerset GetPowersetByName(string iName)
    {
        string[] strArray = iName.Split('.');
        if (strArray.Length < 2)
            return null;

        if (strArray.Length > 2)
            iName = $"{strArray[0]}.{strArray[1]}";
        string key = strArray[0];
        if (!Database.PowersetGroups.ContainsKey(key))
            return null;
        PowersetGroup powersetGroup = Database.PowersetGroups[key];
        return powersetGroup.Powersets.ContainsKey(iName) ? powersetGroup.Powersets[iName] : null;
    }

    public static IPowerset GetPowersetByName(string iName, string iArchetype)
    {
        int idx = GetArchetypeByName(iArchetype).Idx;
        foreach (IPowerset powerset1 in Database.Powersets)
        {
            if ((idx != powerset1.nArchetype && powerset1.nArchetype != -1) ||
                !string.Equals(iName, powerset1.DisplayName, StringComparison.OrdinalIgnoreCase))
                continue;
            if (powerset1.SetType != Enums.ePowerSetType.Ancillary)
                return powerset1;
            if (powerset1.Power.Length > 0 && powerset1.Powers[0].Requires.ClassOk(idx))
                return powerset1;
        }
        return null;
    }
    //Pine
    public static IPowerset GetPowersetByName(string iName, Enums.ePowerSetType iSet)
    {
        return Database.Powersets.FirstOrDefault(powerset => iSet == powerset.SetType && string.Equals(iName, powerset.DisplayName, StringComparison.OrdinalIgnoreCase));
    }

    public static IPowerset GetPowersetByID(string iName, Enums.ePowerSetType iSet)
        => Database.Powersets.FirstOrDefault(ps => iSet == ps.SetType && string.Equals(iName, ps.SetName, StringComparison.OrdinalIgnoreCase));

    public static IPowerset GetInherentPowerset()
        => Database.Powersets.FirstOrDefault(ps => ps.SetType == Enums.ePowerSetType.Inherent);

    public static Archetype GetArchetypeByName(string iArchetype)
        => Database.Classes.FirstOrDefault(cls => string.Equals(iArchetype, cls.DisplayName, StringComparison.OrdinalIgnoreCase));

    public static int GetOriginByName(Archetype archetype, string iOrigin)
    {
        for (int index = 0; index <= archetype.Origin.Length - 1; ++index)
        {
            if (string.Equals(iOrigin, archetype.Origin[index], StringComparison.OrdinalIgnoreCase))
                return index;
        }
        return 0;
    }

    public static int GetPowerByName(string iName, int iArchetype)
    {
        for (int index = 0; index <= Database.Power.Length - 1; ++index)
        {
            int num = -1;
            if (Database.Power[index].PowerSetID > -1)
                num = Database.Powersets[Database.Power[index].PowerSetID].nArchetype;
            if ((iArchetype == num || num == -1) && string.Equals(iName, Database.Power[index].DisplayName))
                return index;
        }
        return -1;
    }

    public static IPower GetPowerByName(string name)
    {
        if (string.IsNullOrEmpty(name))
            return null;
        IPowerset powersetByName = GetPowersetByName(name);

        return powersetByName?.Powers.FirstOrDefault(power2 => string.Equals(power2.FullName, name, StringComparison.OrdinalIgnoreCase));
    }

    public static string[] GetPowersetNames(int iAT, Enums.ePowerSetType iSet)
    {
        List<string> stringList = new List<string>();
        if (iSet != Enums.ePowerSetType.Pool && iSet != Enums.ePowerSetType.Inherent)
        {
            int[] numArray = Array.Empty<int>();
            switch (iSet)
            {
                case Enums.ePowerSetType.Primary:
                    numArray = Database.Classes[iAT].Primary;
                    break;
                case Enums.ePowerSetType.Secondary:
                    numArray = Database.Classes[iAT].Secondary;
                    break;
                case Enums.ePowerSetType.Ancillary:
                    numArray = Database.Classes[iAT].Ancillary;
                    break;
            }

            stringList.AddRange(numArray.Select(index => Database.Powersets[index].DisplayName));
        }
        else
        {
            stringList.AddRange(from powerset in Database.Powersets where powerset.SetType == iSet select powerset.DisplayName);
        }
        stringList.Sort();
        return stringList.Count > 0 ? stringList.ToArray() : new[] { "No " + Enum.GetName(iSet.GetType(), iSet) };
    }

    public static int[] GetPowersetIndexesByGroup(PowersetGroup group)
    {
        return group.Powersets.Select(powerset => powerset.Value.nID).ToArray();
    }

    public static int[] GetPowersetIndexesByGroupName(string name)
        => !string.IsNullOrEmpty(name) && Database.PowersetGroups.ContainsKey(name) ? GetPowersetIndexesByGroup(Database.PowersetGroups[name]) : new int[1];

    public static IPowerset[] GetPowersetIndexes(Archetype at, Enums.ePowerSetType iSet)
        => GetPowersetIndexes(at.Idx, iSet);

    public static IPowerset[] GetPowersetIndexes(int iAT, Enums.ePowerSetType iSet)
    {
        List<IPowerset> powersetList = new List<IPowerset>();
        if (iSet != Enums.ePowerSetType.Pool & iSet != Enums.ePowerSetType.Inherent)
        {
            foreach (var ps in Database.Powersets)
            {
                if (ps.nArchetype == iAT & ps.SetType == iSet)
                    powersetList.Add(ps);
                else if (iSet == Enums.ePowerSetType.Ancillary & ps.SetType == iSet && ps.ClassOk(iAT))
                    powersetList.Add(ps);
            }
        }
        else
        {
            for (int index = 0; index <= Database.Powersets.Length - 1; ++index)
            {
                if (Database.Powersets[index].SetType == iSet)
                    powersetList.Add(Database.Powersets[index]);
            }
        }
        powersetList.Sort();
        return powersetList.ToArray();
    }

    public static int ToDisplayIndex(IPowerset iPowerset, IPowerset[] iIndexes)
    {
        for (int index = 0; index <= iIndexes.Length - 1; ++index)
        {
            if (iIndexes[index].nID == iPowerset.nID)
                return index;
        }
        return iIndexes.Length > 0 ? 0 : -1;
    }

    public static int GetEnhancementByUIDName(string iName)
        => Database.Enhancements.TryFindIndex(enh => enh.UID.Contains(iName));

    public static int GetEnhancementByName(string iName)
        => Database.Enhancements.TryFindIndex(enh => string.Equals(enh.ShortName, iName, StringComparison.OrdinalIgnoreCase) || string.Equals(enh.Name, iName, StringComparison.OrdinalIgnoreCase));

    public static int GetEnhancementByName(string iName, Enums.eType iType)
        => Database.Enhancements.TryFindIndex(enh => enh.TypeID == iType && string.Equals(enh.ShortName, iName, StringComparison.OrdinalIgnoreCase) || string.Equals(enh.Name, iName, StringComparison.OrdinalIgnoreCase));

    public static int GetEnhancementByName(string iName, string iSet)
    {
        foreach (EnhancementSet enhancementSet in Database.EnhancementSets)
        {
            if (!string.Equals(enhancementSet.ShortName, iSet, StringComparison.OrdinalIgnoreCase))
                continue;
            foreach (int enhancement in enhancementSet.Enhancements)
            {
                if (string.Equals(Database.Enhancements[enhancementSet.Enhancements[enhancement]].ShortName, iName, StringComparison.OrdinalIgnoreCase))
                    return enhancementSet.Enhancements[enhancement];
            }
        }
        return -1;
    }

    public static int FindEnhancement(string setName, string enhName, int iType, int fallBack)
    {
        for (int index = 0; index < Database.Enhancements.Length; ++index)
        {
            if (Database.Enhancements[index].TypeID != (Enums.eType) iType || !string.Equals(Database.Enhancements[index].ShortName, enhName,
                    StringComparison.OrdinalIgnoreCase))
                continue;
            int num;
            if (Database.Enhancements[index].TypeID != Enums.eType.SetO)
                num = index;
            else if (Database.EnhancementSets[Database.Enhancements[index].nIDSet].DisplayName.Equals(setName, StringComparison.OrdinalIgnoreCase))
                num = index;
            else
                continue;
            return num;
        }
        if (fallBack > -1 & fallBack < Database.Enhancements.Length)
            return fallBack;
        return -1;
    }
    //Pine
    public static int GetRecipeIdxByName(string iName)
    {
        for (int index = 0; index <= Database.Recipes.Length - 1; ++index)
        {
            if (string.Equals(Database.Recipes[index].InternalName, iName, StringComparison.OrdinalIgnoreCase))
                return index;
        }
        return -1;
    }

    public static Recipe GetRecipeByName(string iName)
    {
        return Database.Recipes.FirstOrDefault(recipe => string.Equals(recipe.InternalName, iName, StringComparison.OrdinalIgnoreCase));
    }

    public static string[] UidReferencingPowerFix(string uidPower, string uidNew = "")
    {
        string[] array = new string[0];
        for (int index1 = 0; index1 <= Database.Power.Length - 1; ++index1)
        {
            if (Database.Power[index1].Requires.ReferencesPower(uidPower, uidNew))
            {
                Array.Resize(ref array, array.Length + 1);
                array[array.Length - 1] = Database.Power[index1].FullName + " (Requirement)";
            }
            for (int index2 = 0; index2 <= Database.Power[index1].Effects.Length - 1; ++index2)
            {
                if (Database.Power[index1].Effects[index2].Summon != uidPower)
                    continue;
                Database.Power[index1].Effects[index2].Summon = uidNew;
                Array.Resize(ref array, array.Length + 1);
                array[array.Length - 1] = Database.Power[index1].FullName + " (GrantPower)";
            }
        }
        return array;
    }

    public static int NidFromStaticIndexEnh(int sidEnh)
    {
        int num;
        if (sidEnh < 0)
        {
            num = -1;
        }
        else
        {
            for (int index = 0; index < Database.Enhancements.Length; ++index)
            {
                if (Database.Enhancements[index].StaticIndex == sidEnh)
                    return index;
            }
            num = -1;
        }
        return num;
    }

    public static int NidFromUidioSet(string uidSet)
    {
        for (int index = 0; index < Database.EnhancementSets.Count; ++index)
        {
            if (string.Equals(Database.EnhancementSets[index].Uid, uidSet, StringComparison.OrdinalIgnoreCase))
                return index;
        }
        return -1;
    }

    public static int NidFromUidRecipe(string uidRecipe, ref int subIndex)
    {
        bool isSub = subIndex > -1 & uidRecipe.Contains("_");
        subIndex = -1;
        string uid = isSub ? uidRecipe.Substring(0, uidRecipe.LastIndexOf("_", StringComparison.Ordinal)) : uidRecipe;
        for (int recipeIdx = 0; recipeIdx < Database.Recipes.Length; ++recipeIdx)
        {
            if (!string.Equals(Database.Recipes[recipeIdx].InternalName, uid, StringComparison.OrdinalIgnoreCase))
                continue;
            if (!isSub)
                return recipeIdx;
            int startIndex = uidRecipe.LastIndexOf("_", StringComparison.Ordinal) + 1;
            if (startIndex < 0 || startIndex > uidRecipe.Length - 1)
                return -1;
            uid = uidRecipe.Substring(startIndex);
            for (int index2 = 0; index2 < Database.Recipes[recipeIdx].Item.Length; ++index2)
            {
                if (Database.Recipes[recipeIdx].Item[index2].Level != startIndex)
                    continue;
                subIndex = index2;
                return recipeIdx;
            }
        }
        return -1;
    }

    public static int NidFromUidEnh(string uidEnh)
    {
        for (int index = 0; index < Database.Enhancements.Length; ++index)
        {
            if (string.Equals(Database.Enhancements[index].UID, uidEnh, StringComparison.OrdinalIgnoreCase))
                return index;
        }
        return -1;
    }

    public static int NidFromUidEnhExtended(string uidEnh)
    {
        if (!uidEnh.StartsWith("BOOSTS", true, CultureInfo.CurrentCulture))
            return NidFromUidEnh(uidEnh);
        for (int index = 0; index < Database.Enhancements.Length; ++index)
        {
            if (string.Equals("BOOSTS." + Database.Enhancements[index].UID + "." + Database.Enhancements[index].UID, uidEnh, StringComparison.OrdinalIgnoreCase))
                return index;
        }
        return -1;
    }

    const string MainDbName = "Mids' Hero Designer Database MK II";

    static void SaveMainDbRaw(ISerialize serializer, string fn, string name)
    {
        var powersetPowers = Database.Powersets.SelectMany(x => x.Powers).Select(p => p.PowerIndex).Distinct().ToList();
        // only powers that aren't in a powerset
        var powers = Database.Power.Where(p => powersetPowers.Contains(p.PowerIndex) == false).ToList();
        var toSerialize = new
        {
            name,
            Database.Version,
            Database.Date,
            Database.Issue,
            Database.ArchetypeVersion,
            Archetypes = Database.Classes,
            Database.PowersetVersion,
            // out of memory exception
            //Database.Powersets,
            Powers = new
            {
                Database.PowerVersion,
                Database.PowerLevelVersion,
                Database.PowerEffectVersion,
                Database.IOAssignmentVersion,
                // out of memory exception
                //Database.Power
                // just powers not in power sets
                Powers = powers
            },
            Database.Entities
        };
        ConfigData.SaveRawMhd(serializer, toSerialize, fn, null);
        var archPowersets = Database.Powersets; // .Where(ps => ps.nArchetype >= 0);
        var dbPath = Path.Combine(Path.GetDirectoryName(fn), "db");
        var playerPath = Path.Combine(dbPath, "Player");
        var otherPath = Path.Combine(dbPath, "Other");
        var toWrite = new List<FHash>();
        foreach (var path in new[] { dbPath, playerPath, otherPath }.Where(p => !Directory.Exists(p)))
            Directory.CreateDirectory(path);
        var metadataPath = Path.Combine(Path.GetDirectoryName(fn), "db_metadata" + Path.GetExtension(fn));
        var (hasPrevious, prev) = ConfigData.LoadRawMhd<FHash[]>(serializer, metadataPath);
        foreach (var ps in archPowersets)
        {
            var at = Database.Classes.FirstOrDefault(cl => ps.nArchetype != -1 && cl.Idx == ps.nArchetype);
            var at2 = Database.Classes.Length > ps.nArchetype && ps.nArchetype != -1 ? Database.Classes[ps.nArchetype] : null;
            if (ps.FullName?.Length == 0 || ps.FullName?.Length > 100)
                continue;

            if (ps.FullName?.Contains(";") == true || string.IsNullOrWhiteSpace(ps.FullName))
            {
                Console.Error.WriteLine("hmmm:" + ps.DisplayName);
            }
            var psFn = Path.Combine(ps.nArchetype >= 0 ? playerPath : otherPath, ps.ATClass + "_" + ps.FullName + Path.GetExtension(fn));
            if (psFn.Length > 240)
            {
                continue;
            }
            var psPrevious = hasPrevious ? prev.FirstOrDefault(psm => psm.Fullname == ps.FullName && psm.Archetype == ps.ATClass) : null;
            var lastSaveResult = hasPrevious && psPrevious != null ? new RawSaveResult(hash: psPrevious.Hash, length: psPrevious.Length) : null;
            var saveresult = ConfigData.SaveRawMhd(serializer, ps, psFn, lastSaveResult);
            toWrite.Add(new FHash(
                fullname: ps.FullName,
                archetype: ps.ATClass,
                hash: saveresult.Hash,
                length: saveresult.Length
            ));
        }
        ConfigData.SaveRawMhd(serializer, toWrite, metadataPath, null);
    }
    public static void SaveMainDatabase(ISerialize serializer)
    {
        string path = Files.SelectDataFileSave(Files.MxdbFileDB);
        //SaveMainDbRaw(serializer, path, MainDbName);
        FileStream fileStream;
        BinaryWriter writer;
        try
        {
            fileStream = new FileStream(path, FileMode.Create);
            writer = new BinaryWriter(fileStream);
        }
        catch (Exception ex)
        {
            MessageBox.Show("Main db save failed: " + ex.Message);
            return;
        }
        try
        {
            writer.Write(MainDbName);
            writer.Write(Database.Version);
            writer.Write(-1);
            writer.Write(Database.Date.ToBinary());
            writer.Write(Database.Issue);
            writer.Write("BEGIN:ARCHETYPES");
            Database.ArchetypeVersion.StoreTo(writer);
            writer.Write(Database.Classes.Length - 1);
            for (int index = 0; index <= (Database.Classes.Length - 1); ++index)
            {
                Database.Classes[index].StoreTo(ref writer);
            }
            /*foreach (var index in Database.Classes)
                index.StoreTo(ref writer);*/

            writer.Write("BEGIN:POWERSETS");
            Database.PowersetVersion.StoreTo(writer);
            writer.Write(Database.Powersets.Length - 1);
            for (int index = 0; index <= (Database.Powersets.Length - 1); ++index)
            {
                Database.Powersets[index].StoreTo(ref writer);
            }

            writer.Write("BEGIN:POWERS");
            Database.PowerVersion.StoreTo(writer);
            Database.PowerLevelVersion.StoreTo(writer);
            Database.PowerEffectVersion.StoreTo(writer);
            Database.IOAssignmentVersion.StoreTo(writer);
            writer.Write(Database.Power.Length - 1);
            for (int index = 0; index <= (Database.Power.Length - 1); ++index)
            {
                Database.Power[index].StoreTo(ref writer);
            }
            /*foreach (var index in Database.Power)
                index.StoreTo(ref writer);*/
            writer.Write("BEGIN:SUMMONS");
            Database.StoreEntities(writer);
            writer.Close();
            fileStream.Close();
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            writer.Close();
            fileStream.Close();
        }
    }

    public static bool LoadMainDatabase()
    {
        ClearLookups();
        string path = Files.SelectDataFileLoad(Files.MxdbFileDB);
        FileStream fileStream;
        BinaryReader reader;
        try
        {
            fileStream = new FileStream(path, FileMode.Open, FileAccess.Read);
            reader = new BinaryReader(fileStream);
        }
        catch
        {
            return false;
        }
        try
        {
            if (reader.ReadString() != "Mids' Hero Designer Database MK II")
            {
                MessageBox.Show("Expected MHD header, got something else!", "Eeeeee!");
            }
            Database.Version = reader.ReadSingle();
            int year = reader.ReadInt32();
            if (year > 0)
            {
                int month = reader.ReadInt32();
                int day = reader.ReadInt32();
                Database.Date = new DateTime(year, month, day);
            }
            else
                Database.Date = DateTime.FromBinary(reader.ReadInt64());
            Database.Issue = reader.ReadInt32();
            if (reader.ReadString() != "BEGIN:ARCHETYPES")
            {
                MessageBox.Show("Expected Archetype Data, got something else!", "Eeeeee!");
                reader.Close();
                fileStream.Close();
                return false;
            }
            Database.ArchetypeVersion.Load(reader);
            Database.Classes = new Archetype[reader.ReadInt32() + 1];
            for (int index = 0; index < Database.Classes.Length; ++index)
                Database.Classes[index] = new Archetype(reader)
                {
                    Idx = index
                };
            if (reader.ReadString() != "BEGIN:POWERSETS")
            {
                MessageBox.Show("Expected Powerset Data, got something else!", "Eeeeee!");
                reader.Close();
                fileStream.Close();
                return false;
            }
            Database.PowersetVersion.Load(reader);
            int num3 = 0;
            Database.Powersets = new IPowerset[reader.ReadInt32() + 1];
            for (int index = 0; index < Database.Powersets.Length; ++index)
            {
                Database.Powersets[index] = new Powerset(reader)
                {
                    nID = index
                };
                ++num3;
                if (num3 <= 10)
                    continue;
                num3 = 0;
                Application.DoEvents();
            }
            if (reader.ReadString() != "BEGIN:POWERS")
            {
                MessageBox.Show("Expected Power Data, got something else!", "Eeeeee!");
                reader.Close();
                fileStream.Close();
                return false;
            }
            Database.PowerVersion.Load(reader);
            Database.PowerLevelVersion.Load(reader);
            Database.PowerEffectVersion.Load(reader);
            Database.IOAssignmentVersion.Load(reader);
            Database.Power = new IPower[reader.ReadInt32() + 1];
            for (int index = 0; index <= Database.Power.Length - 1; ++index)
            {
                Database.Power[index] = new Power(reader);
                ++num3;
                if (num3 <= 50)
                    continue;
                num3 = 0;
                Application.DoEvents();
            }
            if (reader.ReadString() != "BEGIN:SUMMONS")
            {
                MessageBox.Show("Expected Summon Data, got something else!", "Eeeeee!");
                reader.Close();
                fileStream.Close();
                return false;
            }
            Database.LoadEntities(reader);
            reader.Close();
            fileStream.Close();
        }
        catch
        {
            reader.Close();
            fileStream.Close();
            return false;
        }
        return true;
    }

    public static void LoadDatabaseVersion()
    {
        var target = Files.SelectDataFileLoad("I12.mhd");
        Database.Version = GetDatabaseVersion(target);
    }

    static float GetDatabaseVersion(string fp)
    {
        var fName = Debugger.IsAttached ? Files.SearchUp("Data", fp) : fp;
        float num1 = -1f;
        float num2;
        if (!File.Exists(fName))
        {
            num2 = num1;
        }
        else
        {
            using (FileStream fileStream = new FileStream(fName, FileMode.Open, FileAccess.Read))
            {
                using (BinaryReader binaryReader = new BinaryReader(fileStream))
                {
                    try
                    {
                        if (binaryReader.ReadString() != "Mids' Hero Designer Database MK II")
                        {
                            MessageBox.Show("Expected MHD header, got something else!");
                        }
                        num1 = binaryReader.ReadSingle();
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
                        num1 = -1f;
                    }
                    binaryReader.Close();
                }
                fileStream.Close();
            }
            num2 = num1;
        }
        return num2;
    }

    public static bool LoadLevelsDatabase()
    {
        string path = Files.SelectDataFileLoad("Levels.mhd");
        Database.Levels = new LevelMap[0];
        StreamReader iStream;
        try
        {
            iStream = new StreamReader(path);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}", "Error!");
            return false;
        }
        string[] strArray = FileIO.IOGrab(iStream);
        while (strArray[0] != "Level")
            strArray = FileIO.IOGrab(iStream);
        Database.Levels = new LevelMap[50];
        for (int index = 0; index < 50; ++index)
            Database.Levels[index] = new LevelMap(FileIO.IOGrab(iStream));
        List<int> intList = new List<int> { 0 };
        for (int index = 0; index <= Database.Levels.Length - 1; ++index)
        {
            if (Database.Levels[index].Powers > 0)
                intList.Add(index);
        }
        Database.Levels_MainPowers = intList.ToArray();
        iStream.Close();
        return true;
    }

    public static void LoadOrigins()
    {
        string path = Files.SelectDataFileLoad("Origins.mhd");
        Database.Origins = new List<Origin>();
        StreamReader streamReader;
        try
        {
            streamReader = new StreamReader(path);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}", "Error!");
            return;
        }
        try
        {
            if (string.IsNullOrEmpty(FileIO.IOSeekReturn(streamReader, "Version:")))
                throw new EndOfStreamException("Unable to load Enhancement Class data, version header not found!");
            if (!FileIO.IOSeek(streamReader, "Origin"))
                throw new EndOfStreamException("Unable to load Origin data, section header not found!");
            string[] strArray;
            do
            {
                strArray = FileIO.IOGrab(streamReader);
                if (strArray[0] != "End")
                    Database.Origins.Add(new Origin(strArray[0], strArray[1], strArray[2]));
                else
                    break;
            }
            while (strArray[0] != "End");
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            streamReader.Close();
            return;
        }
        streamReader.Close();
    }

    public static int GetOriginIDByName(string iOrigin)
    {
        for (int index = 0; index <= Database.Origins.Count - 1; ++index)
        {
            if (string.Equals(iOrigin, Database.Origins[index].Name, StringComparison.OrdinalIgnoreCase))
                return index;
        }
        return 0;
    }

    public static int IsSpecialEnh(int enhID)
    {
        for (int index = 0; index < Database.EnhancementSets[Database.Enhancements[enhID].nIDSet].Enhancements.Length; ++index)
        {
            if (enhID == Database.EnhancementSets[Database.Enhancements[enhID].nIDSet].Enhancements[index] && Database.EnhancementSets[Database.Enhancements[enhID].nIDSet].SpecialBonus[index].Index.Length > 0)
                return index;
        }
        return -1;
    }

    public static string GetEnhancementNameShortWSet(int iEnh)
    {
        string str;
        if (iEnh < 0 || iEnh > Database.Enhancements.Length - 1)
        {
            str = string.Empty;
        }
        else
        {
            switch (Database.Enhancements[iEnh].TypeID)
            {
                case Enums.eType.Normal:
                case Enums.eType.SpecialO:
                    str = Database.Enhancements[iEnh].ShortName;
                    break;
                case Enums.eType.InventO:
                    str = "Invention: " + Database.Enhancements[iEnh].ShortName;
                    break;
                case Enums.eType.SetO:
                    str = Database.EnhancementSets[Database.Enhancements[iEnh].nIDSet].DisplayName + ": " + Database.Enhancements[iEnh].ShortName;
                    break;
                default:
                    str = string.Empty;
                    break;
            }
        }
        return str;
    }

    public static int GetFirstValidEnhancement(int iClass)
    {
        for (int index1 = 0; index1 <= Database.Enhancements.Length - 1; ++index1)
        {
            for (int index2 = 0; index2 <= Database.Enhancements[index1].ClassID.Length - 1; ++index2)
            {
                if (Database.EnhancementClasses[Database.Enhancements[index1].ClassID[index2]].ID == iClass)
                    return index1;
            }
        }
        return -1;
    }

    public static void GuessRecipes()
    {
        foreach (IEnhancement enhancement in Database.Enhancements)
        {
            if (enhancement.TypeID != Enums.eType.InventO && enhancement.TypeID != Enums.eType.SetO)
                continue;
            int recipeIdxByName = GetRecipeIdxByName(enhancement.UID);
            if (recipeIdxByName <= -1)
                continue;
            enhancement.RecipeIDX = recipeIdxByName;
            enhancement.RecipeName = Database.Recipes[recipeIdxByName].InternalName;
        }
    }

    public static void AssignRecipeSalvageIDs()
    {
        int[] numArray = new int[7];
        string[] strArray = new string[7];
        foreach (Recipe recipe in Database.Recipes)
        {
            foreach (Recipe.RecipeEntry recipeEntry in recipe.Item)
            {
                for (int index1 = 0; index1 <= recipeEntry.Salvage.Length - 1; ++index1)
                {
                    if (recipeEntry.Salvage[index1] == strArray[index1])
                    {
                        recipeEntry.SalvageIdx[index1] = numArray[index1];
                    }
                    else
                    {
                        recipeEntry.SalvageIdx[index1] = -1;
                        string a = recipeEntry.Salvage[index1];
                        for (int index2 = 0; index2 <= Database.Salvage.Length - 1; ++index2)
                        {
                            if (!string.Equals(a, Database.Salvage[index2].InternalName, StringComparison.OrdinalIgnoreCase))
                                continue;
                            recipeEntry.SalvageIdx[index1] = index2;
                            numArray[index1] = index2;
                            strArray[index1] = recipeEntry.Salvage[index1];
                            break;
                        }
                    }
                }
            }
        }
    }

    public static void AssignRecipeIDs()
    {
        foreach (Recipe recipe in Database.Recipes)
        {
            recipe.Enhancement = string.Empty;
            recipe.EnhIdx = -1;
        }
        for (int index1 = 0; index1 <= Database.Enhancements.Length - 1; ++index1)
        {
            if (string.IsNullOrEmpty(Database.Enhancements[index1].RecipeName))
                continue;
            Database.Enhancements[index1].RecipeIDX = -1;
            string recipeName = Database.Enhancements[index1].RecipeName;
            for (int index2 = 0; index2 <= Database.Recipes.Length - 1; ++index2)
            {
                if (!recipeName.Equals(Database.Recipes[index2].InternalName, StringComparison.OrdinalIgnoreCase))
                    continue;
                Database.Recipes[index2].Enhancement = Database.Enhancements[index1].UID;
                Database.Recipes[index2].EnhIdx = index1;
                Database.Enhancements[index1].RecipeIDX = index2;
                break;
            }
        }
    }

    public static void LoadRecipes()
    {
        string path = Files.SelectDataFileLoad("Recipe.mhd");
        Database.Recipes = new Recipe[0];
        FileStream fileStream;
        BinaryReader reader;
        try
        {
            fileStream = new FileStream(path, FileMode.Open, FileAccess.Read);
            reader = new BinaryReader(fileStream);
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message + "\n\nRecipe database couldn't be loaded.");
            return;
        }
        if (reader.ReadString() == "Mids' Hero Designer Recipe Database")
        {
            Database.RecipeSource1 = reader.ReadString();
            Database.RecipeSource2 = reader.ReadString();
            Database.RecipeRevisionDate = DateTime.FromBinary(reader.ReadInt64());
            int num = 0;
            Database.Recipes = new Recipe[reader.ReadInt32() + 1];
            for (int index = 0; index < Database.Recipes.Length; ++index)
            {
                Database.Recipes[index] = new Recipe(reader);
                ++num;
                if (num <= 100)
                    continue;
                num = 0;
                Application.DoEvents();
            }
        }
        else
        {
            MessageBox.Show("Recipe Database header wasn't found, file may be corrupt!");
            reader.Close();
            fileStream.Close();
        }
    }

    const string RecipeName = "Mids' Hero Designer Recipe Database";
    static void SaveRecipesRaw(ISerialize serializer, string fn, string name)
    {
        var toSerialize = new
        {
            name,
            Database.RecipeSource1,
            Database.RecipeSource2,
            Database.RecipeRevisionDate,
            Database.Recipes
        };
        ConfigData.SaveRawMhd(serializer, toSerialize, fn, null);
    }
    public static void SaveRecipes(ISerialize serializer)
    {
        string path = Files.SelectDataFileSave("Recipe.mhd");
        SaveRecipesRaw(serializer, path, RecipeName);
        FileStream fileStream;
        BinaryWriter writer;
        try
        {
            fileStream = new FileStream(path, FileMode.Create);
            writer = new BinaryWriter(fileStream);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            return;
        }
        try
        {
            writer.Write(RecipeName);
            writer.Write(Database.RecipeSource1);
            writer.Write(Database.RecipeSource2);
            writer.Write(Database.RecipeRevisionDate.ToBinary());
            writer.Write(Database.Recipes.Length - 1);
            for (int index = 0; index <= Database.Recipes.Length - 1; ++index)
                Database.Recipes[index].StoreTo(writer);
            writer.Close();
            fileStream.Close();
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            writer.Close();
            fileStream.Close();
        }
    }

    public static void LoadSalvage()
    {
        string path = Files.SelectDataFileLoad("Salvage.mhd");
        Database.Salvage = new Salvage[0];
        FileStream fileStream;
        BinaryReader reader;
        try
        {
            fileStream = new FileStream(path, FileMode.Open, FileAccess.Read);
            reader = new BinaryReader(fileStream);
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message + "\n\nSalvage database couldn't be loaded.");
            return;
        }
        try
        {
            if (reader.ReadString() != "Mids' Hero Designer Salvage Database")
            {
                MessageBox.Show("Salvage Database header wasn't found, file may be corrupt!");
                reader.Close();
                fileStream.Close();
            }
            else
            {
                Database.Salvage = new Salvage[reader.ReadInt32() + 1];
                for (int index = 0; index < Database.Salvage.Length; ++index)
                    Database.Salvage[index] = new Salvage(reader);
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show("Salvage Database file isn't how it should be (" + ex.Message + ")\nNo salvage loaded.");
            Database.Salvage = new Salvage[0];
            reader.Close();
            fileStream.Close();
        }
    }

    static void SaveSalvageRaw(ISerialize serializer, string fn, string name)
    {
        var toSerialize = new
        {
            name,
            Database.Salvage
        };
        ConfigData.SaveRawMhd(serializer, toSerialize, fn, null);
    }

    const string SalvageName = "Mids' Hero Designer Salvage Database";
    public static void SaveSalvage(ISerialize serializer)
    {
        string path = Files.SelectDataFileSave("Salvage.mhd");
        SaveSalvageRaw(serializer, path, SalvageName);
        FileStream fileStream;
        BinaryWriter writer;
        try
        {
            fileStream = new FileStream(path, FileMode.Create);
            writer = new BinaryWriter(fileStream);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            return;
        }
        try
        {
            writer.Write(SalvageName);
            writer.Write(Database.Salvage.Length - 1);
            for (int index = 0; index <= Database.Salvage.Length - 1; ++index)
                Database.Salvage[index].StoreTo(writer);
            writer.Close();
            fileStream.Close();
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            writer.Close();
            fileStream.Close();
        }
    }

    const string EnhancementDbName = "Mids' Hero Designer Enhancement Database";
    static void SaveEnhancementDbRaw(ISerialize serializer, string filename, string name)
    {
        var toSerialize = new
        {
            name,
            Database.VersionEnhDb,
            Database.Enhancements,
            Database.EnhancementSets
        };
        ConfigData.SaveRawMhd(serializer, toSerialize, filename, null);
    }

    public static void SaveEnhancementDb(ISerialize serializer)
    {
        string path = Files.SelectDataFileSave(Files.MxdbFileEnhDB);
        SaveEnhancementDbRaw(serializer, path, EnhancementDbName);
        FileStream fileStream;
        BinaryWriter writer;
        try
        {
            fileStream = new FileStream(path, FileMode.Create);
            writer = new BinaryWriter(fileStream);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            return;
        }
        try
        {
            writer.Write(EnhancementDbName);
            writer.Write(Database.VersionEnhDb);
            writer.Write(Database.Enhancements.Length - 1);
            for (int index = 0; index <= Database.Enhancements.Length - 1; ++index)
                Database.Enhancements[index].StoreTo(writer);
            writer.Write(Database.EnhancementSets.Count - 1);
            for (int index = 0; index <= Database.EnhancementSets.Count - 1; ++index)
                Database.EnhancementSets[index].StoreTo(writer);
            writer.Close();
            fileStream.Close();
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            writer.Close();
            fileStream.Close();
        }
    }

    public static void LoadEnhancementDb()
    {
        string path = Files.SelectDataFileLoad("EnhDB.mhd");
        Database.Enhancements = new IEnhancement[0];
        FileStream fileStream;
        BinaryReader reader;
        try
        {
            fileStream = new FileStream(path, FileMode.Open, FileAccess.Read);
            reader = new BinaryReader(fileStream);
        }
        catch (Exception ex)
        {
            MessageBox.Show(ex.Message + "\n\nNo Enhancements have been loaded.", "EnhDB Load Failed");
            return;
        }
        try
        {
            if (reader.ReadString() != "Mids' Hero Designer Enhancement Database")
            {
                MessageBox.Show("Enhancement Database header wasn't found, file may be corrupt!", "Meep!");
                reader.Close();
                fileStream.Close();
            }
            else
            {
                reader.ReadSingle();
                float versionEnhDb = Database.VersionEnhDb;
                int num1 = 0;
                Database.Enhancements = new IEnhancement[reader.ReadInt32() + 1];
                for (int index = 0; index < Database.Enhancements.Length; ++index)
                {
                    Database.Enhancements[index] = new Enhancement(reader);
                    ++num1;
                    if (num1 <= 5)
                        continue;
                    num1 = 0;
                    Application.DoEvents();
                }
                Database.EnhancementSets = new EnhancementSetCollection();
                int num2 = reader.ReadInt32() + 1;
                for (int index = 0; index < num2; ++index)
                {
                    Database.EnhancementSets.Add(new EnhancementSet(reader));
                    ++num1;
                    if (num1 <= 5)
                        continue;
                    num1 = 0;
                    Application.DoEvents();
                }
                reader.Close();
                fileStream.Close();
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show("Enhancement Database file isn't how it should be (" + ex.Message + ")\nNo Enhancements have been loaded.", "Huh...");
            Database.Enhancements = new IEnhancement[0];
            reader.Close();
            fileStream.Close();
        }
    }

    public static bool LoadEnhancementClasses()
    {
        using (StreamReader streamReader = new StreamReader(Files.SelectDataFileLoad(Files.MxdbFileEClasses)))
        {
            Database.EnhancementClasses = new Enums.sEnhClass[0];
            try
            {
                if (string.IsNullOrEmpty(FileIO.IOSeekReturn(streamReader, "Version:")))
                    throw new EndOfStreamException("Unable to load Enhancement Class data, version header not found!");
                if (!FileIO.IOSeek(streamReader, "Index"))
                    throw new EndOfStreamException("Unable to load Enhancement Class data, section header not found!");
                Enums.sEnhClass[] enhancementClasses = Database.EnhancementClasses;
                string[] strArray;
                do
                {
                    strArray = FileIO.IOGrab(streamReader);
                    if (strArray[0] != "End")
                    {
                        Array.Resize(ref enhancementClasses, enhancementClasses.Length + 1);
                        enhancementClasses[enhancementClasses.Length - 1].ID = int.Parse(strArray[0]);
                        enhancementClasses[enhancementClasses.Length - 1].Name = strArray[1];
                        enhancementClasses[enhancementClasses.Length - 1].ShortName = strArray[2];
                        enhancementClasses[enhancementClasses.Length - 1].ClassID = strArray[3];
                        enhancementClasses[enhancementClasses.Length - 1].Desc = strArray[4];
                    }
                    else
                        break;
                }
                while (strArray[0] != "End");
                Database.EnhancementClasses = enhancementClasses;
                Application.DoEvents();
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
                streamReader.Close();
                return false;
            }
            streamReader.Close();
        }
        return true;
    }

    public static void LoadSetTypeStrings()
    {
        string path = Files.SelectDataFileLoad(Files.MxdbFileSetTypes);
        Database.SetTypeStringLong = new string[0];
        Database.SetTypeStringShort = new string[0];
        StreamReader streamReader;
        try
        {
            streamReader = new StreamReader(path);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            return;
        }
        try
        {
            if (string.IsNullOrEmpty(FileIO.IOSeekReturn(streamReader, "Version:")))
                throw new EndOfStreamException("Unable to load SetType data, version header not found!");
            if (!FileIO.IOSeek(streamReader, "SetID"))
                throw new EndOfStreamException("Unable to load SetType data, section header not found!");
            string[] setTypeStringLong = Database.SetTypeStringLong;
            string[] setTypeStringShort = Database.SetTypeStringShort;
            string[] strArray;
            do
            {
                strArray = FileIO.IOGrab(streamReader);
                if (strArray[0] != "End")
                {
                    Array.Resize(ref setTypeStringLong, setTypeStringLong.Length + 1);
                    Array.Resize(ref setTypeStringShort, setTypeStringShort.Length + 1);
                    setTypeStringShort[setTypeStringShort.Length - 1] = strArray[1];
                    setTypeStringLong[setTypeStringLong.Length - 1] = strArray[2];
                }
                else
                    break;
            }
            while (strArray[0] != "End");
            Database.SetTypeStringLong = setTypeStringLong;
            Database.SetTypeStringShort = setTypeStringShort;
            Database.EnhGradeStringLong = new string[4];
            Database.EnhGradeStringShort = new string[4];
            Database.EnhGradeStringLong[0] = "None";
            Database.EnhGradeStringLong[1] = "Training Origin";
            Database.EnhGradeStringLong[2] = "Dual Origin";
            Database.EnhGradeStringLong[3] = "Single Origin";
            Database.EnhGradeStringShort[0] = "None";
            Database.EnhGradeStringShort[1] = "TO";
            Database.EnhGradeStringShort[2] = "DO";
            Database.EnhGradeStringShort[3] = "SO";
            Database.SpecialEnhStringLong = new string[5];
            Database.SpecialEnhStringShort = new string[5];
            Database.SpecialEnhStringLong[0] = "None";
            Database.SpecialEnhStringLong[1] = "Hamidon Origin";
            Database.SpecialEnhStringLong[2] = "Hydra Origin";
            Database.SpecialEnhStringLong[3] = "Titan Origin";
            Database.SpecialEnhStringLong[4] = "Yin's Talisman";
            Database.SpecialEnhStringShort[0] = "None";
            Database.SpecialEnhStringShort[1] = "HO";
            Database.SpecialEnhStringShort[2] = "TnO";
            Database.SpecialEnhStringShort[3] = "HyO";
            Database.SpecialEnhStringShort[4] = "YinO";
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            streamReader.Close();
            return;
        }
        streamReader.Close();
    }

    public static bool LoadMaths()
    {
        string path = Files.SelectDataFileLoad(Files.MxdbFileMaths);
        StreamReader streamReader;
        try
        {
            streamReader = new StreamReader(path);
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            return false;
        }
        try
        {
            if (string.IsNullOrEmpty(FileIO.IOSeekReturn(streamReader, "Version:")))
                throw new EndOfStreamException("Unable to load Enhancement Maths data, version header not found!");
            if (!FileIO.IOSeek(streamReader, "EDRT"))
                throw new EndOfStreamException("Unable to load Maths data, section header not found!");
            Database.MultED = new float[4][];
            for (int index = 0; index < 4; ++index)
                Database.MultED[index] = new float[3];
            for (int index1 = 0; index1 <= 2; ++index1)
            {
                string[] strArray = FileIO.IOGrab(streamReader);
                for (int index2 = 0; index2 < 4; ++index2)
                    Database.MultED[index2][index1] = float.Parse(strArray[index2 + 1]);
            }
            if (!FileIO.IOSeek(streamReader, "EGE"))
                throw new EndOfStreamException("Unable to load Maths data, section header not found!");
            Database.MultTO = new float[1][];
            Database.MultDO = new float[1][];
            Database.MultSO = new float[1][];
            Database.MultHO = new float[1][];
            string[] strArray1 = FileIO.IOGrab(streamReader);
            Database.MultTO[0] = new float[4];
            for (int index = 0; index < 4; ++index)
                Database.MultTO[0][index] = float.Parse(strArray1[index + 1]);
            string[] strArray2 = FileIO.IOGrab(streamReader);
            Database.MultDO[0] = new float[4];
            for (int index = 0; index < 4; ++index)
                Database.MultDO[0][index] = float.Parse(strArray2[index + 1]);
            string[] strArray3 = FileIO.IOGrab(streamReader);
            Database.MultSO[0] = new float[4];
            for (int index = 0; index < 4; ++index)
                Database.MultSO[0][index] = float.Parse(strArray3[index + 1]);
            string[] strArray4 = FileIO.IOGrab(streamReader);
            Database.MultHO[0] = new float[4];
            for (int index = 0; index < 4; ++index)
                Database.MultHO[0][index] = float.Parse(strArray4[index + 1]);
            if (!FileIO.IOSeek(streamReader, "LBIOE"))
                throw new EndOfStreamException("Unable to load Maths data, section header not found!");
            Database.MultIO = new float[53][];
            for (int index1 = 0; index1 < 53; ++index1)
            {
                string[] strArray5 = FileIO.IOGrab(streamReader);
                Database.MultIO[index1] = new float[4];
                for (int index2 = 0; index2 < 4; ++index2)
                    Database.MultIO[index1][index2] = float.Parse(strArray5[index2 + 1]);
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Message: {ex.Message}\r\nTrace: {ex.StackTrace}");
            streamReader.Close();
            return false;
        }
        streamReader.Close();
        return true;
    }

    public static void AssignSetBonusIndexes()
    {
        foreach (EnhancementSet enhancementSet in Database.EnhancementSets)
        {
            foreach (EnhancementSet.BonusItem bonu in enhancementSet.Bonus)
            {
                for (int index = 0; index < bonu.Index.Length; ++index)
                    bonu.Index[index] = NidFromUidPower(bonu.Name[index]);
            }
            foreach (EnhancementSet.BonusItem specialBonu in enhancementSet.SpecialBonus)
            {
                for (int index = 0; index <= specialBonu.Index.Length - 1; ++index)
                    specialBonu.Index[index] = NidFromUidPower(specialBonu.Name[index]);
            }
        }
    }

    public static float GetModifier(IEffect iEffect)
    {
        int iClass = 0;
        int iLevel = MidsContext.MathLevelBase;
        var effPower = iEffect.GetPower();
        if (effPower == null)
        {
            if (iEffect.Enhancement == null)
                return 1f;
        }
        else
            iClass = string.IsNullOrEmpty(effPower.ForcedClass) ? (iEffect.Absorbed_Class_nID <= -1 ? MidsContext.Archetype.Idx : iEffect.Absorbed_Class_nID) : NidFromUidClass(effPower.ForcedClass);
        if (MidsContext.MathLevelExemp > -1 && MidsContext.MathLevelExemp < MidsContext.MathLevelBase)
            iLevel = MidsContext.MathLevelExemp;
        return GetModifier(iClass, iEffect.nModifierTable, iLevel);
    }

    static float GetModifier(int iClass, int iTable, int iLevel)

    {
        float num;
        if (iClass < 0)
            num = 0.0f;
        else if (iTable < 0)
            num = 0.0f;
        else if (iLevel < 0)
            num = 0.0f;
        else if (iClass > Database.Classes.Length - 1)
        {
            num = 0.0f;
        }
        else
        {
            iClass = Database.Classes[iClass].Column;
            num = iClass >= 0 ? (iTable <= Database.AttribMods.Modifier.Length - 1 ? (iLevel <= Database.AttribMods.Modifier[iTable].Table.Length - 1 ? (iClass <= Database.AttribMods.Modifier[iTable].Table[iLevel].Length - 1 ? Database.AttribMods.Modifier[iTable].Table[iLevel][iClass] : 0.0f) : 0.0f) : 0.0f) : 0.0f;
        }
        return num;
    }

    public static void MatchAllIDs(IMessager iFrm = null)
    {
        UpdateMessage(iFrm, "Matching Group IDs...");
        FillGroupArray();
        UpdateMessage(iFrm, "Matching Class IDs...");
        MatchArchetypeIDs();
        UpdateMessage(iFrm, "Matching Powerset IDs...");
        MatchPowersetIDs();
        UpdateMessage(iFrm, "Matching Power IDs...");
        MatchPowerIDs();
        UpdateMessage(iFrm, "Propagating Group IDs...");
        SetPowersetsFromGroups();
        UpdateMessage(iFrm, "Matching Enhancement IDs...");
        MatchEnhancementIDs();
        UpdateMessage(iFrm, "Matching Modifier IDs...");
        MatchModifierIDs();
        UpdateMessage(iFrm, "Matching Entity IDs...");
        MatchSummonIDs();
        TestNewCode();

    }

    static void UpdateMessage(IMessager iFrm, string iMsg)

    {
        iFrm?.SetMessage(iMsg);
    }

    static void MatchArchetypeIDs()

    {
        for (int index = 0; index <= Database.Classes.Length - 1; ++index)
        {
            Database.Classes[index].Idx = index;
            Array.Sort(Database.Classes[index].Origin);
            Database.Classes[index].Primary = new int[0];
            Database.Classes[index].Secondary = new int[0];
            Database.Classes[index].Ancillary = new int[0];
        }
    }

    static void MatchPowersetIDs()

    {
        for (int index1 = 0; index1 <= Database.Powersets.Length - 1; ++index1)
        {
            IPowerset powerset = Database.Powersets[index1];
            powerset.nID = index1;
            powerset.nArchetype = NidFromUidClass(powerset.ATClass);
            powerset.nIDTrunkSet = string.IsNullOrEmpty(powerset.UIDTrunkSet) ? -1 : NidFromUidPowerset(powerset.UIDTrunkSet);
            powerset.nIDLinkSecondary = string.IsNullOrEmpty(powerset.UIDLinkSecondary) ? -1 : NidFromUidPowerset(powerset.UIDLinkSecondary);
            if (powerset.UIDMutexSets.Length > 0)
            {
                powerset.nIDMutexSets = new int[powerset.UIDMutexSets.Length];
                for (int index2 = 0; index2 < powerset.UIDMutexSets.Length; ++index2)
                    powerset.nIDMutexSets[index2] = NidFromUidPowerset(powerset.UIDMutexSets[index2]);
            }
            powerset.Power = new int[0];
            powerset.Powers = new IPower[0];
        }
    }

    static void MatchPowerIDs()
    {
        Database.MutexList = UidMutexAll();
        for (int index = 0; index < Database.Power.Length; ++index)
        {
            IPower power1 = Database.Power[index];
            if (string.IsNullOrEmpty(power1.FullName))
                power1.FullName = "Orphan." + power1.DisplayName.Replace(" ", "_");
            power1.PowerIndex = index;
            power1.PowerSetID = NidFromUidPowerset(power1.FullSetName);
            if (power1.PowerSetID <= -1)
                continue;
            var ps = power1.GetPowerSet();
            int length = ps.Powers.Length;
            power1.PowerSetIndex = length;
            int[] power2 = ps.Power;
            Array.Resize(ref power2, length + 1);
            ps.Power = power2;
            IPower[] powers = ps.Powers;
            Array.Resize(ref powers, length + 1);
            ps.Powers = powers;
            ps.Power[length] = index;
            ps.Powers[length] = power1;
        }
        foreach (IPower power in Database.Power)
        {
            bool flag = false;
            if (power.GetPowerSet().SetType == Enums.ePowerSetType.SetBonus)
            {
                flag = power.PowerName.Contains("Slow");
                if (flag)
                {
                    power.BuffMode = Enums.eBuffMode.Debuff;
                    foreach (var index in power.Effects)
                        index.buffMode = Enums.eBuffMode.Debuff;
                }
            }
            foreach (IEffect effect in power.Effects)
            {
                if (flag)
                    effect.buffMode = Enums.eBuffMode.Debuff;
                switch (effect.EffectType)
                {
                    case Enums.eEffectType.GrantPower:
                        effect.nSummon = NidFromUidPower(effect.Summon);
                        power.HasGrantPowerEffect = true;
                        break;
                    case Enums.eEffectType.EntCreate:
                        effect.nSummon = NidFromUidEntity(effect.Summon);
                        break;
                    case Enums.eEffectType.PowerRedirect:
                        effect.nSummon = NidFromUidPower(effect.Override);
                        power.HasPowerOverrideEffect = true;
                        break;
                }
            }
            power.NGroupMembership = new int[power.GroupMembership.Length];
            for (int index1 = 0; index1 < power.GroupMembership.Length; ++index1)
            {
                for (int index2 = 0; index2 < Database.MutexList.Length; ++index2)
                {
                    if (!string.Equals(Database.MutexList[index2], power.GroupMembership[index1], StringComparison.OrdinalIgnoreCase))
                        continue;
                    power.NGroupMembership[index1] = index2;
                    break;
                }
            }
            power.NIDSubPower = new int[power.UIDSubPower.Length];
            for (int index = 0; index < power.UIDSubPower.Length; ++index)
                power.NIDSubPower[index] = NidFromUidPower(power.UIDSubPower[index]);
            MatchRequirementId(power);
        }
    }

    static void MatchRequirementId(IPower power)

    {
        if (power.Requires.ClassName.Length > 0)
        {
            power.Requires.NClassName = new int[power.Requires.ClassName.Length];
            for (int index = 0; index < power.Requires.ClassName.Length; ++index)
                power.Requires.NClassName[index] = NidFromUidClass(power.Requires.ClassName[index]);
        }
        if (power.Requires.ClassNameNot.Length > 0)
        {
            power.Requires.NClassNameNot = new int[power.Requires.ClassNameNot.Length];
            for (int index = 0; index < power.Requires.ClassNameNot.Length; ++index)
                power.Requires.NClassNameNot[index] = NidFromUidClass(power.Requires.ClassNameNot[index]);
        }
        if (power.Requires.PowerID.Length > 0)
        {
            power.Requires.NPowerID = new int[power.Requires.PowerID.Length][];
            for (int index1 = 0; index1 < power.Requires.PowerID.Length; ++index1)
            {
                power.Requires.NPowerID[index1] = new int[power.Requires.PowerID[index1].Length];
                for (int index2 = 0; index2 < power.Requires.PowerID[index1].Length; ++index2)
                    power.Requires.NPowerID[index1][index2] = !string.IsNullOrEmpty(power.Requires.PowerID[index1][index2]) ? NidFromUidPower(power.Requires.PowerID[index1][index2]) : -1;
            }
        }
        if (power.Requires.PowerIDNot.Length <= 0)
            return;
        power.Requires.NPowerIDNot = new int[power.Requires.PowerIDNot.Length][];
        for (int index1 = 0; index1 < power.Requires.PowerIDNot.Length; ++index1)
        {
            power.Requires.NPowerIDNot[index1] = new int[power.Requires.PowerIDNot[index1].Length];
            for (int index2 = 0; index2 < power.Requires.PowerIDNot[index1].Length; ++index2)
                power.Requires.NPowerIDNot[index1][index2] = !string.IsNullOrEmpty(power.Requires.PowerIDNot[index1][index2]) ? NidFromUidPower(power.Requires.PowerIDNot[index1][index2]) : -1;
        }
    }

    static void SetPowersetsFromGroups()
    {
        for (int index1 = 0; index1 < Database.Classes.Length; ++index1)
        {
            Archetype archetype = Database.Classes[index1];
            List<int> intList1 = new List<int>();
            List<int> intList2 = new List<int>();
            List<int> intList3 = new List<int>();
            for (int index2 = 0; index2 < Database.Powersets.Length; ++index2)
            {
                IPowerset powerset = Database.Powersets[index2];
                if (powerset.Powers.Length > 0)
                    powerset.Powers[0].SortOverride = true;
                if (string.Equals(powerset.GroupName, archetype.PrimaryGroup, StringComparison.OrdinalIgnoreCase))
                {
                    intList1.Add(index2);
                    if (powerset.nArchetype < 0)
                        powerset.nArchetype = index1;
                }
                if (string.Equals(powerset.GroupName, archetype.SecondaryGroup, StringComparison.OrdinalIgnoreCase))
                {
                    intList2.Add(index2);
                    if (powerset.nArchetype < 0)
                        powerset.nArchetype = index1;
                }
                if (string.Equals(powerset.GroupName, archetype.EpicGroup, StringComparison.OrdinalIgnoreCase) && (powerset.nArchetype == index1 || powerset.Powers.Length > 0 && powerset.Powers[0].Requires.ClassOk(archetype.ClassName)))
                    intList3.Add(index2);
            }
            archetype.Primary = intList1.ToArray();
            archetype.Secondary = intList2.ToArray();
            archetype.Ancillary = intList3.ToArray();
        }
    }

    public static void MatchEnhancementIDs()
    {
        for (int index1 = 0; index1 <= Database.Power.Length - 1; ++index1)
        {
            List<int> intList = new List<int>();
            for (int index2 = 0; index2 <= Database.Power[index1].BoostsAllowed.Length - 1; ++index2)
            {
                int index3 = EnhancementClassIdFromName(Database.Power[index1].BoostsAllowed[index2]);
                if (index3 > -1)
                    intList.Add(Database.EnhancementClasses[index3].ID);
            }

            if (Database.Power[index1].Enhancements != null)
            {
                //do nothing
            }
            else
            {
                Database.Power[index1].Enhancements = intList.ToArray();
            }
                
        }
        for (int index = 0; index <= Database.EnhancementSets.Count - 1; ++index)
            Database.EnhancementSets[index].Enhancements = new int[0];
        bool flag = false;
        string str = string.Empty;
        for (int index1 = 0; index1 <= Database.Enhancements.Length - 1; ++index1)
        {
            IEnhancement enhancement = Database.Enhancements[index1];
            if (enhancement.TypeID != Enums.eType.SetO || string.IsNullOrEmpty(enhancement.UIDSet))
                continue;
            int index2 = NidFromUidioSet(enhancement.UIDSet);
            if (index2 > -1)
            {
                enhancement.nIDSet = index2;
                Array.Resize(ref Database.EnhancementSets[index2].Enhancements, Database.EnhancementSets[index2].Enhancements.Length + 1);
                Database.EnhancementSets[index2].Enhancements[Database.EnhancementSets[index2].Enhancements.Length - 1] = index1;
            }
            else
            {
                str = str + enhancement.UIDSet + enhancement.Name + "\n";
                flag = true;
            }
        }
        if (!flag)
            return;
        MessageBox.Show("One or more enhancements had difficulty being matched to their invention set. You should check the database for misplaced Invention Set enhancements.\n" + str, "Mismatch Detected");
    }

    static int EnhancementClassIdFromName(string iName)
    {
        int num;
        if (string.IsNullOrEmpty(iName))
        {
            num = -1;
        }
        else
        {
            for (int index = 0; index <= Database.EnhancementClasses.Length - 1; ++index)
            {
                if (string.Equals(Database.EnhancementClasses[index].ClassID, iName, StringComparison.OrdinalIgnoreCase))
                    return index;
            }
            num = -1;
        }
        return num;
    }

    static void MatchModifierIDs()
    {
        foreach (IPower power in Database.Power)
        {
            foreach (IEffect effect in power.Effects)
                effect.nModifierTable = NidFromUidAttribMod(effect.ModifierTable);
        }
    }

    public static void MatchSummonIDs()
        => SummonedEntity.MatchSummonIDs(NidFromUidClass, NidFromUidPowerset, NidFromUidPower);

    public static void AssignStaticIndexValues(ISerialize serializer, bool save)
    {
        int lastStaticPowerIdx = -2;
        for (int index = 0; index <= Database.Power.Length - 1; ++index)
        {
            if (Database.Power[index].StaticIndex > -1 && Database.Power[index].StaticIndex > lastStaticPowerIdx)
                lastStaticPowerIdx = Database.Power[index].StaticIndex;
        }
        if (lastStaticPowerIdx < -1)
            lastStaticPowerIdx = -1;
        for (int index = 0; index <= Database.Power.Length - 1; ++index)
        {
            if (Database.Power[index].StaticIndex >= 0)
                continue;
            ++lastStaticPowerIdx;
            Database.Power[index].StaticIndex = lastStaticPowerIdx;
        }
        int lastStaticEnhIdx = -2;
        for (int index = 1; index <= Database.Enhancements.Length - 1; ++index)
        {
            if (Database.Enhancements[index].StaticIndex > -1 && Database.Enhancements[index].StaticIndex > lastStaticEnhIdx)
                lastStaticEnhIdx = Database.Enhancements[index].StaticIndex;
        }
        if (lastStaticEnhIdx < -1)
            lastStaticEnhIdx = -1;
        for (int index = 1; index <= Database.Enhancements.Length - 1; ++index)
        {
            if (Database.Enhancements[index].StaticIndex >= 1)
                continue;
            ++lastStaticEnhIdx;
            Database.Enhancements[index].StaticIndex = lastStaticEnhIdx;
        }

        if (!save)
            return;
        SaveMainDatabase(serializer);
        SaveEnhancementDb(serializer);
    }

    // NEW CODE FOR DatabaseAPI.cs
    public class AIToon
    {
        public Base.Data_Classes.Archetype Archetype;
        public IPowerset Fitness;
        public IPowerset Primary;
        public IPowerset Secondary;
        public IPowerset Pool1;
        public IPowerset Pool2;
        public IPowerset Pool3;
        public IPowerset Pool4;
        public IPowerset Epic;

        public PowerEntry Health;
        public PowerEntry Stamina;
        public PowerEntry Level1Primary;
        public PowerEntry Level1Secondary;
        public PowerEntry Level2;
        public PowerEntry Level4;
        public PowerEntry Level6;
        public PowerEntry Level8;
        public PowerEntry Level10;
        public PowerEntry Level12;
        public PowerEntry Level14;
        public PowerEntry Level16;
        public PowerEntry Level18;
        public PowerEntry Level20;
        public PowerEntry Level22;
        public PowerEntry Level24;
        public PowerEntry Level26;
        public PowerEntry Level28;
        public PowerEntry Level30;
        public PowerEntry Level32;
        public PowerEntry Level35;
        public PowerEntry Level38;
        public PowerEntry Level41;
        public PowerEntry Level44;
        public PowerEntry Level47;
        public PowerEntry Level49;
    }

    public enum EnhancementTypes : int
    {
        Accuracy = 26,
        Damage = 29,
        EnduranceModification = 32,
        EnduranceReduction = 33,
        Defense = 30,
        Heal = 36,
        Resistance = 44,
        Range = 42,
        Recharge = 43
    }

    public static IPower GetPowerByIndex(int index)
    {
        if (index < 0 || index > Database.Power.Length - 1)
            return null;
        return Database.Power[index];
    }

    public static IEnhancement GetEnhancementByIndex(int index)
    {
        if (index < 0 || index > Database.Enhancements.Length - 1)
            return null;
        return Database.Enhancements[index];
    }

    public static string GetLoadSring(IEnhancement enhancement, int level = 49, string delimiter = ":")
    {
        // Set DisplayName(Can be empty):Enhancement Short Name:Type(enum eType):Fallback:Relative Level:Grade(enum eEnhGrade):IO Level
        EnhancementSet set = GetEnhancementSet(enhancement);
        string loadString = ((null == set)? "" : set.DisplayName) + delimiter;
        loadString += enhancement.ShortName + delimiter;
        loadString += (int)enhancement.TypeID + delimiter;
        loadString += "-1" + delimiter;
        loadString += level.ToString() + delimiter;
        loadString += "0" + delimiter;
        loadString += level.ToString();
        return loadString;
    }

    public static EnhancementSet GetEnhancementSet(IEnhancement enhancement)
    {
        foreach (EnhancementSet enhancementSet in Database.EnhancementSets)
        {
            if (enhancementSet.Uid == enhancement.UIDSet)
                return enhancementSet;
        }
        return null;
    }

    public static int GetEnhancementSetIndexByName(string iName)
        => Database.EnhancementSets.TryFindIndex(enh => string.Equals(enh.ShortName, iName, StringComparison.OrdinalIgnoreCase) || string.Equals(enh.DisplayName, iName, StringComparison.OrdinalIgnoreCase));

    public static EnhancementSet GetEnhancementSetByIndex(int index)
    {
        if (0 > index || index >= Database.EnhancementSets.Count)
            return null;
        return Database.EnhancementSets[index];
    }

    public static List<IPower> GetBonusPowers(EnhancementSet enhancementSet)
    {
        List<IPower> bonusPowers = new List<IPower>();
        if (null == enhancementSet)
            return bonusPowers;
        foreach (EnhancementSet.BonusItem bonusItem in enhancementSet.Bonus)
        {
            for (int bonusIndex = 0; bonusIndex < bonusItem.Index.Length; ++bonusIndex)
            {
                int powerIndex = bonusItem.Index[bonusIndex] + 3;
                IPower bonusPower = GetPowerByIndex(powerIndex);
                if (null == bonusPower)
                    continue;
                bonusPowers.Add(bonusPower);
            }
        }
        return bonusPowers;
    }

    public static bool HasBonusEffect(EnhancementSet enhancementSet, int slots, Enums.eEffectType effectType, Enums.eDamage damageType = Enums.eDamage.None)
    {
        List<IPower> bonusPowers = GetBonusPowers(enhancementSet);
        if (2 > slots || 6 < slots)
            return false;

        for (int bonusPowerIndex = 0; bonusPowerIndex < bonusPowers.Count; ++bonusPowerIndex)
        {
            if (bonusPowerIndex == slots - 1)
                return false;
            IPower bonusPower = bonusPowers[bonusPowerIndex];
            for (int effectIndex = 0; effectIndex < bonusPower.Effects.Length; ++effectIndex)
            {
                IEffect effect = bonusPower.Effects[effectIndex];
                if (effect.EffectType != effectType)
                    continue;
                if (Enums.eDamage.None == damageType)
                    return true;
                if (effect.DamageType == damageType)
                    return true;
            }
        }
        return false;
    }

    public static HashSet<EnhancementSet> GetEnhancementSetsWithBonusEffect(IPower power, int slots, Enums.eEffectType effectType, Enums.eDamage damageType = Enums.eDamage.None)
    {
        HashSet<EnhancementSet> enhancementSets = new HashSet<EnhancementSet>();
        if (1 > slots || 6 < slots)
            return enhancementSets;

        int[] validEnhancements = power.GetValidEnhancements(Enums.eType.SetO);

        for (int validEnhancementsIndex = 0; validEnhancementsIndex <= validEnhancements.Length - 1; ++validEnhancementsIndex)
        {
            IEnhancement enhancement = GetEnhancementByIndex(validEnhancements[validEnhancementsIndex]);
            if (null == enhancement)
                continue;
            EnhancementSet enhancementSet = GetEnhancementSet(enhancement);
            if (null == enhancementSet)
                continue;
            if (!HasBonusEffect(enhancementSet, slots, effectType, damageType))
                continue;
            enhancementSets.Add(enhancementSet);
        }
        return enhancementSets;
    }

    public static float SumBonusEffect(EnhancementSet enhancementSet, int slots, Enums.eEffectType effectType, Enums.eDamage damageType = Enums.eDamage.None)
    {
        float sum = 0.0f;
        if (1 > slots || 6 < slots)
            return sum;
        List<IPower> bonusPowers = GetBonusPowers(enhancementSet);

        for (int bonusPowerIndex = 0; bonusPowerIndex < bonusPowers.Count; ++bonusPowerIndex)
        {
            if (bonusPowerIndex == slots - 1)
                return sum;
            IPower bonusPower = bonusPowers[bonusPowerIndex];
            for (int effectIndex = 0; effectIndex < bonusPower.Effects.Length; ++effectIndex)
            {
                IEffect effect = bonusPower.Effects[effectIndex];
                if (effect.EffectType != effectType)
                    continue;
                if (Enums.eDamage.None == damageType || effect.DamageType == damageType)
                    sum += effect.Scale;
            }
        }
        return sum;
    }

    public static float SumBonusEffect(PowerEntry powerEntry, Enums.eEffectType effectType, Enums.eDamage damageType = Enums.eDamage.None)
    {
        float sum = 0.0f;
        Dictionary<string, List<IEnhancement>> enhancementGroups = GetEnhancementsGroupedBySet(powerEntry);

        foreach (KeyValuePair<string, List<IEnhancement>> kvp in enhancementGroups)
        {
            if ("None" == kvp.Key)
                continue;
            int enhancementsetIndex = GetEnhancementSetIndexByName(kvp.Key);
            if (-1 == enhancementsetIndex)
                continue;
            EnhancementSet enhancementSet = GetEnhancementSetByIndex(enhancementsetIndex);
            if (null == enhancementSet)
                continue;
            int enhancementCount = kvp.Value.Count;
            sum += SumBonusEffect(enhancementSet, enhancementCount, effectType, damageType);
        }
        return sum;
    }

    public static EnhancementSet GetHighestBonusEffect(HashSet<EnhancementSet> EnhancementSets, int slots, Enums.eEffectType effectType, Enums.eDamage damageType = Enums.eDamage.None)
    {
        EnhancementSet highest = null;
        if (1 > slots || 6 < slots)
            return highest;
        float sum = 0.0f;

        foreach (EnhancementSet enhancementSet in EnhancementSets)
        {
            float setSum = SumBonusEffect(enhancementSet, slots, effectType, damageType);
            if (setSum < sum)
                continue;
            sum = setSum;
            highest = enhancementSet;
        }
        return highest;
    }

    public static bool AllowsEnhancement(IPower power, EnhancementTypes enhancementType)
    {
        int[] allowedEnhancements = power.GetValidEnhancements(Enums.eType.InventO);
        foreach (int enhancementID in allowedEnhancements)
        {
            if (enhancementID == (int)enhancementType)
                return true;
        }
        return false;
    }

    public static Dictionary<string, List<IEnhancement>> GetEnhancementsGroupedBySet(PowerEntry powerEntry)
    {
        Dictionary<string, List<IEnhancement>> enhancementSets = new Dictionary<string, List<IEnhancement>>();
        foreach (SlotEntry slotEntry in powerEntry.Slots)
        {
            int enhancementIndex = slotEntry.Enhancement.Enh;
            IEnhancement enhancement = GetEnhancementByIndex(enhancementIndex);
            EnhancementSet enhancementSet = GetEnhancementSet(enhancement);
            string enhancementSetName = "None";
            List<IEnhancement> enhancementList;
            if (null != enhancementSet)
                enhancementSetName = enhancementSet.DisplayName;
            if (!enhancementSets.ContainsKey(enhancementSetName))
                enhancementSets.Add(enhancementSetName, new List<IEnhancement>());
            if (enhancementSets.TryGetValue(enhancementSetName, out enhancementList))
            {
                enhancementList.Add(enhancement);
            }
        }
        return enhancementSets;
    }

    // Call this after all database info has loaded, such as at the end of LoadEnhancementDb()
    public static void TestNewCode()
    {
        TestEnhancementListing();
        AIToon toon = TestCreateBuild();
        TestGetPowerByIndex();
        TestGetEnhancementByIndex();
        TestGetEnhancementSet();
        TestGetLoadSring();
        TestGetBonusPowers();
        TestHasBonusEffect();
        TestGetEnhancementSetsWithBonusEffect();
        TestSumBonusEffect(toon);
        TestGetHighestBonusEffect();
        TestAllowsEnhancement(toon);
        TestGetEnhancementsGroupedBySet(toon);
        PowerEntry.TestNewCode();
    }

    public static void TestGetPowerByIndex()
    {
        IPower power = GetPowerByIndex(0);
        Debug.Assert(power != null, "power is null!");
        Debug.Assert(power.DisplayName == "Single Shot", "power.DisplayName is incorrect!");

        power = GetPowerByIndex(100);
        Debug.Assert(power != null, "power is null!");
        Debug.Assert(power.DisplayName == "Blaze", "power.DisplayName is incorrect!");

        power = GetPowerByIndex(11000);
        Debug.Assert(power == null, "power is not null!");
    }

    public static void TestGetEnhancementByIndex()
    {
        IEnhancement enhancement = GetEnhancementByIndex(0);
        Debug.Assert(enhancement != null, "enhancement is null!");
        Debug.Assert(enhancement.Name == "Accuracy", "enhancement.Name is incorrect!");

        enhancement = GetEnhancementByIndex(100);
        Debug.Assert(enhancement != null, "enhancement is null!");
        Debug.Assert(enhancement.Name == "Accuracy/Damage/Endurance", "enhancement.Name is incorrect!");

        enhancement = GetEnhancementByIndex(1300);
        Debug.Assert(enhancement == null, "enhancement is not null!");
    }

    public static void TestGetEnhancementSet()
    {
        IEnhancement enhancement = GetEnhancementByIndex(0);
        EnhancementSet enhancementSet = GetEnhancementSet(enhancement);
        Debug.Assert(enhancementSet == null, "enhancementSet is not null!");

        enhancement = GetEnhancementByIndex(200);
        enhancementSet = GetEnhancementSet(enhancement);
        Debug.Assert(enhancementSet != null, "enhancementSet is null!");
        Debug.Assert(enhancementSet.DisplayName == "Executioner's Contract", "enhancementSet.DisplayName is incorrect!");

        int index = GetEnhancementSetIndexByName("Superior Winter's Bite");
        enhancementSet = GetEnhancementSetByIndex(index);
        Debug.Assert(enhancementSet.DisplayName == "Superior Winter's Bite", "enhancementSet.DisplayName is incorrect!");
    }

    public static void TestGetLoadSring()
    {
        IEnhancement enhancement = GetEnhancementByIndex(200);
        string loadString = GetLoadSring(enhancement);
        Debug.Assert(loadString == "Executioner's Contract:Stun%:4:-1:49:0:49", "loadString is incorrect!");

        enhancement = GetEnhancementByIndex(26);
        loadString = GetLoadSring(enhancement);
        Debug.Assert(loadString == ":Acc:2:-1:49:0:49", "loadString is incorrect!");
    }

    public static void TestGetBonusPowers()
    {
        IEnhancement enhancement = GetEnhancementByIndex(200);
        EnhancementSet enhancementSet = GetEnhancementSet(enhancement);
        List<IPower> bonusPowers = GetBonusPowers(enhancementSet);

        Debug.Assert(bonusPowers.Count == 5, "bonusPowers.Count is incorrect!");
        IPower[] bonusPowersArray = bonusPowers.ToArray();

        foreach (IPower power in bonusPowersArray)
        {
            Debug.Print(power.DisplayName);
        }
        Debug.Assert(bonusPowersArray[0].DisplayName == "Moderate Improved Recovery Bonus", "bonusPowersArray[0].DisplayName is incorrect!");
        Debug.Assert(bonusPowersArray[1].DisplayName == "Moderate Fire, Cold and Mez Resistance", "bonusPowersArray[1].DisplayName is incorrect!");
        Debug.Assert(bonusPowersArray[2].DisplayName == "Large Improved Regeneration Bonus", "bonusPowersArray[2].DisplayName is incorrect!");
        Debug.Assert(bonusPowersArray[3].DisplayName == "Large Lethal, Smash and Mez Resistance", "bonusPowersArray[3].DisplayName is incorrect!");
        Debug.Assert(bonusPowersArray[4].DisplayName == "Huge Increased Ranged/Energy/Negative Energy Def Bonus", "bonusPowersArray[4].DisplayName is incorrect!");

        bonusPowers = GetBonusPowers(null);
        Debug.Assert(bonusPowers.Count == 0, "bonusPowers.Count is incorrect!");
    }

    public static void TestHasBonusEffect()
    {
        IEnhancement enhancement = GetEnhancementByIndex(200);
        EnhancementSet enhancementSet = GetEnhancementSet(enhancement);
        bool hasEnergyDefenseBonus = HasBonusEffect(enhancementSet, 6, Enums.eEffectType.Defense, Enums.eDamage.Energy);
        Debug.Assert(hasEnergyDefenseBonus == true, "hasEnergyDefenseBonus is incorrect!");

        bool hasEnergyResistanceBonus = HasBonusEffect(enhancementSet, 6, Enums.eEffectType.Resistance, Enums.eDamage.Energy);
        Debug.Assert(hasEnergyResistanceBonus == false, "hasEnergyResistanceBonus is incorrect!");

        bool hasDefenseBonus = HasBonusEffect(enhancementSet, 6, Enums.eEffectType.Defense);
        Debug.Assert(hasDefenseBonus == true, "hasDefenseBonus is incorrect!");

        bool hasResistanceBonus = HasBonusEffect(enhancementSet, 6, Enums.eEffectType.Resistance);
        Debug.Assert(hasResistanceBonus == true, "hasResistanceBonus is incorrect!");

        bool hasFireDefenseBonus = HasBonusEffect(enhancementSet, 6, Enums.eEffectType.Defense, Enums.eDamage.Fire);
        Debug.Assert(hasFireDefenseBonus == false, "hasFireDefenseBonus is incorrect!");

        bool hasFireResistanceBonus = HasBonusEffect(enhancementSet, 6, Enums.eEffectType.Resistance, Enums.eDamage.Fire);
        Debug.Assert(hasFireResistanceBonus == true, "hasFireResistanceBonus is incorrect!");

        hasEnergyDefenseBonus = HasBonusEffect(enhancementSet, 5, Enums.eEffectType.Defense, Enums.eDamage.Energy);
        Debug.Assert(hasEnergyDefenseBonus == false, "hasEnergyDefenseBonus is incorrect!");

        bool hasSmashingResistanceBonus = HasBonusEffect(enhancementSet, 5, Enums.eEffectType.Resistance, Enums.eDamage.Smashing);
        Debug.Assert(hasSmashingResistanceBonus == true, "hasSmashingResistanceBonus is incorrect!");

        hasSmashingResistanceBonus = HasBonusEffect(enhancementSet, 4, Enums.eEffectType.Resistance, Enums.eDamage.Smashing);
        Debug.Assert(hasSmashingResistanceBonus == false, "hasSmashingResistanceBonus is incorrect!");

        bool hasRegenerationBonus = HasBonusEffect(enhancementSet, 4, Enums.eEffectType.Regeneration, Enums.eDamage.None);
        Debug.Assert(hasRegenerationBonus == true, "hasRegenerationBonus is incorrect!");

        hasRegenerationBonus = HasBonusEffect(enhancementSet, 3, Enums.eEffectType.Regeneration, Enums.eDamage.None);
        Debug.Assert(hasRegenerationBonus == false, "hasRegenerationBonus is incorrect!");

        hasFireResistanceBonus = HasBonusEffect(enhancementSet, 3, Enums.eEffectType.Resistance, Enums.eDamage.Fire);
        Debug.Assert(hasFireResistanceBonus == true, "hasFireResistanceBonus is incorrect!");

        hasFireResistanceBonus = HasBonusEffect(enhancementSet, 2, Enums.eEffectType.Resistance, Enums.eDamage.Fire);
        Debug.Assert(hasFireResistanceBonus == false, "hasFireResistanceBonus is incorrect!");
    }

    public static void TestGetEnhancementSetsWithBonusEffect()
    {
        IPower power = GetPowerByIndex(0);
        HashSet<EnhancementSet> defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 6, Enums.eEffectType.Defense);
        Debug.Print("Defense (6 slots)");
        foreach (EnhancementSet enhancementSet in defenseBonusSets)
        {
            Debug.Print(enhancementSet.DisplayName);
        }
        Debug.Assert(defenseBonusSets.Count == 14, "defenseBonusSets.Count is incorrect!");
        EnhancementSet[] defenseBonusSetsArray = defenseBonusSets.ToArray();
        Debug.Assert(defenseBonusSetsArray[0].DisplayName == "Maelstrom's Fury", "defenseBonusSetsArray[0].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[1].DisplayName == "Ruin", "defenseBonusSetsArray[1].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[2].DisplayName == "Thunderstrike", "defenseBonusSetsArray[2].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[3].DisplayName == "Devastation", "defenseBonusSetsArray[3].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[4].DisplayName == "Exploited Vulnerability", "defenseBonusSetsArray[4].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[5].DisplayName == "Achilles' Heel", "defenseBonusSetsArray[5].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[6].DisplayName == "Undermined Defenses", "defenseBonusSetsArray[6].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[7].DisplayName == "Apocalypse", "defenseBonusSetsArray[7].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[8].DisplayName == "Shield Breaker", "defenseBonusSetsArray[8].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[9].DisplayName == "Overwhelming Force", "defenseBonusSetsArray[9].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[10].DisplayName == "Spider's Bite", "defenseBonusSetsArray[10].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[11].DisplayName == "Superior Spider's Bite", "defenseBonusSetsArray[11].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[12].DisplayName == "Winter's Bite", "defenseBonusSetsArray[12].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[13].DisplayName == "Superior Winter's Bite", "defenseBonusSetsArray[13].DisplayName is incorrect!");

        HashSet<EnhancementSet> psionicDefenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 6, Enums.eEffectType.Defense, Enums.eDamage.Psionic);
        Debug.Assert(psionicDefenseBonusSets.Count == 2, "psionicDefenseBonusSets.Count is incorrect!");
        EnhancementSet[] psionicDefenseBonusSetsArray = psionicDefenseBonusSets.ToArray();

        Debug.Assert(psionicDefenseBonusSetsArray[0].DisplayName == "Devastation", "psionicDefenseBonusSetsArray[0].DisplayName is incorrect!");
        Debug.Assert(psionicDefenseBonusSetsArray[1].DisplayName == "Apocalypse", "psionicDefenseBonusSetsArray[1].DisplayName is incorrect!");
        Debug.Print(" ");
        Debug.Print("Psionic Defense (6 slots)");
        foreach (EnhancementSet enhancementSet in psionicDefenseBonusSets)
        {
            Debug.Print(enhancementSet.DisplayName);
        }

        HashSet<EnhancementSet> enduranceDiscountBonusSets = GetEnhancementSetsWithBonusEffect(power, 6, Enums.eEffectType.EnduranceDiscount);
        Debug.Assert(enduranceDiscountBonusSets.Count == 0, "enduranceDiscountBonusSets.Count is incorrect!");
        Debug.Print(" ");
        Debug.Print("EnduranceDiscount (6 slots)");
        foreach (EnhancementSet enhancementSet in enduranceDiscountBonusSets)
        {
            Debug.Print(enhancementSet.DisplayName);
        }
        Debug.Print(" ");

        defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 5, Enums.eEffectType.Defense);
        Debug.Print("Defense (5 slots)");
        foreach (EnhancementSet enhancementSet in defenseBonusSets)
        {
            Debug.Print(enhancementSet.DisplayName);
        }
        Debug.Assert(defenseBonusSets.Count == 11, "defenseBonusSets.Count is incorrect!");
        defenseBonusSetsArray = defenseBonusSets.ToArray();
        Debug.Assert(defenseBonusSetsArray[0].DisplayName == "Maelstrom's Fury", "defenseBonusSetsArray[0].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[1].DisplayName == "Ruin", "defenseBonusSetsArray[1].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[2].DisplayName == "Thunderstrike", "defenseBonusSetsArray[2].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[3].DisplayName == "Exploited Vulnerability", "defenseBonusSetsArray[3].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[4].DisplayName == "Achilles' Heel", "defenseBonusSetsArray[4].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[5].DisplayName == "Shield Breaker", "defenseBonusSetsArray[5].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[6].DisplayName == "Overwhelming Force", "defenseBonusSetsArray[6].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[7].DisplayName == "Spider's Bite", "defenseBonusSetsArray[7].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[8].DisplayName == "Superior Spider's Bite", "defenseBonusSetsArray[8].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[9].DisplayName == "Winter's Bite", "defenseBonusSetsArray[9].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[10].DisplayName == "Superior Winter's Bite", "defenseBonusSetsArray[10].DisplayName is incorrect!");
        Debug.Print(" ");

        defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 4, Enums.eEffectType.Defense);
        Debug.Print("Defense (4 slots)");
        foreach (EnhancementSet enhancementSet in defenseBonusSets)
        {
            Debug.Print(enhancementSet.DisplayName);
        }
        Debug.Assert(defenseBonusSets.Count == 7, "defenseBonusSets.Count is incorrect!");
        defenseBonusSetsArray = defenseBonusSets.ToArray();
        Debug.Assert(defenseBonusSetsArray[0].DisplayName == "Maelstrom's Fury", "defenseBonusSetsArray[0].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[1].DisplayName == "Thunderstrike", "defenseBonusSetsArray[1].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[2].DisplayName == "Exploited Vulnerability", "defenseBonusSetsArray[2].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[3].DisplayName == "Achilles' Heel", "defenseBonusSetsArray[3].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[4].DisplayName == "Shield Breaker", "defenseBonusSetsArray[4].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[5].DisplayName == "Spider's Bite", "defenseBonusSetsArray[5].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[6].DisplayName == "Superior Spider's Bite", "defenseBonusSetsArray[6].DisplayName is incorrect!");
        Debug.Print(" ");

        defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 3, Enums.eEffectType.Defense);
        Debug.Print("Defense (3 slots)");
        foreach (EnhancementSet enhancementSet in defenseBonusSets)
        {
            Debug.Print(enhancementSet.DisplayName);
        }
        Debug.Assert(defenseBonusSets.Count == 4, "defenseBonusSets.Count is incorrect!");
        defenseBonusSetsArray = defenseBonusSets.ToArray();
        Debug.Assert(defenseBonusSetsArray[0].DisplayName == "Maelstrom's Fury", "defenseBonusSetsArray[0].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[1].DisplayName == "Thunderstrike", "defenseBonusSetsArray[1].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[2].DisplayName == "Exploited Vulnerability", "defenseBonusSetsArray[2].DisplayName is incorrect!");
        Debug.Assert(defenseBonusSetsArray[3].DisplayName == "Achilles' Heel", "defenseBonusSetsArray[3].DisplayName is incorrect!");
        Debug.Print(" ");

        defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 2, Enums.eEffectType.Defense);
        Debug.Print("Defense (2 slots)");
        foreach (EnhancementSet enhancementSet in defenseBonusSets)
        {
            Debug.Print(enhancementSet.DisplayName);
        }
        Debug.Assert(defenseBonusSets.Count == 0, "defenseBonusSets.Count is incorrect!");
        Debug.Print(" ");
    }

    public static void TestSumBonusEffect(AIToon toon)
    {
        IEnhancement enhancement = GetEnhancementByIndex(200);
        EnhancementSet enhancementSet = GetEnhancementSet(enhancement);
        float sum = SumBonusEffect(enhancementSet, 6, Enums.eEffectType.Defense, Enums.eDamage.None);
        Debug.Assert(sum >= 0.075 && sum < 0.0752, "sum is incorrect!");
        sum = SumBonusEffect(enhancementSet, 5, Enums.eEffectType.Defense, Enums.eDamage.None);
        Debug.Assert(sum == 0.0, "sum is incorrect!");
        sum = SumBonusEffect(enhancementSet, 6, Enums.eEffectType.Resistance, Enums.eDamage.None);
        Debug.Assert(sum > 0.13444 && sum < 0.135, "sum is incorrect!");

        PowerEntry fireball = toon.Level2;
        EnhancementSet[] enhancementSets = GetEnhancementSetsWithBonusEffect(fireball.Power, 3, Enums.eEffectType.Resistance, Enums.eDamage.Fire).ToArray();
        EnhancementSet ragnarok = enhancementSets[1];
        EnhancementSet positronsBlast = enhancementSets[0];
        fireball.Slots[0].LoadFromString(GetLoadSring(GetEnhancementByIndex(positronsBlast.Enhancements[0])), ":");
        fireball.Slots[1].LoadFromString(GetLoadSring(GetEnhancementByIndex(positronsBlast.Enhancements[1])), ":");
        fireball.Slots[2].LoadFromString(GetLoadSring(GetEnhancementByIndex(positronsBlast.Enhancements[2])), ":");
        sum = SumBonusEffect(fireball, Enums.eEffectType.Resistance, Enums.eDamage.Fire);
        Debug.Assert(sum > 0.0224 && sum < 0.0226, "sum is incorrect!");
        fireball.Slots[0].LoadFromString(GetLoadSring(GetEnhancementByIndex(ragnarok.Enhancements[0])), ":");
        fireball.Slots[1].LoadFromString(GetLoadSring(GetEnhancementByIndex(ragnarok.Enhancements[1])), ":");
        fireball.Slots[2].LoadFromString(GetLoadSring(GetEnhancementByIndex(ragnarok.Enhancements[2])), ":");
        sum = SumBonusEffect(fireball, Enums.eEffectType.Resistance, Enums.eDamage.Fire);
        Debug.Assert(sum > 0.059 && sum < 0.061, "sum is incorrect!");
        fireball.Slots[3].LoadFromString(GetLoadSring(GetEnhancementByIndex(positronsBlast.Enhancements[0])), ":");
        fireball.Slots[4].LoadFromString(GetLoadSring(GetEnhancementByIndex(positronsBlast.Enhancements[1])), ":");
        fireball.Slots[5].LoadFromString(GetLoadSring(GetEnhancementByIndex(positronsBlast.Enhancements[2])), ":");
        sum = SumBonusEffect(fireball, Enums.eEffectType.Resistance, Enums.eDamage.Fire);
        Debug.Assert(sum > 0.0824 && sum < 0.0826, "sum is incorrect!");

        string acc = GetLoadSring(GetEnhancementByIndex(26));
        string dam = GetLoadSring(GetEnhancementByIndex(29));
        string rech = GetLoadSring(GetEnhancementByIndex(43));
        toon.Level2.Slots[0].LoadFromString(acc, ":");
        toon.Level2.Slots[1].LoadFromString(dam, ":");
        toon.Level2.Slots[2].LoadFromString(dam, ":");
        toon.Level2.Slots[3].LoadFromString(dam, ":");
        toon.Level2.Slots[4].LoadFromString(rech, ":");
        toon.Level2.Slots[5].LoadFromString(rech, ":");
        Debug.Assert(toon.Level2.Slots[0].Enhancement.Enh == 26, "toon.Level2.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[1].Enhancement.Enh == 29, "toon.Level2.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[2].Enhancement.Enh == 29, "toon.Level2.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[3].Enhancement.Enh == 29, "toon.Level2.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[4].Enhancement.Enh == 43, "toon.Level2.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[5].Enhancement.Enh == 43, "toon.Level2.Slots[5].Enhancement.Enh is incorrect!");

    }

    public static void TestGetHighestBonusEffect()
    {
        IPower power = GetPowerByIndex(0);
        HashSet<EnhancementSet> defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 6, Enums.eEffectType.Defense);
        EnhancementSet highestBonusEffect = GetHighestBonusEffect(defenseBonusSets, 6, Enums.eEffectType.Defense);
        Debug.Print("Highest Defense (6 slots)");
        Debug.Print(highestBonusEffect.DisplayName + " " + SumBonusEffect(highestBonusEffect, 6, Enums.eEffectType.Defense));
        Debug.Print(" ");
        Debug.Assert(highestBonusEffect.DisplayName == "Superior Winter's Bite", "highestBonusEffect.DisplayName is incorrect!");

        defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 5, Enums.eEffectType.Defense);
        highestBonusEffect = GetHighestBonusEffect(defenseBonusSets, 5, Enums.eEffectType.Defense);
        Debug.Print("Highest Defense (5 slots)");
        Debug.Print(highestBonusEffect.DisplayName + " " + SumBonusEffect(highestBonusEffect, 5, Enums.eEffectType.Defense));
        Debug.Print(" ");
        Debug.Assert(highestBonusEffect.DisplayName == "Superior Winter's Bite", "highestBonusEffect.DisplayName is incorrect!");

        defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 4, Enums.eEffectType.Defense);
        highestBonusEffect = GetHighestBonusEffect(defenseBonusSets, 4, Enums.eEffectType.Defense);
        Debug.Print("Highest Defense (4 slots)");
        Debug.Print(highestBonusEffect.DisplayName + " " + SumBonusEffect(highestBonusEffect, 4, Enums.eEffectType.Defense));
        Debug.Print(" ");
        Debug.Assert(highestBonusEffect.DisplayName == "Superior Spider's Bite", "highestBonusEffect.DisplayName is incorrect!");

        defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 3, Enums.eEffectType.Defense);
        highestBonusEffect = GetHighestBonusEffect(defenseBonusSets, 3, Enums.eEffectType.Defense);
        Debug.Print("Highest Defense (3 slots)");
        Debug.Print(highestBonusEffect.DisplayName + " " + SumBonusEffect(highestBonusEffect, 3, Enums.eEffectType.Defense));
        Debug.Print(" ");
        Debug.Assert(highestBonusEffect.DisplayName == "Thunderstrike", "highestBonusEffect.DisplayName is incorrect!");

        defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 2, Enums.eEffectType.Defense);
        highestBonusEffect = GetHighestBonusEffect(defenseBonusSets, 2, Enums.eEffectType.Defense);
        Debug.Print("Highest Defense (2 slots)");
        if (null != highestBonusEffect) Debug.Print(highestBonusEffect.DisplayName + " " + SumBonusEffect(highestBonusEffect, 2, Enums.eEffectType.Defense));
        Debug.Print(" ");

        defenseBonusSets = GetEnhancementSetsWithBonusEffect(power, 6, Enums.eEffectType.Defense, Enums.eDamage.Psionic);
        highestBonusEffect = GetHighestBonusEffect(defenseBonusSets, 6, Enums.eEffectType.Defense, Enums.eDamage.Psionic);
        Debug.Print(" ");
        Debug.Print("Highest Psionic Defense");
        Debug.Print(highestBonusEffect.DisplayName);
        Debug.Assert(highestBonusEffect.DisplayName == "Apocalypse", "highestBonusEffect.DisplayName is incorrect!");
    }

    public static void TestAllowsEnhancement(AIToon toon)
    {
        Debug.Assert(AllowsEnhancement(toon.Level1Primary.Power, EnhancementTypes.Accuracy) == true, "AllowsEnhancement EnhancementTypes.Accuracy is incorrect!");
        Debug.Assert(AllowsEnhancement(toon.Level1Primary.Power, EnhancementTypes.Damage) == true, "AllowsEnhancement EnhancementTypes.Damage is incorrect!");
        Debug.Assert(AllowsEnhancement(toon.Level1Primary.Power, EnhancementTypes.EnduranceReduction) == true, "AllowsEnhancement EnhancementTypes.EnduranceReduction is incorrect!");
        Debug.Assert(AllowsEnhancement(toon.Level1Primary.Power, EnhancementTypes.Recharge) == true, "AllowsEnhancement EnhancementTypes.Recharge is incorrect!");
        Debug.Assert(AllowsEnhancement(toon.Level1Primary.Power, EnhancementTypes.Heal) == false, "AllowsEnhancement EnhancementTypes.Heal is incorrect!");
    }

    public static void TestEnhancementListing()
    {
        List<string> linesList = new List<string>();
        string headers = "Name, Set Type, Effect Type, Damage/Enhancement/Mez Type, Scale, Slots Required, Min Level, Max Level, PvP Bonus?";
        Debug.Print(" ");
        Debug.Print(headers);
        linesList.Add(headers);
        foreach (EnhancementSet enhancementSet in Database.EnhancementSets)
        {
            List<IPower> bonusPowers = GetBonusPowers(enhancementSet);
            int slotsRequired = 2;
            foreach (IPower bonusPower in bonusPowers)
            {
                for (int effectIndex = 0; effectIndex < bonusPower.Effects.Length; ++effectIndex)
                {
                    IEffect effect = bonusPower.Effects[effectIndex];
                    string DEMType = effect.DamageType.ToString();
                    if (effect.ETModifies != Enums.eEffectType.None)
                        DEMType = effect.ETModifies.ToString();
                    if (effect.MezType != Enums.eMez.None)
                        DEMType = effect.MezType.ToString();
                    string line = enhancementSet.DisplayName + ", " + enhancementSet.SetType + ", " + effect.EffectType + ", " + DEMType + ", " + effect.Scale + ", " + slotsRequired + ", " + (enhancementSet.LevelMin + 1) + ", " + (enhancementSet.LevelMax + 1);
                    if (bonusPower.SetName.Equals("PvP_Set_Bonus", StringComparison.InvariantCultureIgnoreCase))
                    {
                        line += ", True";
                    } else {
                        line += ", False";
                    }
                    Debug.Print(line);
                    linesList.Add(line);
                    if (effect.EffectType == Enums.eEffectType.Enhancement)
                    {
                        int x = 1;
                    }
                    if (enhancementSet.DisplayName == "Expedient Reinforcement")
                    {
                        for (int enhancementIndex = 0; enhancementIndex < enhancementSet.Enhancements.Length; ++enhancementIndex)
                        {
                            IEnhancement enhancement = GetEnhancementByIndex(enhancementSet.Enhancements[enhancementIndex]);
                            int x = 1;
                        }

                    }
                }
                ++slotsRequired;
                if (6 < slotsRequired)
                    slotsRequired = 2;
            }
        }
        string[] lines = linesList.ToArray();
        System.IO.File.WriteAllLines(@"D:\src\CoH\enhancement-set-bonus.csv", lines);
    }

    public static AIToon TestCreateBuild()
    {
        AIToon toon = new AIToon();
        toon.Archetype = DatabaseAPI.GetArchetypeByName("Blaster");
        Debug.Assert(toon.Archetype.DisplayName == "Blaster", "toon.Archetype.DisplayName is incorrect!");

        toon.Fitness = GetPowersetByName("Inherent Fitness", Enums.ePowerSetType.Inherent);
        toon.Primary = GetPowersetByName("Fire Blast", Enums.ePowerSetType.Primary);
        toon.Secondary = GetPowersetByName("Mental Manipulation", Enums.ePowerSetType.Secondary);
        toon.Pool1 = GetPowersetByName("Speed", Enums.ePowerSetType.Pool);
        toon.Pool2 = GetPowersetByName("Fighting", Enums.ePowerSetType.Pool);
        toon.Pool3 = GetPowersetByName("Concealment", Enums.ePowerSetType.Pool);
        toon.Pool4 = GetPowersetByName("Force of Will", Enums.ePowerSetType.Pool);
        toon.Epic = GetPowersetByName("Force Mastery", Enums.ePowerSetType.Ancillary);
        Debug.Assert(toon.Fitness.DisplayName == "Inherent Fitness", "toon.Fitness.DisplayName is incorrect!");
        Debug.Assert(toon.Primary.DisplayName == "Fire Blast", "toon.Primary.DisplayName is incorrect!");
        Debug.Assert(toon.Secondary.DisplayName == "Mental Manipulation", "toon.Secondary.DisplayName is incorrect!");
        Debug.Assert(toon.Pool1.DisplayName == "Speed", "toon.Pool1.DisplayName is incorrect!");
        Debug.Assert(toon.Pool2.DisplayName == "Fighting", "toon.Pool2.DisplayName is incorrect!");
        Debug.Assert(toon.Pool3.DisplayName == "Concealment", "toon.Pool3.DisplayName is incorrect!");
        Debug.Assert(toon.Pool4.DisplayName == "Force of Will", "toon.Pool4.DisplayName is incorrect!");
        Debug.Assert(toon.Epic.DisplayName == "Force Mastery", "toon.Epic.DisplayName is incorrect!");

        toon.Health = new PowerEntry(1, toon.Fitness.Powers[1]);                    // Health
        toon.Stamina = new PowerEntry(1, toon.Fitness.Powers[3]);                   // Stamina
        toon.Level1Primary = new PowerEntry(1, toon.Primary.Powers[0]);             // Flares
        toon.Level1Secondary = new PowerEntry(1, toon.Secondary.Powers[0]);         // Subdual
        toon.Level2 = new PowerEntry(2, toon.Primary.Powers[2]);                    // Fire Ball
        toon.Level4 = new PowerEntry(4, toon.Pool1.Powers[1]);                      // Hasten
        toon.Level6 = new PowerEntry(6, toon.Primary.Powers[3]);                    // Rain of Fire
        toon.Level8 = new PowerEntry(8, toon.Pool2.Powers[1]);                      // Kick
        toon.Level10 = new PowerEntry(10, toon.Pool3.Powers[1]);                    // Grant Invisibility
        toon.Level12 = new PowerEntry(12, toon.Primary.Powers[5]);                  // Aim
        toon.Level14 = new PowerEntry(14, toon.Secondary.Powers[3]);                // Psychic Scream
        toon.Level16 = new PowerEntry(16, toon.Secondary.Powers[4]);                // Concentration
        toon.Level18 = new PowerEntry(18, toon.Primary.Powers[6]);                  // Blaze
        toon.Level20 = new PowerEntry(20, toon.Pool3.Powers[2]);                    // Invisibility
        toon.Level22 = new PowerEntry(22, toon.Pool2.Powers[3]);                    // Tough
        toon.Level24 = new PowerEntry(24, toon.Pool2.Powers[4]);                    // Weave
        toon.Level26 = new PowerEntry(26, toon.Primary.Powers[7]);                  // Blazing Bolt
        toon.Level28 = new PowerEntry(28, toon.Pool4.Powers[1]);                    // Weaken Resolve
        toon.Level30 = new PowerEntry(30, toon.Pool1.Powers[2]);                    // Super Speed
        toon.Level32 = new PowerEntry(32, toon.Primary.Powers[8]);                  // Inferno
        toon.Level35 = new PowerEntry(35, toon.Epic.Powers[0]);                     // Personal Force Field
        toon.Level38 = new PowerEntry(38, toon.Secondary.Powers[8]);                // Psychic Shockwave
        toon.Level41 = new PowerEntry(41, toon.Epic.Powers[3]);                     // Temp Invulnerability
        toon.Level44 = new PowerEntry(44, toon.Epic.Powers[4]);                     // Force of Nature
        toon.Level47 = new PowerEntry(47, toon.Epic.Powers[1]);                     // Repulsion Field
        toon.Level49 = new PowerEntry(49, toon.Pool1.Powers[3]);                    // Burnout
        Debug.Assert(toon.Health.Power.DisplayName == "Health", "toon.Health.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Stamina.Power.DisplayName == "Stamina", "toon.Stamina.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level1Primary.Power.DisplayName == "Flares", "toon.Level1Primary.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level1Secondary.Power.DisplayName == "Subdual", "toon.Level1Secondary.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level2.Power.DisplayName == "Fire Ball", "toon.Level2.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level4.Power.DisplayName == "Hasten", "toon.Level4.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level6.Power.DisplayName == "Rain of Fire", "toon.Level6.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level8.Power.DisplayName == "Kick", "toon.Level8.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level10.Power.DisplayName == "Grant Invisibility", "toon.Level10.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level12.Power.DisplayName == "Aim", "toon.Level12.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level14.Power.DisplayName == "Psychic Scream", "toon.Level14.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level16.Power.DisplayName == "Concentration", "toon.Level16.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level18.Power.DisplayName == "Blaze", "toon.Level18.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level20.Power.DisplayName == "Invisibility", "toon.Level20.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level22.Power.DisplayName == "Tough", "toon.Level22.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level24.Power.DisplayName == "Weave", "toon.Level24.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level26.Power.DisplayName == "Blazing Bolt", "toon.Level26.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level28.Power.DisplayName == "Weaken Resolve", "toon.Level28.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level30.Power.DisplayName == "Super Speed", "toon.Level30.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level32.Power.DisplayName == "Inferno", "toon.Level32.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level35.Power.DisplayName == "Personal Force Field", "toon.Level35.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level38.Power.DisplayName == "Psychic Shockwave", "toon.Level38.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level41.Power.DisplayName == "Temp Invulnerability", "toon.Level41.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level44.Power.DisplayName == "Force of Nature", "toon.Level44.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level47.Power.DisplayName == "Repulsion Field", "toon.Level47.Power.DisplayName is incorrect!");
        Debug.Assert(toon.Level49.Power.DisplayName == "Burnout", "toon.Level49.Power.DisplayName is incorrect!");

        toon.Stamina.AddSlot(3);
        toon.Stamina.AddSlot(3);
        toon.Stamina.AddSlot(5);
        toon.Health.AddSlot(5);
        toon.Level1Primary.AddSlot(11);
        toon.Level1Primary.AddSlot(11);
        toon.Level1Primary.AddSlot(21);
        toon.Level1Primary.AddSlot(36);
        toon.Level2.AddSlot(7);
        toon.Level2.AddSlot(7);
        toon.Level2.AddSlot(17);
        toon.Level2.AddSlot(36);
        toon.Level2.AddSlot(50);
        toon.Level4.AddSlot(13);
        toon.Level6.AddSlot(9);
        toon.Level6.AddSlot(9);
        toon.Level6.AddSlot(21);
        toon.Level6.AddSlot(37);
        toon.Level6.AddSlot(50);
        toon.Level12.AddSlot(13);
        toon.Level14.AddSlot(15);
        toon.Level14.AddSlot(15);
        toon.Level14.AddSlot(23);
        toon.Level14.AddSlot(37);
        toon.Level16.AddSlot(17);
        toon.Level18.AddSlot(19);
        toon.Level18.AddSlot(19);
        toon.Level18.AddSlot(23);
        toon.Level18.AddSlot(37);
        toon.Level20.AddSlot(31);
        toon.Level20.AddSlot(31);
        toon.Level20.AddSlot(31);
        toon.Level22.AddSlot(34);
        toon.Level22.AddSlot(34);
        toon.Level22.AddSlot(36);
        toon.Level22.AddSlot(45);
        toon.Level22.AddSlot(45);
        toon.Level24.AddSlot(25);
        toon.Level24.AddSlot(25);
        toon.Level24.AddSlot(29);
        toon.Level24.AddSlot(43);
        toon.Level26.AddSlot(27);
        toon.Level26.AddSlot(27);
        toon.Level26.AddSlot(29);
        toon.Level26.AddSlot(40);
        toon.Level28.AddSlot(40);
        toon.Level28.AddSlot(43);
        toon.Level32.AddSlot(33);
        toon.Level32.AddSlot(33);
        toon.Level32.AddSlot(33);
        toon.Level32.AddSlot(34);
        toon.Level38.AddSlot(39);
        toon.Level38.AddSlot(39);
        toon.Level38.AddSlot(39);
        toon.Level38.AddSlot(40);
        toon.Level41.AddSlot(42);
        toon.Level41.AddSlot(42);
        toon.Level41.AddSlot(42);
        toon.Level41.AddSlot(43);
        toon.Level41.AddSlot(45);
        toon.Level44.AddSlot(46);
        toon.Level44.AddSlot(46);
        toon.Level44.AddSlot(46);
        toon.Level44.AddSlot(48);
        toon.Level47.AddSlot(48);
        toon.Level47.AddSlot(48);
        toon.Level49.AddSlot(50);
        Debug.Assert(toon.Stamina.Slots.Length == 4, "toon.Stamina.Slots.Length is incorrect!");
        Debug.Assert(toon.Health.Slots.Length == 2, "toon.Health.Slots.Length is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots.Length == 5, "toon.Level1Primary.Slots.Length is incorrect!");
        Debug.Assert(toon.Level1Secondary.Slots.Length == 1, "toon.Level1Secondary.Slots.Length is incorrect!");
        Debug.Assert(toon.Level2.Slots.Length == 6, "toon.Level2.Slots.Length is incorrect!");
        Debug.Assert(toon.Level4.Slots.Length == 2, "toon.Level4.Slots.Length is incorrect!");
        Debug.Assert(toon.Level6.Slots.Length == 6, "toon.Level6.Slots.Length is incorrect!");
        Debug.Assert(toon.Level8.Slots.Length == 1, "toon.Level8.Slots.Length is incorrect!");
        Debug.Assert(toon.Level10.Slots.Length == 1, "toon.Level10.Slots.Length is incorrect!");
        Debug.Assert(toon.Level12.Slots.Length == 2, "toon.Level12.Slots.Length is incorrect!");
        Debug.Assert(toon.Level14.Slots.Length == 5, "toon.Level14.Slots.Length is incorrect!");
        Debug.Assert(toon.Level16.Slots.Length == 2, "toon.Level16.Slots.Length is incorrect!");
        Debug.Assert(toon.Level18.Slots.Length == 5, "toon.Level18.Slots.Length is incorrect!");
        Debug.Assert(toon.Level20.Slots.Length == 4, "toon.Level20.Slots.Length is incorrect!");
        Debug.Assert(toon.Level22.Slots.Length == 6, "toon.Level22.Slots.Length is incorrect!");
        Debug.Assert(toon.Level24.Slots.Length == 5, "toon.Level24.Slots.Length is incorrect!");
        Debug.Assert(toon.Level26.Slots.Length == 5, "toon.Level26.Slots.Length is incorrect!");
        Debug.Assert(toon.Level28.Slots.Length == 3, "toon.Level28.Slots.Length is incorrect!");
        Debug.Assert(toon.Level30.Slots.Length == 1, "toon.Level30.Slots.Length is incorrect!");
        Debug.Assert(toon.Level32.Slots.Length == 5, "toon.Level32.Slots.Length is incorrect!");
        Debug.Assert(toon.Level35.Slots.Length == 1, "toon.Level35.Slots.Length is incorrect!");
        Debug.Assert(toon.Level38.Slots.Length == 5, "toon.Level38.Slots.Length is incorrect!");
        Debug.Assert(toon.Level41.Slots.Length == 6, "toon.Level41.Slots.Length is incorrect!");
        Debug.Assert(toon.Level44.Slots.Length == 5, "toon.Level44.Slots.Length is incorrect!");
        Debug.Assert(toon.Level47.Slots.Length == 3, "toon.Level47.Slots.Length is incorrect!");
        Debug.Assert(toon.Level49.Slots.Length == 2, "toon.Level49.Slots.Length is incorrect!");

        string acc = GetLoadSring(GetEnhancementByIndex(26));
        string dam = GetLoadSring(GetEnhancementByIndex(29));
        string endMod = GetLoadSring(GetEnhancementByIndex(32));
        string endRed = GetLoadSring(GetEnhancementByIndex(33));
        string def = GetLoadSring(GetEnhancementByIndex(30));
        string heal = GetLoadSring(GetEnhancementByIndex(36));
        string rech = GetLoadSring(GetEnhancementByIndex(43));
        string res = GetLoadSring(GetEnhancementByIndex(44));

        toon.Stamina.Slots[0].LoadFromString(endMod, ":");
        toon.Stamina.Slots[1].LoadFromString(endMod, ":");
        toon.Stamina.Slots[2].LoadFromString(endMod, ":");
        toon.Health.Slots[0].LoadFromString(heal, ":");
        toon.Health.Slots[1].LoadFromString(heal, ":");
        toon.Level1Primary.Slots[0].LoadFromString(acc, ":");
        toon.Level1Primary.Slots[1].LoadFromString(dam, ":");
        toon.Level1Primary.Slots[2].LoadFromString(dam, ":");
        toon.Level1Primary.Slots[3].LoadFromString(dam, ":");
        toon.Level1Primary.Slots[4].LoadFromString(rech, ":");
        toon.Level1Secondary.Slots[0].LoadFromString(acc, ":");
        toon.Level2.Slots[0].LoadFromString(acc, ":");
        toon.Level2.Slots[1].LoadFromString(dam, ":");
        toon.Level2.Slots[2].LoadFromString(dam, ":");
        toon.Level2.Slots[3].LoadFromString(dam, ":");
        toon.Level2.Slots[4].LoadFromString(rech, ":");
        toon.Level2.Slots[5].LoadFromString(rech, ":");
        toon.Level4.Slots[0].LoadFromString(rech, ":");
        toon.Level4.Slots[1].LoadFromString(rech, ":");
        toon.Level6.Slots[0].LoadFromString(acc, ":");
        toon.Level6.Slots[1].LoadFromString(dam, ":");
        toon.Level6.Slots[2].LoadFromString(dam, ":");
        toon.Level6.Slots[3].LoadFromString(dam, ":");
        toon.Level6.Slots[4].LoadFromString(rech, ":");
        toon.Level6.Slots[5].LoadFromString(rech, ":");
        toon.Level8.Slots[0].LoadFromString(acc, ":");
        toon.Level10.Slots[0].LoadFromString(def, ":");
        toon.Level12.Slots[0].LoadFromString(rech, ":");
        toon.Level12.Slots[1].LoadFromString(rech, ":");
        toon.Level14.Slots[0].LoadFromString(acc, ":");
        toon.Level14.Slots[1].LoadFromString(dam, ":");
        toon.Level14.Slots[2].LoadFromString(dam, ":");
        toon.Level14.Slots[3].LoadFromString(dam, ":");
        toon.Level14.Slots[4].LoadFromString(rech, ":");
        toon.Level16.Slots[0].LoadFromString(rech, ":");
        toon.Level16.Slots[1].LoadFromString(rech, ":");
        toon.Level18.Slots[0].LoadFromString(acc, ":");
        toon.Level18.Slots[1].LoadFromString(dam, ":");
        toon.Level18.Slots[2].LoadFromString(dam, ":");
        toon.Level18.Slots[3].LoadFromString(dam, ":");
        toon.Level18.Slots[4].LoadFromString(rech, ":");
        toon.Level20.Slots[0].LoadFromString(endRed, ":");
        toon.Level20.Slots[1].LoadFromString(def, ":");
        toon.Level20.Slots[2].LoadFromString(def, ":");
        toon.Level20.Slots[3].LoadFromString(def, ":");
        toon.Level22.Slots[0].LoadFromString(endRed, ":");
        toon.Level22.Slots[1].LoadFromString(endRed, ":");
        toon.Level22.Slots[2].LoadFromString(res, ":");
        toon.Level22.Slots[3].LoadFromString(res, ":");
        toon.Level22.Slots[4].LoadFromString(res, ":");
        toon.Level22.Slots[5].LoadFromString(rech, ":");
        toon.Level24.Slots[0].LoadFromString(endRed, ":");
        toon.Level24.Slots[1].LoadFromString(endRed, ":");
        toon.Level24.Slots[2].LoadFromString(def, ":");
        toon.Level24.Slots[3].LoadFromString(def, ":");
        toon.Level24.Slots[4].LoadFromString(def, ":");
        toon.Level26.Slots[0].LoadFromString(acc, ":");
        toon.Level26.Slots[1].LoadFromString(dam, ":");
        toon.Level26.Slots[2].LoadFromString(dam, ":");
        toon.Level26.Slots[3].LoadFromString(dam, ":");
        toon.Level26.Slots[4].LoadFromString(rech, ":");
        toon.Level28.Slots[0].LoadFromString(acc, ":");
        toon.Level28.Slots[1].LoadFromString(rech, ":");
        toon.Level28.Slots[2].LoadFromString(rech, ":");
        toon.Level30.Slots[0].LoadFromString(endRed, ":");
        toon.Level32.Slots[0].LoadFromString(acc, ":");
        toon.Level32.Slots[1].LoadFromString(dam, ":");
        toon.Level32.Slots[2].LoadFromString(dam, ":");
        toon.Level32.Slots[3].LoadFromString(dam, ":");
        toon.Level32.Slots[4].LoadFromString(rech, ":");
        toon.Level35.Slots[0].LoadFromString(rech, ":");
        toon.Level38.Slots[0].LoadFromString(acc, ":");
        toon.Level38.Slots[1].LoadFromString(dam, ":");
        toon.Level38.Slots[2].LoadFromString(dam, ":");
        toon.Level38.Slots[3].LoadFromString(dam, ":");
        toon.Level38.Slots[4].LoadFromString(rech, ":");
        toon.Level41.Slots[0].LoadFromString(res, ":");
        toon.Level41.Slots[1].LoadFromString(res, ":");
        toon.Level41.Slots[2].LoadFromString(res, ":");
        toon.Level41.Slots[3].LoadFromString(endRed, ":");
        toon.Level41.Slots[4].LoadFromString(endRed, ":");
        toon.Level41.Slots[5].LoadFromString(endRed, ":");
        toon.Level44.Slots[0].LoadFromString(res, ":");
        toon.Level44.Slots[1].LoadFromString(res, ":");
        toon.Level44.Slots[2].LoadFromString(res, ":");
        toon.Level44.Slots[3].LoadFromString(rech, ":");
        toon.Level44.Slots[4].LoadFromString(rech, ":");
        toon.Level47.Slots[0].LoadFromString(endRed, ":");
        toon.Level47.Slots[1].LoadFromString(endRed, ":");
        toon.Level47.Slots[2].LoadFromString(endRed, ":");
        toon.Level49.Slots[0].LoadFromString(rech, ":");
        toon.Level49.Slots[1].LoadFromString(rech, ":");
        Debug.Assert(toon.Stamina.Slots[0].Enhancement.Enh == 32, "toon.Stamina.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Stamina.Slots[1].Enhancement.Enh == 32, "toon.Stamina.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Stamina.Slots[2].Enhancement.Enh == 32, "toon.Stamina.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Health.Slots[0].Enhancement.Enh == 36, "toon.Health.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Health.Slots[1].Enhancement.Enh == 36, "toon.Health.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[0].Enhancement.Enh == 26, "toon.Level1Primary.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[1].Enhancement.Enh == 29, "toon.Level1Primary.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[2].Enhancement.Enh == 29, "toon.Level1Primary.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[3].Enhancement.Enh == 29, "toon.Level1Primary.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[4].Enhancement.Enh == 43, "toon.Level1Primary.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Secondary.Slots[0].Enhancement.Enh == 26, "toon.Level1Secondary.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[0].Enhancement.Enh == 26, "toon.Level2.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[1].Enhancement.Enh == 29, "toon.Level2.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[2].Enhancement.Enh == 29, "toon.Level2.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[3].Enhancement.Enh == 29, "toon.Level2.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[4].Enhancement.Enh == 43, "toon.Level2.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level2.Slots[5].Enhancement.Enh == 43, "toon.Level2.Slots[5].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level4.Slots[0].Enhancement.Enh == 43, "toon.Level4.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level4.Slots[1].Enhancement.Enh == 43, "toon.Level4.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level6.Slots[0].Enhancement.Enh == 26, "toon.Level6.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level6.Slots[1].Enhancement.Enh == 29, "toon.Level6.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level6.Slots[2].Enhancement.Enh == 29, "toon.Level6.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level6.Slots[3].Enhancement.Enh == 29, "toon.Level6.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level6.Slots[4].Enhancement.Enh == 43, "toon.Level6.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level6.Slots[5].Enhancement.Enh == 43, "toon.Level6.Slots[5].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level8.Slots[0].Enhancement.Enh == 26, "toon.Level8.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level10.Slots[0].Enhancement.Enh == 30, "toon.Level10.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level12.Slots[0].Enhancement.Enh == 43, "toon.Level12.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level12.Slots[1].Enhancement.Enh == 43, "toon.Level12.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level14.Slots[0].Enhancement.Enh == 26, "toon.Level14.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level14.Slots[1].Enhancement.Enh == 29, "toon.Level14.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level14.Slots[2].Enhancement.Enh == 29, "toon.Level14.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level14.Slots[3].Enhancement.Enh == 29, "toon.Level14.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level14.Slots[4].Enhancement.Enh == 43, "toon.Level14.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level16.Slots[0].Enhancement.Enh == 43, "toon.Level16.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level16.Slots[1].Enhancement.Enh == 43, "toon.Level16.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level18.Slots[0].Enhancement.Enh == 26, "toon.Level18.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level18.Slots[1].Enhancement.Enh == 29, "toon.Level18.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level18.Slots[2].Enhancement.Enh == 29, "toon.Level18.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level18.Slots[3].Enhancement.Enh == 29, "toon.Level18.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level18.Slots[4].Enhancement.Enh == 43, "toon.Level18.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level20.Slots[0].Enhancement.Enh == 33, "toon.Level20.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level20.Slots[1].Enhancement.Enh == 30, "toon.Level20.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level20.Slots[2].Enhancement.Enh == 30, "toon.Level20.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level20.Slots[3].Enhancement.Enh == 30, "toon.Level20.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level22.Slots[0].Enhancement.Enh == 33, "toon.Level22.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level22.Slots[1].Enhancement.Enh == 33, "toon.Level22.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level22.Slots[2].Enhancement.Enh == 44, "toon.Level22.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level22.Slots[3].Enhancement.Enh == 44, "toon.Level22.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level22.Slots[4].Enhancement.Enh == 44, "toon.Level22.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level22.Slots[5].Enhancement.Enh == 43, "toon.Level22.Slots[5].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level24.Slots[0].Enhancement.Enh == 33, "toon.Level24.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level24.Slots[1].Enhancement.Enh == 33, "toon.Level24.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level24.Slots[2].Enhancement.Enh == 30, "toon.Level24.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level24.Slots[3].Enhancement.Enh == 30, "toon.Level24.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level24.Slots[4].Enhancement.Enh == 30, "toon.Level24.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level26.Slots[0].Enhancement.Enh == 26, "toon.Level26.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level26.Slots[1].Enhancement.Enh == 29, "toon.Level26.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level26.Slots[2].Enhancement.Enh == 29, "toon.Level26.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level26.Slots[3].Enhancement.Enh == 29, "toon.Level26.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level26.Slots[4].Enhancement.Enh == 43, "toon.Level26.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level28.Slots[0].Enhancement.Enh == 26, "toon.Level28.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level28.Slots[1].Enhancement.Enh == 43, "toon.Level28.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level28.Slots[2].Enhancement.Enh == 43, "toon.Level28.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level30.Slots[0].Enhancement.Enh == 33, "toon.Level30.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level32.Slots[0].Enhancement.Enh == 26, "toon.Level32.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level32.Slots[1].Enhancement.Enh == 29, "toon.Level32.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level32.Slots[2].Enhancement.Enh == 29, "toon.Level32.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level32.Slots[3].Enhancement.Enh == 29, "toon.Level32.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level32.Slots[4].Enhancement.Enh == 43, "toon.Level32.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level35.Slots[0].Enhancement.Enh == 43, "toon.Level35.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level38.Slots[0].Enhancement.Enh == 26, "toon.Level38.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level38.Slots[1].Enhancement.Enh == 29, "toon.Level38.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level38.Slots[2].Enhancement.Enh == 29, "toon.Level38.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level38.Slots[3].Enhancement.Enh == 29, "toon.Level38.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level38.Slots[4].Enhancement.Enh == 43, "toon.Level38.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level41.Slots[0].Enhancement.Enh == 44, "toon.Level41.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level41.Slots[1].Enhancement.Enh == 44, "toon.Level41.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level41.Slots[2].Enhancement.Enh == 44, "toon.Level41.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level41.Slots[3].Enhancement.Enh == 33, "toon.Level41.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level41.Slots[4].Enhancement.Enh == 33, "toon.Level41.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level41.Slots[5].Enhancement.Enh == 33, "toon.Level41.Slots[5].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level44.Slots[0].Enhancement.Enh == 44, "toon.Level44.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level44.Slots[1].Enhancement.Enh == 44, "toon.Level44.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level44.Slots[2].Enhancement.Enh == 44, "toon.Level44.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level44.Slots[3].Enhancement.Enh == 43, "toon.Level44.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level44.Slots[4].Enhancement.Enh == 43, "toon.Level44.Slots[4].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level47.Slots[0].Enhancement.Enh == 33, "toon.Level47.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level47.Slots[1].Enhancement.Enh == 33, "toon.Level47.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level47.Slots[2].Enhancement.Enh == 33, "toon.Level47.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level49.Slots[0].Enhancement.Enh == 43, "toon.Level49.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level49.Slots[1].Enhancement.Enh == 43, "toon.Level49.Slots[1].Enhancement.Enh is incorrect!");

        return toon;
    }

    public static void TestGetEnhancementsGroupedBySet(AIToon toon)
    {
        Dictionary<string, List<IEnhancement>> enhancementSets = GetEnhancementsGroupedBySet(toon.Level1Primary);
        List<IEnhancement> enhancementList;
        Debug.Assert(enhancementSets.Count == 1, "enhancementSets.Count is incorrect!");
        Debug.Assert(enhancementSets.ContainsKey("None"), "enhancementSets.ContainsKey is incorrect!");
        Debug.Assert(enhancementSets.TryGetValue("None", out enhancementList), "enhancementSets.TryGetValue is incorrect!");
        if (enhancementSets.TryGetValue("None", out enhancementList))
        {
            Debug.Assert(enhancementList.Count == 5, "enhancementList.Count is incorrect!");
            Debug.Assert(enhancementList[0].Name == "Accuracy", "enhancementList[0].Name is incorrect!");
            Debug.Assert(enhancementList[1].Name == "Damage Increase", "enhancementList[1].Name is incorrect!");
            Debug.Assert(enhancementList[2].Name == "Damage Increase", "enhancementList[2].Name is incorrect!");
            Debug.Assert(enhancementList[3].Name == "Damage Increase", "enhancementList[3].Name is incorrect!");
            Debug.Assert(enhancementList[4].Name == "Recharge Reduction", "enhancementList[4].Name is incorrect!");
        }
        EnhancementSet[] defenseBonusSets = GetEnhancementSetsWithBonusEffect(toon.Level1Primary.Power, 6, Enums.eEffectType.Defense).ToArray();
        EnhancementSet set1 = defenseBonusSets[0];
        EnhancementSet set2 = defenseBonusSets[1];
        toon.Level1Primary.Slots[0].LoadFromString(GetLoadSring(GetEnhancementByIndex(set1.Enhancements[0])), ":");
        toon.Level1Primary.Slots[1].LoadFromString(GetLoadSring(GetEnhancementByIndex(set1.Enhancements[1])), ":");
        toon.Level1Primary.Slots[2].LoadFromString(GetLoadSring(GetEnhancementByIndex(set1.Enhancements[2])), ":");
        toon.Level1Primary.Slots[3].LoadFromString(GetLoadSring(GetEnhancementByIndex(set2.Enhancements[0])), ":");
        toon.Level1Primary.Slots[4].LoadFromString(GetLoadSring(GetEnhancementByIndex(set2.Enhancements[1])), ":");
        Debug.Assert(toon.Level1Primary.Slots[0].Enhancement.Enh == set1.Enhancements[0], "toon.Level1Primary.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[1].Enhancement.Enh == set1.Enhancements[1], "toon.Level1Primary.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[2].Enhancement.Enh == set1.Enhancements[2], "toon.Level1Primary.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[3].Enhancement.Enh == set2.Enhancements[0], "toon.Level1Primary.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[4].Enhancement.Enh == set2.Enhancements[1], "toon.Level1Primary.Slots[4].Enhancement.Enh is incorrect!");

        enhancementSets = GetEnhancementsGroupedBySet(toon.Level1Primary);
        Debug.Assert(enhancementSets.Count == 2, "enhancementSets.Count is incorrect!");
        Debug.Assert(enhancementSets.ContainsKey("Maelstrom's Fury"), "enhancementSets.ContainsKey is incorrect!");
        Debug.Assert(enhancementSets.ContainsKey("Ruin"), "enhancementSets.ContainsKey is incorrect!");
        Debug.Assert(enhancementSets.TryGetValue("Maelstrom's Fury", out enhancementList), "enhancementSets.TryGetValue is incorrect!");
        Debug.Assert(enhancementSets.TryGetValue("Ruin", out enhancementList), "enhancementSets.TryGetValue is incorrect!");
        if (enhancementSets.TryGetValue("Maelstrom's Fury", out enhancementList))
        {
            Debug.Assert(enhancementList.Count == 3, "enhancementList.Count is incorrect!");
            Debug.Assert(enhancementList[0].Name == "Accuracy/Damage", "enhancementList[0].Name is incorrect!");
            Debug.Assert(enhancementList[1].Name == "Damage/Endurance", "enhancementList[1].Name is incorrect!");
            Debug.Assert(enhancementList[2].Name == "Damage/Recharge", "enhancementList[2].Name is incorrect!");
        }
        if (enhancementSets.TryGetValue("Ruin", out enhancementList))
        {
            Debug.Assert(enhancementList.Count == 2, "enhancementList.Count is incorrect!");
            Debug.Assert(enhancementList[0].Name == "Accuracy/Damage", "enhancementList[0].Name is incorrect!");
            Debug.Assert(enhancementList[1].Name == "Damage/Endurance", "enhancementList[2].Name is incorrect!");
        }

        string acc = GetLoadSring(GetEnhancementByIndex(26));
        string dam = GetLoadSring(GetEnhancementByIndex(29));
        string rech = GetLoadSring(GetEnhancementByIndex(43));
        toon.Level1Primary.Slots[0].LoadFromString(acc, ":");
        toon.Level1Primary.Slots[1].LoadFromString(dam, ":");
        toon.Level1Primary.Slots[2].LoadFromString(dam, ":");
        toon.Level1Primary.Slots[3].LoadFromString(dam, ":");
        toon.Level1Primary.Slots[4].LoadFromString(rech, ":");
        Debug.Assert(toon.Level1Primary.Slots[0].Enhancement.Enh == 26, "toon.Level1Primary.Slots[0].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[1].Enhancement.Enh == 29, "toon.Level1Primary.Slots[1].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[2].Enhancement.Enh == 29, "toon.Level1Primary.Slots[2].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[3].Enhancement.Enh == 29, "toon.Level1Primary.Slots[3].Enhancement.Enh is incorrect!");
        Debug.Assert(toon.Level1Primary.Slots[4].Enhancement.Enh == 43, "toon.Level1Primary.Slots[4].Enhancement.Enh is incorrect!");
    }
}