using System;
using System.Collections.Generic;
using System.Net.Sockets;
using System.Text;
using MafiaCommon.Packets;
using MafiaServer.Events;
using MafiaCommon;

namespace MafiaServer
{
    public class PlayerSocketWorker
    {
        private readonly Socket _socket;
        public readonly string PlayerName;
        public event OnDisconnectByErrorEvent OnDisconnectByErrorEvent;
        public event OnPlayerSendMessageEvent OnPlayerSendMessageEvent;
        public event OnDisconnectEvent OnDisconnectEvent;
        public event OnPlayerVoteEvent OnPlayerVoteEvent;
        public int Id;
        public Role Role = Role.Citizen;

        public PlayerSocketWorker(Socket socket)
        {
            _socket = socket;
            StringBuilder builder = new StringBuilder();
            int bytes = 0;
            byte[] data = new byte[256];
            do
            {
                bytes = _socket.Receive(data);
                builder.Append(Encoding.UTF8.GetString(data, 0, bytes));
            } while (_socket.Available > 0);

            var packet = PacketConverter.ToPacket(builder.ToString())[0];
            if (packet.GetType() == typeof(ConnectPacket))
            {
                PlayerName = ((ConnectPacket) packet).Name;
                MafiaServer.Game.ConnectPlayer(this);
            }
            else
            {
                _socket.Close();
            }
        }

        public void SendPacket(Packet packet)
        {
            try
            {
                _socket.Send(PacketConverter.ToBytes(packet));
            }
            catch (Exception)
            {
                // ignored
            }
        }

        public void Disconnect()
        {
            _socket.Close();
        }

        public void Run()
        {
            while (_socket.Connected)
            {
                try
                {
                    StringBuilder builder = new StringBuilder();
                    int bytes = 0;
                    byte[] data = new byte[256];
                    do
                    {
                        bytes = _socket.Receive(data);
                        builder.Append(Encoding.UTF8.GetString(data, 0, bytes));
                    } while (_socket.Available > 0);

                    Console.WriteLine(builder.ToString());

                    List<Packet> packets = PacketConverter.ToPacket(builder.ToString());
                    foreach (Packet packet in packets)
                    {
                        WorkPacket(packet);
                    }
                }
                catch (SocketException)
                {
                    OnDisconnectByErrorEvent.Invoke(this);
                }
            }
        }

        private void WorkPacket(Packet packet)
        {
            switch (packet.PacketType)
            {
                case PacketType.MessageSendPacket:
                    OnPlayerSendMessageEvent.Invoke(this, ((MessageSendPacket) packet).ChatType,
                        ((MessageSendPacket) packet).Text);
                    break;
                case PacketType.DisconnectPlayer:
                    _socket.Close();
                    OnDisconnectEvent.Invoke(this);
                    break;
                case PacketType.Vote:
                    OnPlayerVoteEvent.Invoke(this, ((VotePacket) packet).Id);
                    break;
            }
        }
    }
    
    public static class PlayerSocketWorkerUtils {
        public static PlayerSocketWorker FindPlayerById(this List<PlayerSocketWorker> original, int id)
        {
            foreach (PlayerSocketWorker player in original)
            {
                if (player.Id == id) return player;
            }

            return null;
        }
    }
}