using System;
using System.Collections;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using UnityEngine;
using UnityEngine.UI;

public class Server : MonoBehaviour
{

    private TcpListener tcpListener; //This is the listener for TCP
    private Thread tcpListenerThread; //This is the thread that runs TCPListener
    private TcpClient connectedTcpClient; //This is assigned to the accepted TCPClient
    private List<TcpClient> connectedClients;

   // CharacterManager characterManager = new CharacterManager();
    TestEventArgs clientDetails;
    int clientIDcounter = 0;
    private bool RUNNING = false;
    private int clientId;
    EventBus m_eventBus;

    List<NetworkClientInfo> listOfClients;
    ServerController serverController;

    public void StartListen()
    {

        m_eventBus = EventBus.Instance;
        tcpListenerThread = new Thread(new ThreadStart(ListenForIncommingConnections))
        {
            IsBackground = true //
        }; //Assign TCPThread to new thread pointing to listenforcoming requests
        tcpListenerThread.Start();
        RUNNING = true;
    }
    public void StopListen()
    {
        try
        {
            RUNNING = false;
            connectedTcpClient.Close();


            connectedTcpClient.Close();
        }
        catch (Exception e)
        {
            Debug.Log(e.Message);
        }

        // You must close the tcp listener
        try
        {
            tcpListener.Stop();
        }
        catch (Exception e)
        {
            Debug.Log(e.Message);
        }
        Debug.Log("Server stopped");
    }

    private void ListenForIncommingConnections()
    {
        try
        {
            tcpListener = new TcpListener(IPAddress.Any, 7777);
            tcpListener.Start();

            Debug.Log("Server is listening");
            while (RUNNING)
            {
              //  Debug.Log("Running is true");
                connectedTcpClient = tcpListener.AcceptTcpClient();
                Debug.Log("Client Connected");
                NetworkClientInfo clientInfo = new NetworkClientInfo(connectedTcpClient, clientIDcounter)
                {
                    ID = clientIDcounter
                };
                listOfClients.Add(clientInfo);
                clientIDcounter++;
                try
                {
                    m_eventBus.onClientConnected(); //Call method to raise event ClientConnected
                }
                catch (Exception p)
                {
                    Debug.LogError(p);
                }
            }
        }
        catch (SocketException socketException)
        {
            Debug.Log("SocketException " + socketException.ToString());
        }
    }

    public void MessageClient()
    {
        if (connectedTcpClient == null)
        {
            Debug.Log("null");
            return;
        }
        Debug.Log("not null");
        try
        {
            // Get a stream object for writing.
            NetworkStream stream = connectedTcpClient.GetStream();
            if (stream.CanWrite)
            {
                string serverMessage = "This is a message from your server.";
                // Convert string message to byte array.
                byte[] serverMessageAsByteArray = Encoding.ASCII.GetBytes(serverMessage);
                // Write byte array to socketConnection stream.
                stream.WriteAsync(serverMessageAsByteArray, 0, serverMessageAsByteArray.Length);
                Debug.Log("Server sent his message - should be received by client");
            }
        }
        catch (SocketException socketException)
        {
            Debug.Log("Socket exception: " + socketException);
        }
    }


    private void HandleConnection(string message)
    {
        //Type, 0 = test
        string[] data = message.Split(',');
        switch (data[0])
        {
            case "1":
                MessageClient();
                //        m_eventBus.invokeEventArgs(this, new TestEnvir());
                break;

            case "2":
                Debug.Log("Sending type 2");
                break;

            default:
                break;
        }

    }

    void OnApplicationQuit()
    {
        StopListen();
    }
}