using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using DuckEmulator.HabboHotel.Outside.Clients;
using DuckEmulator.HabboHotel.Outside.Messages.Types;
using DuckEmulator.HabboHotel.Outside.Furniture;
using DuckEmulator.Security;

namespace DuckEmulator.HabboHotel.Outside.Rooms.Trade
{
    enum UserType
    {
        Sender = 0,
        Receiver = 1
    }

    class Trade
    {
        internal readonly uint Id;

        internal TradeUser Sender;
        internal TradeUser Receiver;

        internal Boolean HasVerifed = false;

        internal SecurityList<Furni> GetFurni(uint HabboId)
        {
            if (Sender.HabboId == HabboId)
            {
                return Sender.TradedItems;
            }
            else if (Receiver.HabboId == HabboId)
            {
                return Receiver.TradedItems;
            }

            return null;
        }

        internal int GetAlternativeCount(uint HabboId)
        {
            var Items = GetFurni(HabboId);
            var AlternativeList = new SecurityList<uint>(); // BaseId

            foreach (Furni Furni in Items)
            {
                if (!AlternativeList.Contains(Furni.GetBaseItem().Id))
                {
                    AlternativeList.Add(Furni.GetBaseItem().Id);
                }
            }

            return AlternativeList.Count;
        }

        internal Trade(uint Id, uint Sender, uint Receiver)
        {
            this.Id = Id;
            this.Sender = new TradeUser(Sender, Id, UserType.Sender);
            this.Receiver = new TradeUser(Receiver, Id, UserType.Receiver);
        }

        internal ServerMessage SerializeStart()
        {
            ServerMessage Message = new ServerMessage(104);
            Message.AppendUInt(Sender.HabboId);
            Message.AppendBoolean(true);
            Message.AppendUInt(Receiver.HabboId);
            Message.AppendBoolean(true);
            return Message;
        }

        internal ServerMessage SerializeStop(uint StopId)
        {
            ServerMessage Message = new ServerMessage(110);
            Message.AppendUInt(StopId);
            return Message;
        }

        internal ServerMessage SerializeItems()
        {
            ServerMessage Message = new ServerMessage(108);

            Message.AppendUInt(Sender.HabboId);
            Message.AppendInt32(Sender.TradedItems.Count);

            foreach (Furni Furni in Sender.TradedItems)
            {
                Message.AppendUInt(Furni.Id);
                Message.AppendStringWithBreak(Furni.GetBaseItem().Type.ToLower());
                Message.AppendUInt(Furni.Id);
                Message.AppendUInt(Furni.GetBaseItem().SpriteId);
                Message.AppendBoolean(true);
                Message.AppendBoolean(true);
                Message.AppendStringWithBreak("");
                Message.AppendBoolean(false);
                Message.AppendBoolean(false);
                Message.AppendBoolean(false);

                if (Furni.GetBaseItem().Type.ToLower() == "s")
                {
                    Message.AppendInt32(-1);
                }
            }

            Message.AppendUInt(Receiver.HabboId);
            Message.AppendInt32(Receiver.TradedItems.Count);

            foreach (Furni Furni in Receiver.TradedItems)
            {
                Message.AppendUInt(Furni.Id);
                Message.AppendStringWithBreak(Furni.GetBaseItem().Type.ToLower());
                Message.AppendUInt(Furni.Id);
                Message.AppendUInt(Furni.GetBaseItem().SpriteId);
                Message.AppendBoolean(true);
                Message.AppendBoolean(true);
                Message.AppendStringWithBreak("");
                Message.AppendBoolean(false);
                Message.AppendBoolean(false);
                Message.AppendBoolean(false);

                if (Furni.GetBaseItem().Type.ToLower() == "s")
                {
                    Message.AppendInt32(-1);
                }
            }

            return Message;
        }

        internal void StartTrade()
        {
            Sender.SendResponse(SerializeStart());
            Receiver.SendResponse(SerializeStart());

            Sender.GetClient().GetHabbo().GetRoomUser().Statusses.Add("trd", "");
            Sender.GetClient().GetHabbo().GetRoomUser().UpdateStatus();

            Receiver.GetClient().GetHabbo().GetRoomUser().Statusses.Add("trd", "");
            Receiver.GetClient().GetHabbo().GetRoomUser().UpdateStatus();
        }

        internal void StopTrade(uint StopId)
        {
            if (Sender != null)
            {
                Sender.SendResponse(SerializeStop(StopId));
            }

            if (Receiver != null)
            {
                Receiver.SendResponse(SerializeStop(StopId));
            }

            if (Sender != null)
            {
                if (Sender.GetClient() != null)
                {
                    if (Sender.GetClient().GetHabbo().InRoom)
                    {
                        Sender.GetClient().GetHabbo().GetRoomUser().Statusses.Remove("trd");
                        Sender.GetClient().GetHabbo().GetRoomUser().UpdateStatus();
                    }
                }
            }

            if (Receiver != null)
            {
                if (Receiver.GetClient() != null)
                {
                    if (Receiver.GetClient().GetHabbo().InRoom)
                    {
                        Receiver.GetClient().GetHabbo().GetRoomUser().Statusses.Remove("trd");
                        Receiver.GetClient().GetHabbo().GetRoomUser().UpdateStatus();
                    }
                }
            }

            Dispose();
        }

        internal void UpdateFurni(uint HabboId, Furni Furni)
        {
            if (GetAlternativeCount(HabboId) >= 9 || Furni == null || GetFurni(HabboId) == null) return; // al slots fully

            if (!GetFurni(HabboId).Contains(Furni))
            {
                GetFurni(HabboId).Add(Furni);
            }
            else
            {
                GetFurni(HabboId).Remove(Furni);
            }

            Sender.SendResponse(SerializeItems());
            Receiver.SendResponse(SerializeItems());

            Sender.HasAccepted = false;
            Receiver.HasAccepted = false;
        }

        internal void AcceptTrade(uint HabboId, Boolean State)
        {
            if (Sender.HabboId == HabboId)
            {
                Sender.HasAccepted = State;
            }
            else if (Receiver.HabboId == HabboId)
            {
                Receiver.HasAccepted = State;
            }

            ServerMessage Message = new ServerMessage(109);
            Message.AppendUInt(HabboId);
            Message.AppendBoolean(State);

            Sender.SendResponse(Message);
            Receiver.SendResponse(Message);

            if (Sender.HasAccepted && Receiver.HasAccepted && !HasVerifed)
            {
                Sender.SendResponse(new ServerMessage(111));
                Receiver.SendResponse(new ServerMessage(111));
                HasVerifed = true;

                Sender.HasAccepted = false;
                Receiver.HasAccepted = false;
            }
            else if (Sender.HasAccepted && Receiver.HasAccepted && HasVerifed)
            {
                DeliverItems(HabboId);
            }
        }

        internal void DeliverItems(uint HabboId)
        {
            Sender.SendResponse(new ServerMessage(112));
            Receiver.SendResponse(new ServerMessage(112));

            foreach (Furni Furni in Sender.TradedItems)
            {
                Furni.UpdateOwner(Receiver.GetClient().GetHabbo().Id);
                Receiver.GetClient().GetHabbo().GetInventory().AddnewFurni(Furni, true);
                Sender.GetClient().GetHabbo().GetInventory().RemoveFurni(Furni.Id);
            }

            foreach (Furni Furni in Receiver.TradedItems)
            {
                Furni.UpdateOwner(Sender.GetClient().GetHabbo().Id);
                Sender.GetClient().GetHabbo().GetInventory().AddnewFurni(Furni, true);
                Receiver.GetClient().GetHabbo().GetInventory().RemoveFurni(Furni.Id);
            }

            Dispose();
        }

        internal void Dispose()
        {
            Receiver = null;
            Sender = null;

            DuckEnvironment.TradeManager.ActiveTrades.Remove(Id);
        }
    }
}