using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;

namespace PKIDcreator
{

    public partial class Form1 : Form
    {
        public class D2Mod
        {
            public int id;
            public string mStr;
            public string gStr;
            public string mmStr;
        }

        public class D2ModCollection
        {
            Array mods;
            private int curIndex;
            D2ModCollection()
            {
                mods = Array.CreateInstance(typeof(D2Mod), 0);
                curIndex = 0;
            }
            public int Find(D2Mod mod)
            {
                for (int i = 0; i < mods.Length; i++)
                {
                    if (mods.GetValue(i) == mod)
                        return i;
                }
                return -1;
            }
            public void InsertMod(string modStr, string gameStr, string mmbStr)
            {
                D2Mod temp = new D2Mod();
                temp.gStr = gameStr;
                temp.mStr = modStr;
                temp.mmStr = mmbStr;

                if (this.Find(temp) != -1)
                    return;

                mods.SetValue(temp, curIndex++);

            }
            public void InsertMod(D2Mod mod)
            {
                if (this.Find(mod) != -1)
                    return;
                mods.SetValue(mod, curIndex++);
            }
            public D2Mod GetMod(int index)
            {
                //return mods.GetValue(index);
                if (index < mods.Length || index >= 0)
                    return (mods.GetValue(index) as D2Mod);

                return null;
            }
        }

        public class D2PreSuff
        {
            public Array mod;
            public Array min;
            public Array max;
            public Array param;

            D2PreSuff()
            {
                mod = Array.CreateInstance(typeof(int), 3);
                min = Array.CreateInstance(typeof(int), 3);
                max = Array.CreateInstance(typeof(int), 3);
                param = Array.CreateInstance(typeof(int), 3);
            }
        }

        public class D2PreCollection
        {
            Array prefix;
            private int curIndex;
            D2PreCollection()
            {
                prefix = Array.CreateInstance(typeof(D2PreSuff), 0);
                curIndex = 0;
            }
            void InsertPrefix(int[] mod, int[] min, int[] max, int[] param)
            {
                D2PreSuff temp = new D2PreSuff();

                for (int i = 0; i < mod.Length; i++)
                {
                    temp.mod.SetValue(mod[i], i);
                    temp.min.SetValue(min[i], i);
                    temp.max.SetValue(max[i], i);
                    temp.param.SetValue(param[i], i);
                }

                if (Find(temp) != -1)
                {
                    return;
                }
                else
                {
                    prefix.SetValue(temp, curIndex++);
                }
            }
            int Find(D2PreSuff findPre)
            {
                for (int i = 0; i < prefix.Length; i++)
                {
                    if (prefix.GetValue(i) == findPre)
                        return i;
                }
                return -1;
            }
            D2PreSuff GetPrefix(int index)
            {
                if (index < prefix.Length && index >= 0)
                    return (prefix.GetValue(index) as D2PreSuff);
                return null;
            }
        }

        //As stupid as I am I created 2 class that is exactly the same but with different variable names, don't ask why...
        public class D2SufCollection
        {
            Array suffix;
            private int curIndex;
            D2SufCollection()
            {
                suffix = Array.CreateInstance(typeof(D2PreSuff), 0);
                curIndex = 0;
            }
            void InsertSuffix(int[] mod, int[] min, int[] max, int[] param)
            {
                D2PreSuff temp = new D2PreSuff();

                for (int i = 0; i < mod.Length; i++)
                {
                    temp.mod.SetValue(mod[i], i);
                    temp.min.SetValue(min[i], i);
                    temp.max.SetValue(max[i], i);
                    temp.param.SetValue(param[i], i);
                }
                if (Find(temp) != -1)
                {
                    return;
                }
                else
                {
                    suffix.SetValue(temp, curIndex++);
                }
            }
            int Find(D2PreSuff findSuf)
            {
                for (int i = 0; i < suffix.Length; i++)
                {
                    if (suffix.GetValue(i) == findSuf)
                        return i;
                }
                return -1;
            }
            D2PreSuff GetSuffix(int index)
            {
                if (index < suffix.Length && index >= 0)
                    return (suffix.GetValue(index) as D2PreSuff);
                return null;
            }
        }

        public class D2BaseItem
        {
            public int id;
            public string name;
            public int levelreq;
            public int strreq;
            public string type;
            public int maxsockets;
            //public D2BaseItemType itemtype;
        }
        public class D2BaseArmor : D2BaseItem
        {
            public int maxac;
            public int minac;
        }
        public class D2BaseArmorCollection
        {
            Array bases;
            private int curIndex;
            D2BaseArmorCollection()
            {
                bases = Array.CreateInstance(typeof(D2BaseArmor), 0);
                curIndex = 0;
            }
            void InsertBase(D2BaseArmor armor)
            {

                if (Find(armor) != -1)
                {
                    return;
                }
                else
                {
                    bases.SetValue(armor, curIndex++);
                }
            }
            int Find(D2BaseArmor findArmor)
            {
                for (int i = 0; i < bases.Length; i++)
                {
                    if (bases.GetValue(i) == findArmor)
                        return i;
                }
                return -1;
            }
            D2BaseArmor GetArmor(string armorText)
            {
                for (int i = 0; i < bases.Length; i++)
                {
                    if ((bases.GetValue(i) as D2BaseArmor).name == armorText)
                    {
                        return (bases.GetValue(i) as D2BaseArmor);
                    }
                }
                return null;
            }
            D2BaseArmor GetArmor(int index)
            {
                if (index < bases.Length && index >= 0)
                    return (bases.GetValue(index) as D2BaseArmor);
                return null;
            }
        }

        public class D2BaseWeapon : D2BaseItem
        {
            public int mindam;
            public int maxdam;
            public bool onehand;
            public int dexreq;
        }
        public class D2BaseWeaponCollection
        {
            Array bases;
            private int curIndex;
            D2BaseWeaponCollection()
            {
                bases = Array.CreateInstance(typeof(D2BaseWeapon), 0);
                curIndex = 0;
            }
            void InsertBase(D2BaseWeapon weapon)
            {

                if (Find(weapon) != -1)
                {
                    return;
                }
                else
                {
                    bases.SetValue(weapon, curIndex++);
                }
            }
            int Find(D2BaseWeapon findWeapon)
            {
                for (int i = 0; i < bases.Length; i++)
                {
                    if (bases.GetValue(i) == findWeapon)
                        return i;
                }
                return -1;
            }
            D2BaseWeapon GetWeapon(string wpnText)
            {
                for (int i = 0; i < bases.Length; i++)
                {
                    if ((bases.GetValue(i) as D2BaseWeapon).name == wpnText)
                    {
                        return (bases.GetValue(i) as D2BaseWeapon);
                    }
                }
                return null;
            }
            D2BaseWeapon GetWeapon(int index)
            {
                if (index < bases.Length && index >= 0)
                    return (bases.GetValue(index) as D2BaseWeapon);
                return null;
            }
        }

        public class D2UniqueArmor : D2BaseArmor
        {
            Array mods;
            D2UniqueArmor()
            {
                mods = Array.CreateInstance(typeof(D2Mod), 7);
            }
        }
        public class D2UniqueArmorCollection
        {
            Array uniques;
            private int curIndex;
            D2UniqueArmorCollection()
            {
                uniques = Array.CreateInstance(typeof(D2UniqueArmor), 0);
                curIndex = 0;
            }
            void InsertUnique(D2UniqueArmor armor)
            {

                if (Find(armor) != -1)
                {
                    return;
                }
                else
                {
                    uniques.SetValue(armor, curIndex++);
                }
            }
            int Find(D2UniqueArmor findArmor)
            {
                for (int i = 0; i < uniques.Length; i++)
                {
                    if (uniques.GetValue(i) == findArmor)
                        return i;
                }
                return -1;
            }
            D2UniqueArmor GetArmor(int index)
            {
                if (index < uniques.Length && index >= 0)
                    return (uniques.GetValue(index) as D2UniqueArmor);
                return null;
            }

        }

        public class D2UniqueWeapon : D2BaseWeapon
        {

        }
        public class D2UniqueWeaponCollection
        {
            Array uniques;
            private int curIndex;
            D2UniqueWeaponCollection()
            {
                uniques = Array.CreateInstance(typeof(D2UniqueWeapon), 0);
                curIndex = 0;
            }
            void InsertUnique(D2UniqueWeapon weapon)
            {

                if (Find(weapon) != -1)
                {
                    return;
                }
                else
                {
                    uniques.SetValue(weapon, curIndex++);
                }
            }
            int Find(D2UniqueWeapon findWeapon)
            {
                for (int i = 0; i < uniques.Length; i++)
                {
                    if (uniques.GetValue(i) == findWeapon)
                        return i;
                }
                return -1;
            }
            D2UniqueWeapon GetWeapon(int index)
            {
                if (index < uniques.Length && index >= 0)
                    return (uniques.GetValue(index) as D2UniqueWeapon);
                return null;
            }

        }

        Array D2PreMods;
        Array D2SufMods;
        Array D2BaseArmors;
        Array D2BaseWeapons;
        D2ModCollection g_Mods = new D2ModCollection();
        D2UniqueArmorCollection g_UArmor = new D2UniqueArmorCollection();
        D2UniqueWeaponCollection g_UWeapon = new D2UniqueWeaponCollection();

        public Form1()
        {
            InitializeComponent();
        }
        string getData(DataTable tbl, int rowid, string colName)
        {
            if (tbl.Rows[rowid][colName] == DBNull.Value)
            {
                return "";
            }
            return Convert.ToString(tbl.Rows[rowid][colName]);
        }
        void pProg(string text, int all, int part)
        {
            double percent;
            percent = Convert.ToDouble(part) / Convert.ToDouble(all);
            percent = Math.Round(percent * 100.0, 0);
            lblProgress.Text = "Loading " + text + ": " + Convert.ToString(percent) + "%";

        }
        public bool loadData()
        {
            D2BaseArmor d2TempArmor = new D2BaseArmor();
            D2BaseWeapon d2TempWeapon = new D2BaseWeapon(); ;
            D2Mod d2TempMod = new D2Mod();
            DataTable Tbl = items.MagicPrefix;

            D2PreMods = Array.CreateInstance(typeof(D2Mod), items.MagicPrefix.Rows.Count);
            D2SufMods = Array.CreateInstance(typeof(D2Mod), items.MagicSuffix.Rows.Count);
            D2BaseArmors = Array.CreateInstance(typeof(D2BaseArmor), items.Armor.Rows.Count);
            D2BaseWeapons = Array.CreateInstance(typeof(D2BaseWeapon), items.Weapons.Rows.Count);

            this.Activate();
            this.Show();
            double percent = 0;

            for (int i = 0; i < items.Mods.Rows.Count; i++)
            {
                d2TempMod.id = Convert.ToInt32(getData(items.Mods, i, "id"));
                d2TempMod.mStr = getData(items.Mods, i, "mCode");
                d2TempMod.gStr = getData(items.Mods, i, "gStr");
                d2TempMod.mmStr = getData(items.Mods, i, "mmStr");
                if (d2TempMod.gStr != "")
                {
                    g_Mods.InsertMod(d2TempMod);
                }
                pProg("Mods", items.Mods.Rows.Count, i);
                if (i % 10 == 0)
                {
                    Application.DoEvents();
                    this.Refresh();
                }
            }
            for (int i = 0; i < items.MagicPrefix.Rows.Count; i++)
            {
                d2TempMod.id = Convert.ToInt32(getData(Tbl, i, "id"));
                //d2TempMod.mod = Convert.ToString(
                /*D2BaseArmors.SetValue(d2TempArmor, i);

                percent = Convert.ToDouble(i) / Convert.ToDouble(items.Armor.Rows.Count);
                percent = Math.Round(percent * 100.0, 0);
                lblProgress.Text = "Loading armors: " + Convert.ToString(percent) + "%";
                */
                Application.DoEvents();
                this.Refresh();
            }

            for (int i = 0; i < items.Armor.Rows.Count; i++)
            {
                d2TempArmor.id = (int)items.Armor.Rows[i]["ID"];
                d2TempArmor.levelreq = Convert.ToInt32(items.Armor.Rows[i]["levelreq"]);
                d2TempArmor.minac = Convert.ToInt32(items.Armor.Rows[i]["minac"]);
                d2TempArmor.maxac = Convert.ToInt32(items.Armor.Rows[i]["maxac"]);
                d2TempArmor.strreq = Convert.ToInt32(items.Armor.Rows[i]["reqstr"]);
                d2TempArmor.maxsockets = Convert.ToInt32(items.Armor.Rows[i]["gemsockets"]);
                d2TempArmor.name = Convert.ToString(items.Armor.Rows[i]["name"]);

                D2BaseArmors.SetValue(d2TempArmor, i);

                pProg("Armors", items.Armor.Rows.Count, i);

                if (i % 10 == 0)
                {
                    Application.DoEvents();
                    this.Refresh();
                }
            }

            for (int i = 0; i < items.Weapons.Rows.Count; i++)
            {
                d2TempWeapon.id = (int)items.Weapons.Rows[i]["ID"];
                d2TempWeapon.levelreq = Convert.ToInt32(items.Weapons.Rows[i]["levelreq"]);
                d2TempWeapon.onehand = Convert.ToBoolean(Convert.ToInt32(items.Weapons.Rows[i]["maxdam"]));
                if (d2TempWeapon.onehand)
                {
                    d2TempWeapon.mindam = Convert.ToInt32(items.Weapons.Rows[i]["mindam"]);
                    d2TempWeapon.maxdam = Convert.ToInt32(items.Weapons.Rows[i]["maxdam"]);
                }
                else
                {
                    d2TempWeapon.mindam = Convert.ToInt32(items.Weapons.Rows[i]["2handmindam"]);
                    d2TempWeapon.maxdam = Convert.ToInt32(items.Weapons.Rows[i]["2handmaxdam"]);
                }
                d2TempWeapon.maxsockets = Convert.ToInt32(items.Weapons.Rows[i]["gemsockets"]);
                d2TempWeapon.strreq = Convert.ToInt32(items.Weapons.Rows[i]["reqstr"]);
                d2TempWeapon.dexreq = Convert.ToInt32(items.Weapons.Rows[i]["reqdex"]);
                d2TempArmor.name = Convert.ToString(items.Weapons.Rows[i]["name"]);

                D2BaseWeapons.SetValue(d2TempWeapon, i);

                pProg("Weapons", items.Weapons.Rows.Count, i);
                if (i % 10 == 0)
                {
                    this.Refresh();
                    Application.DoEvents();
                }
            }
            lblProgress.Text = "";
            return true;
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            // TODO: This line of code loads data into the 'items.Weapons' table. You can move, or remove it, as needed.
            this.weaponsTableAdapter.Fill(this.items.Weapons);
            // TODO: This line of code loads data into the 'items.UniqueItems' table. You can move, or remove it, as needed.
            this.uniqueItemsTableAdapter.Fill(this.items.UniqueItems);
            // TODO: This line of code loads data into the 'items.SetItems' table. You can move, or remove it, as needed.
            this.setItemsTableAdapter.Fill(this.items.SetItems);
            // TODO: This line of code loads data into the 'items.MagicSuffix' table. You can move, or remove it, as needed.
            this.magicSuffixTableAdapter.Fill(this.items.MagicSuffix);
            // TODO: This line of code loads data into the 'items.MagicPrefix' table. You can move, or remove it, as needed.
            this.magicPrefixTableAdapter.Fill(this.items.MagicPrefix);
            // TODO: This line of code loads data into the 'items.Gems' table. You can move, or remove it, as needed.
            this.gemsTableAdapter.Fill(this.items.Gems);
            // TODO: This line of code loads data into the 'items.Armor' table. You can move, or remove it, as needed.
            this.armorTableAdapter.Fill(this.items.Armor);

            lblMain.Text = "Loading Diablo 2 item data...";
            loadData();
            lblMain.Text = "Welcome to the mm.PKID.ini manager.";
        }

        private void Uniques_Click(object sender, EventArgs e)
        {

        }

        private void btnUpdate_Click(object sender, EventArgs e)
        {
            cboItems.Items.Clear();
        }


    }
}