using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Windows.Forms;

namespace BlabberIM
{
    public class Session
    {
        public Socket mSocket;
        private byte[] buffer;

        public delegate void DOnDisconnect();
        public event DOnDisconnect OnDisconnect;
        public bool mConnected = false;
        private bool isSize { get; set; }
        private int mReceived = 0;
        PacketHandler mPacketHandler = new PacketHandler();

        public Session()
        {
            Console.WriteLine("Session created. {0}", Environment.StackTrace);
        }

        public void Connect(string pServerIP, ushort pServerPort)
        {
            isSize = true;
            mSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
            mSocket.BeginConnect(pServerIP, pServerPort, new AsyncCallback(OnConnected), null);
        }

        private void OnConnected(IAsyncResult ar)
        {
            try
            {
                mSocket.EndConnect(ar);
                mConnected = true;

                Program.PerformLogin();

                mSocket.BeginReceive(buffer = new byte[4], 0, 4, SocketFlags.None, new AsyncCallback(ParseHeader), mSocket);
            }
            catch (SocketException ex)
            {
                switch (ex.SocketErrorCode)
                {
                    case SocketError.TimedOut:
                        Program.ShowLoginError("Connection failed: Connection timed out. Please try again later.", "Connection failure");
                        break;
                    case SocketError.ConnectionRefused:
                        Program.ShowLoginError("The server is currently offline. Please try again later.", "Connection failure");
                        break;
                    /*case SocketError.AccessDenied:
                        break;
                    case SocketError.ConnectionAborted:
                        break;
                    case SocketError.HostDown:
                        break;
                    case SocketError.HostNotFound:
                        break;
                    case SocketError.HostUnreachable:
                        break;
                    case SocketError.IsConnected:
                        break;*/
                    default:
                        Program.ShowLoginError("Connection failed due to an unknown reason/error: " + ex.SocketErrorCode.ToString() + Environment.NewLine + ex.Message, "Connection failure"); break;

                }

                Program.loginForm.Invoke((MethodInvoker)delegate {
                    Program.loginForm.loginButton.Enabled = true;
                    Program.loginForm.loginButton.Text = "Login";
                });
            }
        }
        public void Disconnect()
        {
            if (mConnected)
            {
                Console.WriteLine("Disconnecting or disconnected from server. Stacktrace {0}", Environment.StackTrace);
                mConnected = false;
                if (OnDisconnect != null)
                {
                    OnDisconnect();
                }
                try
                {
                    mSocket.Shutdown(SocketShutdown.Both);
                    mSocket.Close();
                }
                catch { }

            }
        }

        void ParseHeader(IAsyncResult ar)
        {
            try
            {
                int len = mSocket.EndReceive(ar);
                if (len < (isSize ? 4 : 2))
                {
                    Disconnect();
                    return;
                }
                int nextReceiveLength = 4;
                mReceived += len;
                if (isSize)
                {
                    nextReceiveLength = BitConverter.ToInt32(buffer, 0);
                    isSize = false;
                    mReceived = 0;
                    buffer = new byte[nextReceiveLength];
                }
                else
                {
                    if (mReceived == buffer.Length){
                        Packet packet = new Packet(buffer);
                        Handle(this, packet);
                        isSize = true;
                        mReceived = 0;
                        buffer = new byte[nextReceiveLength];
                    }
                }
                mSocket.BeginReceive(buffer, mReceived, buffer.Length - mReceived, SocketFlags.None, new AsyncCallback(ParseHeader), mSocket);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                Disconnect();
            }

        }

        void ParseData(IAsyncResult ar)
        {
            if (!mConnected) return;
            try
            {
                int len = mSocket.EndReceive(ar);
                if (len <= 0)
                {
                    Disconnect();
                    return;
                }
                byte[] realData = new byte[buffer.Length - 4];
                Buffer.BlockCopy(buffer, 4, realData, 0, buffer.Length - 4);
                Packet lPacket = new Packet(realData);
                Handle(this, lPacket);
                mSocket.BeginReceive(buffer = new byte[4], 0, 4, SocketFlags.None, new AsyncCallback(ParseHeader), mSocket);
            }
            catch
            {
                Disconnect();
            }
        }
        public void Handle(Session session, Packet packet)
        {
            mPacketHandler.GetHandler(packet.Opcode).OnPacket(packet, session);
        }
        public void SendPacket(Packet packet)
        {
            if (!mConnected)
                return;
            byte[] data = packet.GetPacket();
            Console.WriteLine("TRying to send packet... Length {0}, Data: {1}", data.Length, data.ToReadableByteArray());
            try
            {
                mSocket.Send(data);
            }
            catch
            {

            }
        }
    }
}