using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Collections;
using ProtoBuf;
using UnnamedGameServer;
using System.Threading;
using Lidgren.Network;

namespace Unnamed_game
{
    using UnnamedGameServer;

    class Connection
    {
        public struct UserInformation
        {
            public string Username;
            public int UserID;
        }

        static private Connection instance;

        private Connection()
        {
            netConfig = new NetPeerConfiguration(SharedConstants.ServerInfo.AppIdentifier);
            netConfig.EnableMessageType(NetIncomingMessageType.Data);
            client = new NetClient(netConfig);
            header = new PacketHeader();
            _isLoggedCharacter = false;
            _isLoggedUser = false;
            magicByte = SharedConstants.ServerInfo.MagicByte;
        }

        // properties
        NetClient client;
        NetConnection serverConnection;
        NetPeerConfiguration netConfig;
        PacketHeader header;
        Thread serverCommThread;
        byte[] magicByte;
        bool _isLoggedCharacter;
        CharacterInformation chInformation
        {
            get
            {
                return Player.Instance().Information;
            }
        }
        bool _isLoggedUser;
        public UserInformation Information;

        // methods
        static public Connection Instance()
        {
            if(instance == null)
            {
                instance = new Connection();
                return instance;
            }
            else
            {
                return instance;
            }
        }
        public void ConnectServer()
        {
            this.ConnectServer(new IPEndPoint(UnnamedGameServer.SharedConstants.ServerInfo.ServerAddress, UnnamedGameServer.SharedConstants.ServerInfo.Port));
        }
        /// <summary>
        /// Should never be used. Use the parameterless one to get the server address and information. It doesn't use try-catch, the exception handling should be done on Game1.Initialize()
        /// </summary>
        public void ConnectServer(IPEndPoint endPoint)
        {
            lock (this)
            {
                if (client.ServerConnection != null)
                {
                    return;
                }
                else
                {
                    client.Start();
                    serverConnection = client.Connect(endPoint);
                    //if (serverConnection.Status != NetConnectionStatus.Connected)
                    //{
                    //    // error connection
                    //    throw new Exception("Cannot connect to server");
                    //}
                    serverCommThread = new Thread(HandleServerCommunication);
                    serverCommThread.Start();
                }
            }
        }
        private void HandleServerCommunication()
        {
            if (client == null)
            {
                throw new Exception("The NetClient is null");
            }
            else
            {
                while (true)
                {
                    PacketHeaderResponse header = new PacketHeaderResponse();
                    client.MessageReceivedEvent.WaitOne();
                    var msg = client.ReadMessage();
                    using (MemoryStream stream = new MemoryStream(msg.Data))
                    {
                        switch (msg.MessageType)
                        {
                            case NetIncomingMessageType.Data:
                                header = Serializer.DeserializeWithLengthPrefix<PacketHeaderResponse>(stream, PrefixStyle.Base128);
                                if (header.type < SharedConstants.Packets.ActionTypeUserStart) // meta
                                {
                                    switch ((ActionTypeMeta)header.type)
                                    {
                                        case ActionTypeMeta.Connect:
                                            HandleConnect(Serializer.DeserializeWithLengthPrefix<PacketConnectResponse>(stream, PrefixStyle.Base128));
                                            break;
                                    }
                                }
                                else if (header.type < SharedConstants.Packets.ActionTypeCharStart) // user
                                {
                                }
                                else // char
                                {
                                }
                                break;
                            case NetIncomingMessageType.DebugMessage:
                                string mess = msg.ReadString();
                                break;
                            case NetIncomingMessageType.StatusChanged:
                                NetConnectionStatus asklasf = (NetConnectionStatus)msg.ReadByte();
                                break;
                            case NetIncomingMessageType.WarningMessage:
                                string mess2 = msg.ReadString();
                                client.Recycle(msg);
                                break;
                        }
                    }
                }
            }
        }
        /// <summary>
        /// This method doesn't check for permissions/priviledges. should check in other methods if you have enough priviledges to do what you plan to do
        /// </summary>
        private void SendPacket(short actionType, object packetStruct, NetDeliveryMethod method)
        {
            header.ActionTypeNumber = (short)actionType;
            NetOutgoingMessage msg = client.CreateMessage();

            using (MemoryStream stream = new MemoryStream())
            {
                Serializer.SerializeWithLengthPrefix<PacketHeader>(stream, header, PrefixStyle.Base128);
                if (actionType < SharedConstants.Packets.ActionTypeUserStart) // meta action
                {
                    switch ((ActionTypeMeta)actionType)
                    {
                        case ActionTypeMeta.Connect:
                            Serializer.SerializeWithLengthPrefix<PacketConnect>(stream, (PacketConnect)packetStruct, PrefixStyle.Base128);
                            break;
                    }
                }
                else if (actionType < SharedConstants.Packets.ActionTypeCharStart) // user action
                {
                }
                else // user action
                {
                }
                msg.Write(stream.ToArray());
                client.SendMessage(msg, method);
            }
        }
        public void CreateNewCharacter(string characterName, CharacterClass chClass, CharacterRace chRace)
        {
            var info = new NewCharacterInfo();
            info.Name = characterName;
            info.OwnerUsername = Information.Username;
            info.Class = chClass;
            info.Race = chRace;
            CreateNewCharacter(info);
        }
        public void CreateNewCharacter(NewCharacterInfo info)
        {
            var packet = new PacketCreateNewCharacter();
            packet.chInfo = info;
            SendPacket((short)ActionTypeUser.CreateNewCharacter, packet, NetDeliveryMethod.ReliableUnordered);
        }
        public void ConnectUser(string username, string unhashedPassword)
        {
            var packet = new PacketConnect();
            packet.Username = username;
            packet.UnhashedPassword = unhashedPassword;
            ConnectUser(packet);
        }
        public void ConnectUser(PacketConnect packet)
        {
            if (_isLoggedUser)
            {
                return;
            }
            else
            {
                SendPacket((short)ActionTypeMeta.Connect, packet, NetDeliveryMethod.ReliableUnordered);
            }
        }
        public void ConnectCharacter(string characterName, short serverID)
        {
            var packet = new PacketLoginCharacter();
            packet.CharacterName = characterName;
            packet.ServerID = serverID;
            ConnectCharacter(packet);
        }
        public void ConnectCharacter(PacketLoginCharacter packet)
        {
            if (_isLoggedCharacter || !_isLoggedUser)
            {
                return;
            }
            else
            {
                SendPacket((short)ActionTypeUser.LoginCharacter, packet, NetDeliveryMethod.ReliableUnordered);
            }
        }
        public void Disconnect(PacketDisconnect packet)
        {
            if (!_isLoggedUser)
            {
                return;
            }
            else
            {
                SendPacket((short)ActionTypeMeta.Disconnect, packet, NetDeliveryMethod.ReliableUnordered);
            }
        }

        // incoming packet manipulation
        private void HandleConnect(PacketConnectResponse packet)
        {
            if (packet.Successfully)
            {
                // login successful
                return;
            }
            else
            {
                // invalid data
                return;
            }
        }
    }
}