using System;
using System.Net;
using System.Text;
using System.Net.Sockets;
using System.Collections.Generic;

namespace FileSecurity_Server.Networking
{
    class Client
    {
        private Socket ClientSocket;
        private IPEndPoint ClientEndPoint;
        private Boolean SentCredentials = false;
        private String MacAddress;
        private String UniqueID;

        private Byte[] ClientBuffer;

        public Client(Socket ClientHandle)
        {
            ClientSocket = ClientHandle;
            ClientEndPoint = (IPEndPoint)ClientSocket.RemoteEndPoint;

            Program.Writer.WriteBlank(true, "({0}) Has Connected!", ClientEndPoint.Address);

            Receive();
        }

        private void Receive()
        {
            try
            {
                ClientBuffer = new Byte[Properties.Settings.Default.Byte_Size];

                ClientSocket.BeginReceive(ClientBuffer, 0, ClientBuffer.Length, SocketFlags.None, new AsyncCallback(Received), ClientSocket);
            }
            catch { Close(); }
        }

        private void Received(IAsyncResult Result)
        {
            try
            {
                Int32 Length = ClientSocket.EndReceive(Result);

                Array.Resize(ref ClientBuffer, Length);

                if (Length != 0)
                {
                    String[] ReceiveSplit = Encoding.Unicode.GetString(ClientBuffer).Split('|');

                    Int16 Header = Convert.ToInt16(ReceiveSplit[0]);

                    switch (Header)
                    {
                        case 0:
                            {
                                MacAddress = ReceiveSplit[1];
                                UniqueID = ReceiveSplit[2];

                                if (MacAddress.Length != 12)
                                {
                                    Program.Writer.WriteBlank(true, "({0}) Has Disconnected, Reason -> Invalid MacAddress Length!", ClientEndPoint.Address);

                                    Close();

                                    return;
                                }
                                else if (UniqueID.Length != 19)
                                {
                                    Program.Writer.WriteBlank(true, "({0}) Has Disconnected, Reason -> Invalid UniqueID Length", ClientEndPoint.Address);

                                    Close();

                                    return;
                                }

                                Program.Writer.WriteBlank(true, "({0}) Has Sent Credentials, Mac -> {1}, UniqueID -> {2}!", ClientEndPoint.Address, MacAddress, UniqueID);

                                SentCredentials = true;

                                String Files = "";

                                foreach (var File in Program.System.Files) { Files += String.Format("{0},", File); }

                                Files = Files.TrimStart(',');

                                Console.WriteLine(Files);

                                Send(String.Format("0|{0}", Files));

                                break;
                            }
                        case 1:
                            {
                                if (!SentCredentials)
                                {
                                    Program.Writer.WriteBlank(true, "({0}) Has Disconnected, Reason -> No Credentials Supplied!", ClientEndPoint.Address);

                                    Close();

                                    return;
                                }

                                Dictionary<String, String> ClientHashes = new Dictionary<String, String>();

                                foreach (var Hash in ReceiveSplit[1].Split(','))
                                {
                                    String[] HashSplit = Hash.Split('#');

                                    ClientHashes.Add(HashSplit[0], HashSplit[1]);
                                }

                                foreach (var Hash in Program.System.Files)
                                {
                                    if (Program.System.Hashes[Hash] != ClientHashes[Hash])
                                    {
                                        Program.Writer.WriteBlank(true, "({0}) Has Disconnected, Reason -> Modified File: {1}!", ClientEndPoint.Address, Hash);

                                        Send(String.Format("2|{0} Is Modified!", Hash));

                                        Program.Query.InsertLog(Convert.ToString(ClientEndPoint.Address), MacAddress, UniqueID, false);

                                        Close();

                                        return;
                                    }
                                }

                                Program.Writer.WriteBlank(true, "({0}) Connection Allowed, All Files Ok!", ClientEndPoint.Address);

                                Send("1");

                                Program.Query.InsertLog(Convert.ToString(ClientEndPoint.Address), MacAddress, UniqueID, true);

                                Close();

                                return;
                            }
                        default:
                            {
                                Program.Writer.WriteBlank(true, "({0}) Has Disconnected, Reason -> Sent Invalid Packet!", ClientEndPoint.Address);

                                Close();

                                return;
                            }
                    }

                    Receive();
                }
                else { Close(); }
            }
            catch { Close(); }
        }

        private void Close()
        {
            try
            {
                ClientSocket.Disconnect(false);
                ClientSocket.Close();
            }
            catch { }
        }

        public void Send(String Message, params Object[] Args)
        {
            try
            {
                String FormattedMessage = String.Format(Message, Args);

                Byte[] Buffer = Encoding.Unicode.GetBytes(FormattedMessage);

                ClientSocket.BeginSend(Buffer, 0, Buffer.Length, SocketFlags.None, new AsyncCallback(Sent), ClientSocket);
            }
            catch { Close(); }
        }

        private void Sent(IAsyncResult Result)
        {
            try { ClientSocket.EndSend(Result); }
            catch { Close(); }
        }
    }
}