using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading;
using System.Windows.Forms;
using SteamSDK;
using System.Diagnostics;
using System.Net;

namespace SteamAPITest
{
    public partial class SteamAPITest : Form
    {
        public static ulong clientServerId = 0;
        public static ulong serverId = 0;
        public static ulong clientId = 0;
        public static bool started = false;
        public static Stopwatch sw = new Stopwatch();
        public DateTime startTime = DateTime.MinValue;
        public int totalPackets = 0;
        public static string debugText = "";
        public static DateTime lastDebug = DateTime.MinValue;

        public SteamAPITest()
        {
            InitializeComponent();

            UpdateTimer.Enabled = true;

            SteamServerAPI.Instance.GameServer.ServersConnected += GameServer_ServersConnected;
            SteamServerAPI.Instance.GameServer.ServersConnectFailure += GameServer_ServersConnectFailure;
            SteamServerAPI.Instance.GameServer.ServersDisconnected += GameServer_ServersDisconnected;
            SteamServerAPI.Instance.GameServer.PolicyResponse += GameServer_PolicyResponse;
            SteamServerAPI.Instance.GameServer.ValidateAuthTicketResponse += GameServer_ValidateAuthTicketResponse;
            SteamServerAPI.Instance.GameServer.UserGroupStatus += GameServer_UserGroupStatus;

            Peer2Peer.SessionRequest += Peer2Peer_SessionRequest;
            Peer2Peer.ConnectionFailed += Peer2Peer_ConnectionFailed;

            Thread serverThread = new Thread(RunServerThread);
            serverThread.IsBackground = true;
            serverThread.Start();

            Thread clientThread = new Thread(RunClientThread);
            clientThread.IsBackground = true;
            clientThread.Start();
        }

        public void RunServerThread()
        {
            bool started = false;
            bool done = false;

            try
            {
                UInt32 ip = 0;
                ulong localServerId = 0;

                ServerStartResult startResult = SteamSDK.SteamServerAPI.Instance.GameServer.Start(
                    new System.Net.IPEndPoint(IPAddress.Parse("0.0.0.0"), 11111),
                    (ushort)11111,
                    ServerMode.eServerModeAuthenticationAndSecure,
                    "1121008",
                    true);

                if (startResult != ServerStartResult.OK)
                {
                    MessageBox.Show(string.Format("Start result: {0}", startResult.ToString()));
                    return;
                }

                SteamServerAPI.Instance.GameServer.SetModDir("Space Engineers");
                SteamServerAPI.Instance.GameServer.ProductName = "Space Engineers";
                SteamServerAPI.Instance.GameServer.GameDescription = "Space Engineers";
                SteamServerAPI.Instance.GameServer.SetDedicated(true);
                SteamServerAPI.Instance.GameServer.SetServerName("ABCDEFGHIJK");
                SteamServerAPI.Instance.GameServer.EnableHeartbeats(true);
                SteamServerAPI.Instance.GameServer.LogOnAnonymous();

                Debug(string.Format("Online: {0}", SteamAPI.Instance != null ? SteamAPI.Instance.IsOnline() : false));

                started = true;

                int timeout = 100;
                while (ip == 0 && timeout > 0)
                {
                    SteamServerAPI.Instance.GameServer.RunCallbacks();
                    //SteamAPI.Instance.RunCallbacks();

                    Thread.Sleep(100);
                    timeout--;

                    ip = SteamServerAPI.Instance.GameServer.GetPublicIP();
                    localServerId = SteamServerAPI.Instance.GameServer.GetSteamID();

                }

                ulong lobbyId = 0;
                /*
                Lobby.Create(LobbyTypeEnum.Public, 4, (lobby, result) =>
                {
                    if(result != Result.OK)
                    {
                        Debug("Unable to create lobby");
                        return;
                    }

                    lobbyId = lobby.LobbyId;
                    done = true;
                });

                while(true)
                {
                    SteamAPI.Instance.RunCallbacks();

                    if (done)
                        break;

                    Thread.Sleep(10);
                }
                */

                string address = IPAddress.Parse(ip.ToString()).ToString();
                Debug(string.Format("Server running: IP: {0} ({1})  ID: {2}  LobbyID: {3}", address, ip, localServerId, lobbyId));
                Invoke(new Action(() =>
                {
                    txtAddress.Text = address.ToString();
                }));

                int count = 0;
                int loopCount = 0;
                while (true)
                {
                    //if(loopCount % 60 == 0)
                        SteamServerAPI.Instance.GameServer.RunCallbacks();

                    loopCount++;
                    //SteamAPI.Instance.RunCallbacks();

                    uint msgSize = 0;
                    Peer2Peer.IsPacketAvailable(out msgSize, 1);
                    if (msgSize > 0)
                    {
                        byte[] buffer = new byte[100];
                        uint dataSize = 0;
                        ulong senderId = 0;

                        while (Peer2Peer.ReadPacket(buffer, out dataSize, out senderId, 1))
                        //Peer2Peer.ReadPacket(buffer, out dataSize, out senderId, 1);
                        {
                            //TimeSpan ts = DateTime.Now - startTime;
                            if(count == 1)
                            {
                                sw.Reset();
                                sw.Start();
                            }

                            count++;

                            //if(count % 10 == 0)
                            Debug(string.Format("TIME:{0:F1}ms : Received packet: \"{2}\" ({3}b)", sw.Elapsed.TotalMilliseconds, dataSize, ASCIIEncoding.ASCII.GetString(buffer, 0, (int)dataSize), dataSize));

                            if (count % 500 == 0)
                                Debug(string.Format("Time elapsed: {0} - packets received: {1} ({2:F1} packets / s)", sw.Elapsed.TotalSeconds, totalPackets, totalPackets / sw.Elapsed.TotalSeconds));

                            totalPackets++;
                        }
                    }

                    Thread.Sleep(0);
                }
            }
            catch (Exception ex)
            {
                Invoke(new Action(() =>
                {
                    MessageBox.Show(string.Format("Error: {0}", ex.ToString()));
                }));
            }
            finally
            {
                if (started)
                {
                    SteamServerAPI.Instance.GameServer.RunCallbacks();
                    SteamServerAPI.Instance.GameServer.EnableHeartbeats(false);
                    SteamServerAPI.Instance.GameServer.LogOff();
                    Peer2Peer.CloseSession(serverId);
                }
            }
        }

        private void Peer2Peer_ConnectionFailed(ulong remoteUserId, P2PSessionErrorEnum error)
        {
            Debug("Peer2Peer_ConnectionFailed");

        }

        private void Peer2Peer_SessionRequest(ulong remoteUserId)
        {
            Debug("Peer2Peer_SessionRequest");
            Peer2Peer.AcceptSession(remoteUserId);
            sw.Start();
        }

        private void GameServer_UserGroupStatus(ulong userId, ulong groupId, bool member, bool officier)
        {
            Debug("GameServer_UserGroupStatus");
        }

        private void GameServer_ValidateAuthTicketResponse(ulong steamID, AuthSessionResponseEnum response, ulong ownerSteamID)
        {
            Debug("GameServer_ValidateAuthTicketResponse");
        }

        private void GameServer_PolicyResponse(sbyte result)
        {
            Debug(string.Format("GameServer_PolicyResponse: {0}", result));
        }

        private void GameServer_ServersDisconnected(Result result)
        {
            Debug("GameServer_ServersDisconnected");
        }

        private void GameServer_ServersConnectFailure(Result result)
        {
            Debug("GameServer_ServersConnectFailure");
        }

        private void GameServer_ServersConnected()
        {
            Debug("GameServer_ServersConnected");
        }

        public void RunClientThread()
        {
             try
            {
                long count = 0;
                while (true)
                {
                    if (SteamAPI.Instance != null)
                        SteamAPI.Instance.RunCallbacks();

                    if (started)
                    {
                        count++;
                        byte[] buffer = ASCIIEncoding.ASCII.GetBytes(string.Format("Client Test Packet #{0}", count));
                        Debug(string.Format("Sending Packet: {0}bytes", buffer.Length));
                        Peer2Peer.SendPacket(clientServerId, buffer, buffer.Length, P2PMessageEnum.UnreliableNoDelay, 1);
                    }
                    else
                        count = 0;

                    if (count == 1)
                    {
                        sw.Reset();
                        sw.Start();
                    }

                    Thread.Sleep(2);
                }
            }
            catch(Exception ex)
            {
                MessageBox.Show(string.Format("Exception : {0}", ex.ToString()));
            }
            finally
            {
                Peer2Peer.CloseSession(serverId);
            }
        }

        unsafe void ServerResponded(GameServerItem serverItem)
        {
            Debug(string.Format("Server Responded: {0}", serverItem.NetAdr.Address.ToString()));

            var buffer = new byte[1024];
            uint length;
            uint ticketHandle;
            if(!SteamAPI.Instance.GetAuthSessionTicket(out ticketHandle, buffer, out length))
            {
                Debug("Failed to get ticket");
                return;
            }

            Debug(string.Format("Ticket Auth: {0}", ticketHandle));

            clientServerId = serverItem.SteamID;
            byte[] buf = ASCIIEncoding.ASCII.GetBytes(string.Format("Client Test Packet #0"));
            Debug(string.Format("Sending Packet: {0}bytes", buf.Length));
            Peer2Peer.SendPacket(clientServerId, buf, buf.Length, P2PMessageEnum.ReliableWithBuffering, 1);
            started = true;
            Thread.Sleep(3000);
        }

        void ServerFailedToRespond()
        {
            Debug("Server failed to respond");
        }

        private void Debug(string text)
        {
            lock(this)
                debugText += text + "\r\n";

            if (DateTime.Now - lastDebug > TimeSpan.FromSeconds(1))
            {
                BeginInvoke(new Action(() =>
                {
                    txtDebug.Text = debugText;
                }));
            }

            lastDebug = DateTime.Now;
        }

        private void UpdateTimer_Tick(object sender, EventArgs e)
        {
            TimeSpan ts = DateTime.Now - startTime;
            //Debug(string.Format("Time elapsed: {0} - packets received: {1} ({2:F1} packets / s)", sw.Elapsed.TotalSeconds, totalPackets, totalPackets / sw.Elapsed.TotalSeconds));
            if(txtDebug.Text.Length != debugText.Length)
                txtDebug.Text = debugText;
        }

        private void btnStart_Click(object sender, EventArgs e)
        {
            SteamAPI.Instance.OnPingServerResponded += ServerResponded;
            SteamAPI.Instance.OnPingServerFailedToRespond += ServerFailedToRespond;

            Debug(string.Format("Connecting to server: {0}", txtAddress.Text));
            UpdateTimer.Enabled = true;
            startTime = DateTime.MinValue;
            serverId = 0;

            IPAddress ip = IPAddress.Parse(txtAddress.Text);
            uint unIP = ip.ToIPv4NetworkOrder();
            SteamAPI.Instance.PingServer(unIP, 11111);
        }

        private void btnStop_Click(object sender, EventArgs e)
        {
            Debug("Stopping client");
            started = false;
            UpdateTimer.Enabled = false;
            startTime = DateTime.MinValue;
            sw.Stop();
        }
    }
}