using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
using Snxxz.UI;

[XLua.LuaCallCSharp]
public class GameNetSystem : Singleton<GameNetSystem>
{
    NetUpdateBehaviour m_NetUpdateBehaviour;
    NeverConnectState neverConnectState;
    AccountLoginState accountLoginState;
    CreateOrSelectRoleState createOrSelectRoleState;
    RoleLoginState roleLoginState;
    ConnectedState connectedState;
    DisconnectState disconnectState;

    NetState m_NetState;
    public NetState netState {
        get { return this.m_NetState; }
        set {
            if (this.m_NetState != value)
            {
                switch (m_NetState)
                {
                    case NetState.NerverConnect:
                        neverConnectState.OnExit();
                        break;
                    case NetState.AccountLogin:
                        accountLoginState.OnExit();
                        break;
                    case NetState.CreateOrSelectRole:
                        createOrSelectRoleState.OnExit();
                        break;
                    case NetState.RoleLogin:
                        roleLoginState.OnExit();
                        break;
                    case NetState.Connected:
                        connectedState.OnExit();
                        break;
                    case NetState.DisConnected:
                        disconnectState.OnExit();
                        break;
                }

                this.m_NetState = value;
                switch (m_NetState)
                {
                    case NetState.NerverConnect:
                        neverConnectState.OnEnter();
                        break;
                    case NetState.AccountLogin:
                        accountLoginState.OnEnter();
                        break;
                    case NetState.CreateOrSelectRole:
                        createOrSelectRoleState.OnEnter();
                        break;
                    case NetState.RoleLogin:
                        roleLoginState.OnEnter();
                        break;
                    case NetState.Connected:
                        connectedState.OnEnter();
                        break;
                    case NetState.DisConnected:
                        disconnectState.OnEnter();
                        break;
                }
            }
        }
    }

    private ClientSocket mainSocket;
    public bool mainSocketConnected { get { return mainSocket == null ? false : mainSocket.connected; } }

    public float timeSinceMainSocketLastProtocol {
        get { return mainSocket == null ? 0f : (float)(DateTime.Now - mainSocket.lastPackageTime).TotalSeconds; }
    }

    private ClientSocket crossServerSocket;
    public bool crossServerSocketConnected { get { return crossServerSocket == null ? false : crossServerSocket.connected; } }

    public float timeSinceCrossServerSocketLastProtocol {
        get { return crossServerSocket == null ? 0f : (float)(DateTime.Now - crossServerSocket.lastPackageTime).TotalSeconds; }
    }

    Queue<GameNetPackBasic> mainProtocolQueue = new Queue<GameNetPackBasic>();
    Queue<GameNetPackBasic> crossSeverProtocolQueue = new Queue<GameNetPackBasic>();

    public GameNetSystem()
    {
        var gameObject = new GameObject("NetUpdateBehaviour");
        GameObject.DontDestroyOnLoad(gameObject);
        m_NetUpdateBehaviour = gameObject.AddComponent<NetUpdateBehaviour>();
        m_NetUpdateBehaviour.RegisterUpdateCallBack(OnUpdate);

        neverConnectState = gameObject.AddComponent<NeverConnectState>();
        accountLoginState = gameObject.AddComponent<AccountLoginState>();
        createOrSelectRoleState = gameObject.AddComponent<CreateOrSelectRoleState>();
        roleLoginState = gameObject.AddComponent<RoleLoginState>();
        connectedState = gameObject.AddComponent<ConnectedState>();
        disconnectState = gameObject.AddComponent<DisconnectState>();

        netState = NetState.NerverConnect;
    }

    public void BeginConnectGameServer(string ip, int port, Action onConnected)
    {
        try
        {
            if (mainSocketConnected)
            {
                mainSocket.CloseConnect();
            }
        }
        catch (System.Exception ex)
        {
            DebugEx.Log(ex);
        }

        mainSocket = new ClientSocket(SocketType.Main);
        mainProtocolQueue.Clear();

        mainSocket.Connect(ip, port, () =>
        {
            if (onConnected != null)
            {
                onConnected();
            }
        });
    }

    public void BeginConnectCrossServer(string ip, int port, Action onConnected)
    {
        try
        {
            if (crossServerSocketConnected)
            {
                crossServerSocket.CloseConnect();
            }
        }
        catch (System.Exception ex)
        {
            DebugEx.Log(ex);
        }

        crossServerSocket = new ClientSocket(SocketType.CrossSever);
        crossSeverProtocolQueue.Clear();
        this.crossServerSocket.Connect(ip, port, () =>
        {
            if (onConnected != null)
            {
                onConnected();
            }
        });
    }

    public void SendInfo(GameNetPackBasic protocol)
    {
        if (mainSocket != null)
        {
            mainSocket.SendInfo(protocol);
            DebugPkgCache.Push(protocol);
        }
    }

    public void SendInfo(byte[] vBytes)
    {
        if (mainSocket != null)
        {
            mainSocket.SendInfo(vBytes);
        }
    }

    public void SendToCrossServer(GameNetPackBasic protocol)
    {
        if (crossServerSocket != null)
        {
            crossServerSocket.SendInfo(protocol);
            DebugPkgCache.Push(protocol);
        }
    }

    public void PushPackage(GameNetPackBasic protocol, SocketType type)
    {
        lock (this)
        {
            if (protocol == null)
            {
                return;
            }

            if (PackageRegedit.Contain(protocol.cmd))
            {
                switch (type)
                {
                    case SocketType.Main:
                        mainProtocolQueue.Enqueue(protocol);
                        break;
                    case SocketType.CrossSever:
                        crossSeverProtocolQueue.Enqueue(protocol);
                        break;
                    default:
                        break;
                }

                DebugPkgCache.Push(protocol);
            }
            else
            {
                DebugEx.LogWarningFormat("数据包(cmd:{0})未登记！", protocol.cmd);
            }
        }
    }

    public void Disconnect()
    {
        try
        {
            if (mainSocket != null)
            {
                mainSocket.CloseConnect();
            }

            if (crossServerSocket != null)
            {
                crossServerSocket.CloseConnect();
            }

            mainProtocolQueue.Clear();
            crossSeverProtocolQueue.Clear();
        }
        catch (Exception ex)
        {
            Debug.Log(ex);
        }
        finally
        {
            netState = NetState.DisConnected;
            var loginModel = ModelCenter.Instance.GetModel<LoginModel>();
            loginModel.busy = false;
        }

    }

    public void Reconnect()
    {
        try
        {
            if (mainSocket != null)
            {
                mainSocket.CloseConnect();
            }

            if (crossServerSocket != null)
            {
                crossServerSocket.CloseConnect();
            }

            mainProtocolQueue.Clear();
            crossSeverProtocolQueue.Clear();
        }
        catch (Exception ex)
        {
            Debug.Log(ex);
        }
        finally
        {
            netState = NetState.AccountLogin;
            var loginModel = ModelCenter.Instance.GetModel<LoginModel>();
            loginModel.busy = false;
            loginModel.ReAccountLogin();
        }
    }

    public void LoginOut()
    {
        try
        {
            if (mainSocket != null)
            {
                mainSocket.CloseConnect();
            }

            if (crossServerSocket != null)
            {
                crossServerSocket.CloseConnect();
            }

            mainProtocolQueue.Clear();
            crossSeverProtocolQueue.Clear();
        }
        catch (Exception ex)
        {
            Debug.Log(ex);
        }
        finally
        {
            netState = NetState.NerverConnect;
            var loginModel = ModelCenter.Instance.GetModel<LoginModel>();
            loginModel.busy = false;
            WindowJumpMgr.Instance.ClearJumpData();
            StageManager.Instance.LoadLoginStage();
            NetLinkWin.Hide();
        }
    }

    public void OnAccountLogin()
    {
        netState = NetState.AccountLogin;
    }

    public void OnEnterWorld()
    {
        netState = NetState.RoleLogin;
    }

    void OnUpdate()
    {
        while (mainProtocolQueue.Count > 0)
        {
            PackageRegedit.Distribute(mainProtocolQueue.Dequeue());
        }

        while (crossSeverProtocolQueue.Count > 0)
        {
            PackageRegedit.Distribute(crossSeverProtocolQueue.Dequeue());
        }
    }

    public enum NetState
    {
        NerverConnect = 1,
        AccountLogin = 2,
        CreateOrSelectRole = 3,
        RoleLogin = 4,
        Connected = 5,
        DisConnected = 6,
    }

    public enum SocketType
    {
        Main = 1,
        CrossSever = 2,
    }

}