namespace kingdom.Game.ConquerStructures
{
    public class Nobility : kingdom.Network.Writer
    {
        public static SafeDictionary<uint, NobilityInformation> Board = new SafeDictionary<uint, NobilityInformation>(10000);
        public static List<NobilityInformation> BoardList = new List<NobilityInformation>(10000);
        public static void Handle(NobilityInfo information, Client.GameClient client)
        {
            switch (information.Type)
            {
                case NobilityInfo.Donate: //El-Coder
                    {
                        if (client.Trade.InTrade) return;
                        ulong cps = information.dwParam;
                        bool newDonator = false;
                        client.NobilityInformation.Gender = (byte)(client.Entity.Body % 10);
                        if (client.NobilityInformation.Donation == 0)
                            newDonator = true;
                        if (information.MoneyType == 2)
                        {
                            //ulong cps = silvers / 3000;
                            if (client.Entity.ConquerPoints >= cps)
                            {
                                client.Entity.ConquerPoints -= (uint)cps;
                                client.NobilityInformation.Donation += cps;
                            }
                        }
                        else if (client.Entity.ConquerPoints >= cps)
                        {
                            client.Entity.ConquerPoints -= (uint)cps;
                            client.NobilityInformation.Donation += cps;
                        }
                        if (!Board.ContainsKey(client.Entity.UID) && client.NobilityInformation.Donation == cps && newDonator)
                        {
                            Board.Add(client.Entity.UID, client.NobilityInformation);
                            try
                            {
                                Database.NobilityTable.InsertNobilityInformation(client.NobilityInformation);
                            }
                            catch
                            {
                                Database.NobilityTable.UpdateNobilityInformation(client.NobilityInformation);
                            }
                        }
                        else
                        {
                            Database.NobilityTable.UpdateNobilityInformation(client.NobilityInformation);
                        }
                        Sort(client.Entity.UID);
                        break;
                    }
                case NobilityInfo.NextRank:
                    {
                        try
                        {
                            ulong[] Contributions = new ulong[]
                              {
                                0, 30000000,  0,  100000000,0, 200000000, 0, (byte)client.NobilityInformation.Rank > 7 
                                || !BoardList.Any(x => x.Rank == NobilityRank.Duke) ? 0 : BoardList.Where(x => x.Rank == NobilityRank.Duke
                                    && x.Donation >= client.NobilityInformation.Donation).Last().Donation - client.NobilityInformation.Donation, 0,(byte)client.NobilityInformation.Rank > 9
                                || !BoardList.Any(x => x.Rank == NobilityRank.Prince) ? 0 : BoardList.Where(x => x.Rank == NobilityRank.Prince
                                    && x.Donation >= client.NobilityInformation.Donation).Last().Donation - client.NobilityInformation.Donation, 0,0, (byte)client.NobilityInformation.Position == 1
                                    || !BoardList.Any(x => x.Rank == NobilityRank.King) ? 0 : BoardList.Where(x => x.Rank == NobilityRank.King
                                        && x.Donation >= client.NobilityInformation.Donation).Last().Donation - client.NobilityInformation.Donation,
                              };
                            MemoryStream strm = new MemoryStream();
                            BinaryWriter wtr = new BinaryWriter(strm);
                            wtr.Write((ushort)0);
                            wtr.Write((ushort)2064);
                            wtr.Write((uint)4);
                            byte[] Ranks = { 1, 3, 5, 7, 9, 12 };
                            foreach (var Rank in Ranks)
                            {
                                wtr.Write((ulong)Contributions[Rank]);
                                wtr.Write((uint)4294967295);
                                wtr.Write((uint)Rank);
                            }
                            int packetlength = (int)strm.Length;
                            strm.Position = 0;
                            wtr.Write((ushort)packetlength);
                            strm.Position = strm.Length;
                            wtr.Write(Server.Encoding.GetBytes("TQServer"));
                            strm.Position = 0;
                            byte[] buf = new byte[strm.Length];
                            strm.Read(buf, 0, buf.Length);
                            client.Send(buf);
                            wtr.Close();
                            strm.Close();
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine(e);
                            Server.SaveException(e);
                        }
                        break;
                    }
                case NobilityInfo.List:
                    {
                        byte[] packet = new byte[600 + 8];
                        WriteUInt16(600, 0, packet);
                        WriteUInt16(2064, 2, packet);
                        WriteUInt16(2, 4, packet);
                        WriteUInt16((ushort)(BoardList.Count > 50 ? 5 : (BoardList.Count / 10) + 1), 10, packet);
                        ushort Count = 0;
                        int offset = 120;
                        for (int i = (int)(information.wParam1 * 10); i < information.wParam1 * 10 + 10 && i < BoardList.Count; i++)
                        {
                            var nob = BoardList[i];
                            WriteUInt32(nob.EntityUID, offset, packet);
                            Count++;
                            offset += 4;
                            if (Kernel.GamePool.ContainsKey(nob.EntityUID))
                            {
                                WriteUInt32(1, offset, packet);
                                offset += 4;
                                WriteUInt32(nob.Mesh, offset, packet);
                                offset += 4;
                            }
                            else
                            {
                                offset += 8;
                            }
                            WriteString(nob.Name, offset, packet);
                            offset += 20;
                            WriteUInt64(nob.Donation, offset, packet);
                            offset += 8;
                            WriteUInt32((uint)nob.Rank, offset, packet);
                            offset += 4;
                            WriteUInt32((uint)i, offset, packet);
                            offset += 4;
                        }
                        WriteUInt16(Count, 12, packet);
                        client.Send(packet);
                        break;
                    }
            }
        }
        public static void Donate(ulong cps, Client.GameClient client) //El-Coder
        {
            bool newDonator = false;
            client.NobilityInformation.Gender = (byte)(client.Entity.Body % 10);
            if (client.NobilityInformation.Donation == 0)
                newDonator = true;

            client.NobilityInformation.Donation += cps;
            if (!Board.ContainsKey(client.Entity.UID) && client.NobilityInformation.Donation == cps && newDonator)
            {
                Board.Add(client.Entity.UID, client.NobilityInformation);
                try
                {
                    Database.NobilityTable.InsertNobilityInformation(client.NobilityInformation);
                }
                catch
                {
                    Database.NobilityTable.UpdateNobilityInformation(client.NobilityInformation);
                }
            }
            else
            {
                Database.NobilityTable.UpdateNobilityInformation(client.NobilityInformation);
            }
            Sort(client.Entity.UID);
        }
        public static void Sort(uint updateUID)
        {
            SafeDictionary<uint, NobilityInformation> sortedBoard = new SafeDictionary<uint, NobilityInformation>();
            int Place = 0;
            foreach (NobilityInformation entry in Board.Values.OrderByDescending((p) => p.Donation))
            {
                Client.GameClient client = null;
                try
                {
                    int previousPlace = entry.Position;
                    entry.Position = Place;
                    NobilityRank Rank = NobilityRank.Serf;

                    if (Place >= 50)
                    {
                        if (entry.Donation >= 200000000)
                        {
                            Rank = NobilityRank.Earl;
                        }
                        else if (entry.Donation >= 100000000)
                        {
                            Rank = NobilityRank.Baron;
                        }
                        else if (entry.Donation >= 30000000)
                        {
                            Rank = NobilityRank.Knight;
                        }
                    }
                    else
                    {
                        if (Place < 5)
                        {
                            Rank = NobilityRank.King;
                        }
                        else if (Place < 17)
                        {
                            Rank = NobilityRank.Prince;
                        }
                        else
                        {
                            Rank = NobilityRank.Duke;
                        }
                    }
                    var oldRank = entry.Rank;
                    entry.Rank = Rank;
                    if (Kernel.GamePool.TryGetValue(entry.EntityUID, out client)) //El-Coder
                    {
                        bool updateTheClient = false;
                        if (oldRank != Rank)
                        {
                            updateTheClient = true;
                            if (Rank == NobilityRank.Baron)
                            {
                                Kernel.SendWorldMessage(new Message("Congratulation! " + client.Entity.Name + " has the Baron title.", Color.White, Message.TopLeft), Server.GamePool);
                            }
                            if (Rank == NobilityRank.Earl)
                            {
                                Kernel.SendWorldMessage(new Message("Congratulation! " + client.Entity.Name + " has the Earl title.", Color.White, Message.TopLeft), Server.GamePool);
                            }
                            if (Rank == NobilityRank.Duke)
                            {
                                Kernel.SendWorldMessage(new Message("Congratulation! " + client.Entity.Name + " has the Duke title.", Color.White, Message.Center), Server.GamePool);
                            }
                            if (Rank == NobilityRank.Prince)
                            {
                                Kernel.SendWorldMessage(new Message("Congratulation! " + client.Entity.Name + " has the Prince title.", Color.White, Message.Center), Server.GamePool);
                            }
                            if (Rank == NobilityRank.King)
                            {
                                Kernel.SendWorldMessage(new Message("Congratulation! " + client.Entity.Name + " has become the new King/Queen in " + Constants.ServerName + ".", Color.White, Message.Center), Server.GamePool);
                            }
                            if (Rank == NobilityRank.Knight)
                            {
                                Kernel.SendWorldMessage(new Message("Congratulation! " + client.Entity.Name + " has become a Knight.", Color.White, Message.TopLeft), Server.GamePool);
                            }
                        }
                        else
                        {
                            if (previousPlace != Place)
                            {
                                updateTheClient = true;
                            }
                        }
                        if (updateTheClient || client.Entity.UID == updateUID)
                        {
                            NobilityInfo update = new NobilityInfo(true);
                            update.Type = NobilityInfo.Icon;
                            update.dwParam = entry.EntityUID;
                            update.UpdateString(entry);
                            client.SendScreen(update, true);
                            client.Entity.NobilityRank = entry.Rank;
                        }
                    }
                    sortedBoard.Add(entry.EntityUID, entry);
                    Place++;
                }
                catch
                {
                }
            }
            Board = sortedBoard;
            lock (BoardList)
                BoardList = Board.Values.ToList();
        }
        public static ulong GetMinimumDonation(Network.GamePackets.Nobility.NobilityIcon.NobilityRanks Rank)
        {
            switch (Rank)
            {
                case Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Knight:
                case Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Lady:
                    return 0x1c9c380L;

                case Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Baron:
                case Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Baroness:
                    return 0x5f5e100L;

                case Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Earl:
                case Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Countess:
                    return 0xbebc200L;
            }
            return MinimumDonationFor(Rank);
        }
        public static ulong MinimumDonationFor(Network.GamePackets.Nobility.NobilityIcon.NobilityRanks Rank)
        {
            ulong num = 0L;
            for (int c = 0; c < BoardList.Count; c++)
            {


                sbyte place = 0;
                Network.GamePackets.Nobility.NobilityIcon.NobilityRanks commoner = Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Commoner;
                uint identifier = BoardList[c].EntityUID;
                ulong donation = BoardList[c].Donation;
                GetNobilityStats(identifier, donation, ref place, ref commoner);
                if ((commoner == Rank) && ((donation < num) || (num == 0L)))
                {
                    num = donation;
                }

            }
            return (num + ((ulong)1L));
        }
        public static void GetNobilityStats(uint Identifier, ulong Donation, ref sbyte Place, ref Network.GamePackets.Nobility.NobilityIcon.NobilityRanks Rank)
        {
            sbyte place = 0;
            Network.GamePackets.Nobility.NobilityIcon.NobilityRanks commoner = Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Commoner;
            for (int c = 0; c < 50; c++)
            {

                if (BoardList[c].EntityUID == Identifier)
                {
                    break;
                }
                if (place < 50)
                {
                    place = (sbyte)(place + 1);
                }
            }

            Place = (place < 50) ? place : ((sbyte)(-1));
            if (Donation == 0L)
            {
                Place = -1;
            }
            commoner = GetRanking(Donation, place);
            Rank = commoner;
        }
        public static Network.GamePackets.Nobility.NobilityIcon.NobilityRanks GetRanking(ulong Donation, sbyte Place)
        {
            if ((Donation != 0L) && (Place >= 0))
            {
                if ((Place < 3) && (Donation > 0L))
                {
                    return Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.King;
                }
                if ((Place < 0x12) && (Donation > 0L))
                {
                    return Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Prince;
                }
                if ((Place < 0x35) && (Donation > 0L))
                {
                    return Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Duke;
                }
                if (Donation >= 0xbebc200L)
                {
                    return Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Earl;
                }
                if (Donation >= 0x5f5e100L)
                {
                    return Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Baron;
                }
                if (Donation >= 0x1c9c380L)
                {
                    return Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Knight;
                }
            }
            return Network.GamePackets.Nobility.NobilityIcon.NobilityRanks.Commoner;
        }
    }
    public class NobilityInformation
    {
        public string Name;
        public uint EntityUID;
        public uint Mesh;
        public ulong Donation;
        public byte Gender;
        public int Position;
        public NobilityRank Rank;
        public bool Prince;
        public bool Duck;
        public bool king;
        public DateTime KingDays;
    }
    public enum NobilityRank : byte
    {
        Serf = 0,
        Knight = 1,
        Baron = 3,
        Earl = 5,
        Duke = 7,
        Prince = 9,
        King = 12
    }
}