using System;
using System.IO;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Collections;
using System.Runtime.CompilerServices;
using static System.Windows.Forms.VisualStyles.VisualStyleElement.Button;
using DQMJ2P_Randomizer.Properties;

namespace viewer_test
{
    public partial class Form1 : Form
    {

        public class Randomizer
        {
            public static Random random = new Random();
            private static List<int> RandomClasses = new List<int>();

            public static RandomPrmData GenerateRandom(HashSet<int> usedClasses, RandomizerSettings Setting)
            {
                RandomPrmData RandomPrm = new RandomPrmData();

                List<List<int>> TypeValues = new List<List<int>>()
                {
                    new List<int> { 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18 },
                    new List<int> { 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28 },
                    new List<int> { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38 },
                    new List<int> { 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48 },
                    new List<int> { 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58 },
                    new List<int> { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68 },
                    new List<int> { 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78 },
                    new List<int> { 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88 },
                };

                if (checkbox1 && TypeValues.Count >= 8)
                {
                    TypeValues.RemoveAt(7);
                }
                if (checkbox2)
                {
                    for (int i = 0; i < TypeValues.Count; i++)
                    {
                        TypeValues[i].RemoveAt(TypeValues[i].Count - 1);
                    }
                }

                int TypeIndex = random.Next(TypeValues.Count);
                List<int> TypeRnage = TypeValues[TypeIndex];

                List<List<int>> TaiseiValues = new List<List<int>>()
                {
                    new List<int> { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7 },
                    new List<int> { 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17 },
                    new List<int> { 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27 },
                    new List<int> { 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37 },
                    new List<int> { 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47 },
                    new List<int> { 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57 },
                    new List<int> { 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67 },
                    new List<int> { 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77 },
                };


                int TaiseiIndex1 = random.Next(TaiseiValues.Count);
                int TaiseiIndex2 = random.Next(TaiseiValues.Count);
                int TaiseiIndex3 = random.Next(TaiseiValues.Count);
                int TaiseiIndex4 = random.Next(TaiseiValues.Count);
                int TaiseiIndex5 = random.Next(TaiseiValues.Count);
                int TaiseiIndex6 = random.Next(TaiseiValues.Count);
                int TaiseiIndex7 = random.Next(TaiseiValues.Count);
                int TaiseiIndex8 = random.Next(TaiseiValues.Count);
                int TaiseiIndex9 = random.Next(TaiseiValues.Count);
                int TaiseiIndex10 = random.Next(TaiseiValues.Count);
                int TaiseiIndex11 = random.Next(TaiseiValues.Count);
                int TaiseiIndex12 = random.Next(TaiseiValues.Count);
                int TaiseiIndex13 = random.Next(TaiseiValues.Count);
                int TaiseiIndex14 = random.Next(TaiseiValues.Count);


                List<int> TaiseiRnage1 = TaiseiValues[TaiseiIndex1];
                List<int> TaiseiRnage2 = TaiseiValues[TaiseiIndex2];
                List<int> TaiseiRnage3 = TaiseiValues[TaiseiIndex3];
                List<int> TaiseiRnage4 = TaiseiValues[TaiseiIndex4];
                List<int> TaiseiRnage5 = TaiseiValues[TaiseiIndex5];
                List<int> TaiseiRnage6 = TaiseiValues[TaiseiIndex6];
                List<int> TaiseiRnage7 = TaiseiValues[TaiseiIndex7];
                List<int> TaiseiRnage8 = TaiseiValues[TaiseiIndex8];
                List<int> TaiseiRnage9 = TaiseiValues[TaiseiIndex9];
                List<int> TaiseiRnage10 = TaiseiValues[TaiseiIndex10];
                List<int> TaiseiRnage11 = TaiseiValues[TaiseiIndex11];
                List<int> TaiseiRnage12 = TaiseiValues[TaiseiIndex12];
                List<int> TaiseiRnage13 = TaiseiValues[TaiseiIndex13];
                List<int> TaiseiRnage14 = TaiseiValues[TaiseiIndex14];

                RandomPrm.Type1 = (byte)TypeRnage[random.Next(TypeRnage.Count)];

                if (checkbox3)
                {
                    int min = Setting.MinPrm;
                    int max = Setting.MaxPrm;

                    if (min > max)
                    {
                        int temp = min;
                        min = max;
                        max = temp;
                    }

                    RandomPrm.MAXHP = random.Next(min, max);
                    RandomPrm.MAXMP = random.Next(min, max);
                    RandomPrm.Attack = random.Next(min, max);
                    RandomPrm.Defense = random.Next(min, max);
                    RandomPrm.Speed = random.Next(min, max);
                    RandomPrm.Inteligence = random.Next(min, max);
                }
                else
                {
                    RandomPrm.MAXHP = random.Next(500, 1000);
                    RandomPrm.MAXMP = random.Next(500, 1000);
                    RandomPrm.Attack = random.Next(500, 1000);
                    RandomPrm.Defense = random.Next(500, 1000);
                    RandomPrm.Speed = random.Next(500, 1000);
                    RandomPrm.Inteligence = random.Next(500, 1000);
                }

                RandomPrm.Equip = (byte)random.Next(112, 255);
                RandomPrm.Skill = (byte)random.Next(1, 255);

                if (checkbox4)
                {
                    RandomPrm.GrowSpeed = 1;
                }
                else
                {
                    RandomPrm.GrowSpeed = (byte)random.Next(1, 10);
                }


                RandomPrm.Taisei1 = (byte)TaiseiRnage1[random.Next(TaiseiRnage1.Count)];
                RandomPrm.Taisei2 = (byte)TaiseiRnage2[random.Next(TaiseiRnage2.Count)];
                RandomPrm.Taisei3 = (byte)TaiseiRnage3[random.Next(TaiseiRnage3.Count)];
                RandomPrm.Taisei4 = (byte)TaiseiRnage4[random.Next(TaiseiRnage4.Count)];
                RandomPrm.Taisei5 = (byte)TaiseiRnage5[random.Next(TaiseiRnage5.Count)];
                RandomPrm.Taisei6 = (byte)TaiseiRnage6[random.Next(TaiseiRnage6.Count)];
                RandomPrm.Taisei7 = (byte)TaiseiRnage7[random.Next(TaiseiRnage7.Count)];
                RandomPrm.Taisei8 = (byte)TaiseiRnage8[random.Next(TaiseiRnage8.Count)];
                RandomPrm.Taisei9 = (byte)TaiseiRnage9[random.Next(TaiseiRnage9.Count)];
                RandomPrm.Taisei10 = (byte)TaiseiRnage10[random.Next(TaiseiRnage10.Count)];
                RandomPrm.Taisei11 = (byte)TaiseiRnage11[random.Next(TaiseiRnage11.Count)];
                RandomPrm.Taisei12 = (byte)TaiseiRnage12[random.Next(TaiseiRnage12.Count)];
                RandomPrm.Taisei13 = (byte)TaiseiRnage13[random.Next(TaiseiRnage13.Count)];
                RandomPrm.Taisei14 = (byte)TaiseiRnage14[random.Next(TaiseiRnage14.Count)];


                RandomClasses.Clear();
                for (int i = 1; i <= 447; i++)
                {
                    RandomClasses.Add(i);
                }

                int ClassIndex = random.Next(RandomClasses.Count);

                RandomPrm.Class =ClassIndex;

                RandomClasses.RemoveAt(ClassIndex);

                //Console.WriteLine("ClassIndex: " + Class);
                Console.WriteLine("RandomPrm.Class: " + RandomPrm.Class);

                List<byte> TraitPool = new List<byte>();
                for (byte i = 1; i <= 250; i++)
                    TraitPool.Add(i);

                RandomPrm.Trait1 = ExtractRandomTrait(TraitPool);
                RandomPrm.Trait2 = ExtractRandomTrait(TraitPool);
                RandomPrm.Trait3 = ExtractRandomTrait(TraitPool);
                RandomPrm.Trait4 = ExtractRandomTrait(TraitPool);

                return RandomPrm;
            }

            private static byte ExtractRandomTrait(List<byte> TraitPool)
            {
                if (TraitPool.Count == 0) return 0;
                int index = random.Next(TraitPool.Count);
                byte value = TraitPool[index];
                TraitPool.RemoveAt(index);
                return value;
            }

            public static byte[] ToByteArray(RandomPrmData RandomPrm)
            {
                List<byte> byteArray = new List<byte>();

                byte[] Unknown1 = new byte[4];
                byte[] Unknown2 = new byte[4];
                byte[] Unknown3 = new byte[3];
                byte[] Unknown4 = new byte[20];
                byte[] Unknown5 = new byte[4];
                byte[] GrowPrm = { 0x01, 0x01, 0x01, 0x19, 0x13, 0x1A, 0x1A, 0x13, 0x19, 0x14,
                    0x14, 0x17, 0x10, 0x1A, 0x18, 0x18, 0x12, 0x1A, 0x1A, 0x19,
                    0x12, 0x15, 0x16, 0x15, 0x12, 0x15, 0x1A };

                List<int> ClassList = Enumerable.Range(1, 447).ToList();

                int ClassIndex = random.Next(ClassList.Count);
                int Class = ClassList[ClassIndex];
                ClassList.RemoveAt(ClassIndex);


                //byte[] Class = BitConverter.GetBytes((short)RandomPrm.Class);

                random.NextBytes(Unknown1);
                random.NextBytes(Unknown2);
                random.NextBytes(Unknown3);
                random.NextBytes(Unknown4);
                random.NextBytes(Unknown5);

                //byteArray.AddRange(Unknown1);
                byteArray.Add((byte)RandomPrm.Type1);
                //byteArray.Add((byte)RandomPrm.Type2);
                byteArray.AddRange(BitConverter.GetBytes((short)Class));
                //byteArray.AddRange(Unknown2);
                //byteArray.Add((byte)RandomPrm.Camera);
                //byteArray.AddRange(Unknown3);
                byteArray.AddRange(BitConverter.GetBytes((short)RandomPrm.MAXHP));
                byteArray.AddRange(BitConverter.GetBytes((short)RandomPrm.MAXMP));
                byteArray.AddRange(BitConverter.GetBytes((short)RandomPrm.Attack));
                byteArray.AddRange(BitConverter.GetBytes((short)RandomPrm.Defense));
                byteArray.AddRange(BitConverter.GetBytes((short)RandomPrm.Speed));
                byteArray.AddRange(BitConverter.GetBytes((short)RandomPrm.Inteligence));
                //byteArray.AddRange(Unknown4);
                byteArray.Add(RandomPrm.Taisei1);
                byteArray.Add(RandomPrm.Taisei2);
                byteArray.Add(RandomPrm.Taisei3);
                byteArray.Add(RandomPrm.Taisei4);
                byteArray.Add(RandomPrm.Taisei5);
                byteArray.Add(RandomPrm.Taisei6);
                byteArray.Add(RandomPrm.Taisei7);
                byteArray.Add(RandomPrm.Taisei8);
                byteArray.Add(RandomPrm.Taisei9);
                byteArray.Add(RandomPrm.Taisei10);
                byteArray.Add(RandomPrm.Taisei11);
                byteArray.Add(RandomPrm.Taisei12);
                byteArray.Add(RandomPrm.Taisei13);
                byteArray.Add(RandomPrm.Taisei14);
                byteArray.Add(RandomPrm.Equip);
                byteArray.Add(RandomPrm.Trait1);
                byteArray.Add(RandomPrm.Trait2);
                byteArray.Add(RandomPrm.Trait3);
                byteArray.Add(RandomPrm.Trait4);
                byteArray.Add(RandomPrm.GrowSpeed);
                byteArray.AddRange(GrowPrm);
                byteArray.Add(RandomPrm.Skill);
                //byteArray.AddRange(Unknown5);

                return byteArray.ToArray();
            }
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Random random = new Random();


            int RandomOffset = 0x6994C6C;

            int CombinationOffset = 0x6994400; //412
            int Combination2POffset = 0x6993C00; //1422
            int CombinationTypeOffset = 0x6994200; //348

            if (string.IsNullOrEmpty(currentFilePath))
            {
                return;
            }

            using (SaveFileDialog sfd = new SaveFileDialog())
            {
                sfd.Filter = "nds Files (*.nds)|*.nds|All Files (*.*)|*.*";
                sfd.FileName = Path.GetFileNameWithoutExtension(currentFilePath) + "_Randomized.nds";

                if (sfd.ShowDialog() == DialogResult.OK)
                {
                    string newFilePath = sfd.FileName;

                    // 元のファイルをコピー
                    File.Copy(currentFilePath, newFilePath, true);

                    // 使用されたClassを管理するための集合
                    HashSet<int> usedClasses = new HashSet<int>();

                    using (FileStream fs = new FileStream(newFilePath, FileMode.Open, FileAccess.Write))
                    {
                        for (int i = 1; i <= 447; i++)    //447
                        {
                            // ランダムなPrmDataを生成
                            RandomPrmData RandomPrm = Randomizer.GenerateRandom(usedClasses, this.Setting);

                            // バイトデータに変換
                            byte[] data = Randomizer.ToByteArray(RandomPrm);

                            // 5 バイト目を書き込む
                            fs.Seek(RandomOffset, SeekOrigin.Begin);
                            fs.Seek(4, SeekOrigin.Current); // 1〜4 をスキップ
                            fs.Write(data, 0, 1);


                            // 7〜8 バイト目を書き込む
                            fs.Seek(1, SeekOrigin.Current); // 6 をスキップ
                            fs.Write(data, 1, 2);

                            // 17〜28 バイト目を書き込む
                            fs.Seek(8, SeekOrigin.Current); // 9〜16 をスキップ
                            fs.Write(data, 3, 12);

                            // 49〜96 バイト目を書き込む
                            fs.Seek(20, SeekOrigin.Current); // 29〜48 をスキップ
                            fs.Write(data, 15, 48);

                            //80byte
                            RandomOffset += 100;
                        }

                        for (int i = 1; i <= 103; i++)   //Combination
                        {
                            fs.Seek(CombinationOffset, SeekOrigin.Begin);
                            fs.WriteByte(0x1E);
                            fs.WriteByte(0x00);
                            fs.WriteByte(0x27);
                            fs.WriteByte(0x00);
                            CombinationOffset += 1;
                        }

                        for (int i = 1; i <= 237; i++)   //Combination2P
                        {
                            byte[] RandomCombination = new byte[6];
                            int DescendantIndex = 0x150;
                            int Ancestor1Index = random.Next(1, 447);
                            int Ancestor2Index = random.Next(1, 447);

                            byte[] Descendants = BitConverter.GetBytes((ushort)DescendantIndex);
                            byte[] Ancestor1 = BitConverter.GetBytes((ushort)Ancestor1Index);
                            byte[] Ancestor2 = BitConverter.GetBytes((ushort)Ancestor2Index);

                            Array.Copy(Descendants, 0, RandomCombination, 0, 2);
                            Array.Copy(Ancestor1, 0, RandomCombination, 2, 2);
                            Array.Copy(Ancestor2, 0, RandomCombination, 4, 2);

                            fs.Seek(Combination2POffset, SeekOrigin.Begin);
                            fs.Write(RandomCombination, 0, 6);
                            Combination2POffset += 6;

                        }

                        for (int i = 1; i <= 57; i++)   //CombinationType
                        {
                            byte[] RandomCombination = new byte[6];
                            int DescendantIndex = random.Next(1, 447);
                            int Ancestor1Index = random.Next(1, 447);
                            int Ancestor2Index = random.Next(1, 8);

                            byte[] Descendants = BitConverter.GetBytes((ushort)DescendantIndex);
                            byte[] Ancestor1 = BitConverter.GetBytes((ushort)Ancestor1Index);
                            byte[] Ancestor2 = BitConverter.GetBytes((ushort)Ancestor2Index);

                            Array.Copy(Descendants, 0, RandomCombination, 0, 2);
                            Array.Copy(Ancestor1, 0, RandomCombination, 2, 2);
                            Array.Copy(Ancestor2, 0, RandomCombination, 4, 2);

                            fs.Seek(CombinationTypeOffset, SeekOrigin.Begin);
                            fs.Write(RandomCombination, 0, 6);
                            CombinationTypeOffset += 6;
                        }

                    }
                }
            }

        }
    }
}