namespace Supercell.Laser.Logic.Team
{
    using Supercell.Laser.Logic.Helper;
    using Supercell.Laser.Logic.Listener;
    using Supercell.Laser.Logic.Message.Team;
    using Supercell.Laser.Logic.Message.Team.Stream;
    using Supercell.Laser.Logic.Team.Stream;
    using Supercell.Laser.Logic.Battle.Structures;
    using Supercell.Laser.Titan.DataStream;

    public class TeamEntry
    {
        public long Id;
        public int Type;

        public int LocationId;

        public List<TeamMember> Members { get; set; }
        public List<TeamInviteEntry> Invites { get; set; }
        public List<TeamJoinRequest> JoinRequests { get; set; }
        public List<int> DisabledBots { get; set; }
        public int EventSlot { get; set; }
        public List<int> CustomModifiers;

        public BattlePlayerMap PlayerMap;


        private long EntryCounter;
        public List<TeamStreamEntry> Stream { get; private set; }
        public BattlePlayerMap BattlePlayerMap => PlayerMap;

        public TeamEntry()
        {
            Members = new List<TeamMember>();
            Invites = new List<TeamInviteEntry>();
            JoinRequests = new List<TeamJoinRequest>();
            DisabledBots = new List<int>();
            Stream = new List<TeamStreamEntry>();

            EventSlot = 1;
            EntryCounter = 0;
            
            CustomModifiers = new List<int>();
        }

        public void AddStreamEntry(TeamStreamEntry entry)
        {
            if (entry == null) return;

            entry.Id = ++EntryCounter;
            Stream.Add(entry);
            TeamStreamMessage message = new TeamStreamMessage();
            message.TeamId = Id;
            message.Entries = new TeamStreamEntry[] { entry };

            foreach (var member in Members)
            {
                if (LogicServerListener.Instance.IsPlayerOnline(member.AccountId))
                {
                    LogicServerListener.Instance.GetGameListener(member.AccountId).SendTCPMessage(message);
                }
            }
        }

        public void StreamUpdated()
        {
            
        }

        public TeamMember GetMember(long id)
        {
            return Members.Find(member => member.AccountId == id);
        }

        public TeamInviteEntry GetInviteById(long id)
        {
            return Invites.Find(invite => invite.Id == id);
        }

        public bool IsEveryoneReady()
        {
            foreach (TeamMember member in Members)
            {
                if (!member.IsReady) return false;
            }
            return true;
        }

        public void TeamUpdated()
        {
            TeamMessage message = new TeamMessage();
            message.Team = this;

            foreach (var member in Members)
            {
                if (LogicServerListener.Instance.IsPlayerOnline(member.AccountId))
                {
                    LogicServerListener.Instance.GetGameListener(member.AccountId).SendTCPMessage(message);
                }
            }
        }

        public bool CheckBrawlers(long id1)
        {
            List<int> brawlers = new List<int>();

            foreach (var member in Members)
            {
                brawlers.Add(member.CharacterId);
            }

            Dictionary<int, int> characterIdCounts = new Dictionary<int, int>();

            foreach (var id in brawlers)
            {
                if (characterIdCounts.ContainsKey(id))
                {
                    characterIdCounts[id]++;
                }
                else
                {
                    characterIdCounts[id] = 1;
                }
            }

            foreach (var kvp in characterIdCounts)
            {
                if (kvp.Value > 1)
                {
                    TeamErrorMessage errorMessage = new TeamErrorMessage();
                    errorMessage.Reason = 17;
                    if (LogicServerListener.Instance.IsPlayerOnline(id1))
                    {
                        LogicServerListener.Instance.GetGameListener(id1).SendTCPMessage(errorMessage);
                    }
                    return true;
                }
            }

            return false;
        }
        
        
       /*
       public void Encode(ByteStream stream)
{
    stream.WriteInt(Field1);           // *(_DWORD*)a1 (offset 0)
    stream.WriteByte(Field2);          // *(unsigned __int8*)(a1 + 4)
    stream.WriteInt(Field3);           // *(_DWORD*)(a1 + 8)
    stream.WriteLong(Field4);          // *(_DWORD*)(a1 + 12) — 64-битное? используется WriteVInt? (смещение 76)
    
    stream.WriteInt(Field5);           // *(_DWORD*)(a1 + 16)
    stream.WriteByte(Field6);          // *(unsigned __int8*)(a1 + 5)
    stream.WriteByte(Field7);          // *(unsigned __int8*)(a1 + 6)
    stream.WriteInt(Field8);           // *(_DWORD*)(a1 + 20)
    stream.WriteInt(Field9);           // *(_DWORD*)(a1 + 24)
    stream.WriteDataReference(Field10); // *(_DWORD*)(a1 + 28)
    stream.WriteBattlePlayerMap(Field11); // *(_DWORD*)(a1 + 52)

    // TeamMemberEntry list (offset 32)
    var memberList = Field12;          // *(_DWORD*)(a1 + 32) — указатель на список
    int memberCount = memberList.Count;
    stream.WriteInt(memberCount);
    for (int i = 0; i < memberCount; i++)
        memberList[i].Encode(stream);

    // TeamInviteEntry list (offset 36)
    var inviteList = Field13;          // *(_DWORD*)(a1 + 36)
    int inviteCount = inviteList.Count;
    stream.WriteInt(inviteCount);
    for (int j = 0; j < inviteCount; j++)
        inviteList[j].Encode(stream);

    // TeamJoinRequest list (offset 40)
    var requestList = Field14;         // *(_DWORD*)(a1 + 40)
    int requestCount = requestList.Count;
    stream.WriteInt(requestCount);
    for (int k = 0; k < requestCount; k++)
        requestList[k].Encode(stream);

    // Int list (offset 48)
    var intList = Field15;             // *(_DWORD*)(a1 + 48)
    int intCount = intList.Count;
    stream.WriteInt(intCount);
    for (int m = 0; m < intCount; m++)
        stream.WriteInt(intList[m]);

    stream.WriteByte(Field16);         // *(unsigned __int8*)(a1 + 44)
    stream.WriteByte(Field17);         // *(unsigned __int8*)(a1 + 45)
    stream.WriteByte(Field18);         // *(unsigned __int8*)(a1 + 46)
    
    stream.WriteIntList(Field19);      // *(_DWORD*)(a1 + 60)
}*/

//
// offset  vtbl    IDA-вызов               → C#
// +0      [64]    WriteInt  *a1           → WriteVInt(Type)
// +4      [32]    WriteBoolean *(a1+4)    → WriteBoolean(Type==1)  ← bool-флаг
// +8      [64]    WriteInt  *(a1+8)       → WriteVInt(3) capacity
// +12     [76]    WriteVInt *(a1+12)      → WriteLong(Id)   ← offset 76 = WriteVInt, LogicLong = 2×VInt
// +16     [64]    WriteInt  *(a1+16)      → WriteVInt(EventSlot)  ← НЕ 0!
// +5      [32]    WriteBoolean *(a1+5)    → WriteBoolean(false) unk
// +6      [32]    WriteBoolean *(a1+6)    → WriteBoolean(false) unk
// +20     [64]    WriteInt  *(a1+20)      → WriteVInt(0) unk
// +24     [64]    WriteInt  *(a1+24)      → WriteVInt(0) unk
// +28     DataRef *(a1+28)               → WriteDataReference(LocationId)
// +52     BattlePM *(a1+52)              → WriteBattlePlayerMap(PlayerMap)  ← ЗАКОММЕНТИРОВАНО У ТЕБЯ!
// +32     list Members                   → count + each.Encode
// +36     list Invites                   → count + each.Encode   ← закомментировано!
// +40     list JoinRequests              → count + each.Encode   ← закомментировано!
// +48     list DisabledBots (int)        → count + each WriteInt ← у тебя WriteVInt(0) без списка
// +44     [32]    WriteBoolean *(a1+44)  → WriteBoolean(false)
// +45     [32]    WriteBoolean *(a1+45)  → WriteBoolean(true)
// +46     [32]    WriteBoolean *(a1+46)  → WriteBoolean(false)
// +60     WriteIntList *(a1+60)          → WriteIntList(CustomModifiers)

        public void Encode(ByteStream stream)
        {
            if (stream == null) return;
        
            stream.WriteVInt(Type);                          // +0  [64]
            stream.WriteBoolean(Type == 1);                  // +4  [32]
            stream.WriteVInt(3);                             // +8  [64] capacity
            stream.WriteLong(Id);                            // +12 [76] LogicLong = high+low VInt
        
            stream.WriteVInt(EventSlot);                     // +16 [64] ← было WriteVInt(0), должен быть EventSlot!
            stream.WriteBoolean(false);                      // +5  [32]
            stream.WriteBoolean(false);                      // +6  [32]
            stream.WriteVInt(0);                             // +20 [64]
            stream.WriteVInt(0);                             // +24 [64]
        
            ByteStreamHelper.WriteDataReference(stream, LocationId); // +28
            ByteStreamHelper.WriteBattlePlayerMap(stream, PlayerMap); // +52 ←
        
            // Members list (+32)
            stream.WriteVInt(Members.Count);
            foreach (TeamMember entry in Members.ToArray())
                entry.Encode(stream);
        
            // Invites list (+36)
            stream.WriteVInt(Invites.Count);                 // ← было WriteVInt(0) 
            foreach (TeamInviteEntry entry in Invites.ToArray())
                entry.Encode(stream);
        
            // JoinRequests list (+40)
            stream.WriteVInt(JoinRequests.Count);            // ← было WriteVInt(0) без encode!
            foreach (TeamJoinRequest request in JoinRequests.ToArray())
                request.Encode(stream);
        
            // DisabledBots int list (+48)
            stream.WriteVInt(DisabledBots.Count);            // ← было WriteVInt(0) и больше ничего
            foreach (int bot in DisabledBots.ToArray())
                stream.WriteVInt(bot);
        
            stream.WriteBoolean(false);  // +44 CLUB WAR
            stream.WriteBoolean(true);   // +45 chat
            stream.WriteBoolean(false);  // +46
        
            ByteStreamHelper.WriteIntList(stream, CustomModifiers); // +60
        }
    }
}