using System;
using System.Collections;
using System.Collections.Generic;
using Cysharp.Threading.Tasks;
using UnityEngine;
using Net;
using Net.Client;
using Net.Component;
using Net.Share;

namespace BITKit
{
    /// <summary>
    /// 基于GDNet的网络服务
    /// </summary>
    [Serializable]
    public class GDNetService:MonoBehaviour, INetProvider,INetClient
    {
        //服务器地址与端口号
        [Header(Constant.Header.Settings)]
        [SerializeField] private string address;
        [SerializeField] private ushort port;
        [Header(Constant.Header.Components)]
        //绑定GDNet的ClientManager
        [SerializeField,SerializeReference,SubclassSelector]
        private INetClientProvider clientProvider;
        //内部事件系统
        private readonly GenericEvent eventSystem = new();
        //内部变量
        [Header(Constant.Header.InternalVariables)]
        //已保存的Rpc对象
        private readonly List<object> rpcHandles = new();
        //GDNet的网络客户端
        private ClientBase client;
        /// <summary>
        /// 是否已连接到服务端
        /// </summary>
        public bool IsConnected => client.Connected;
        /// <summary>
        /// 连接服务端的延迟
        /// </summary>
        public int Ping { get; private set; }
        //客户端的基本回调
        public event Action OnStartConnect;
        public event Action OnConnected;
        public event Action OnDisconnected;
        public event Action OnConnectedFailed;
        
        public void ServerCommand<T>(T command=default)
        {
            SendRT("CallServerCommand",command);
        }

        public void RpcClientCommand<T>(T command=default)
        {
            SendRT("CallRpcClientCommand",command);
        }

        public void ClientCommand<T>(int id,T command=default)
        {
            SendRT("CallClientCommand",id,command);
        }

        public UniTask<T> GetFromServer<T>(string addressablePath = "Internal")
        {
            throw new NotImplementedException();
        }

        public UniTask<T> GetFromClient<T>(int id, string addressablePath = "Internal")
        {
            throw new NotImplementedException();
        }

        public void AddRpcHandle(object rpcHandle)
        {
            rpcHandles.Add(rpcHandle);
        }

        public void AddCommandListener<T>(Action<T> handle)
        {
            eventSystem.AddListener(handle);
        }

        public void RemoveCommandListener<T>(Action<T> handle)
        {
            eventSystem.RemoveListener(handle);
        }

        public void SendRT(string rpcName, params object[] pars)
        {
            client.SendRT(rpcName,pars);
        }

        public void SendTargetRT(int id, string rpcName, params object[] pars)
        {
            SendRT("CallTargetRT",id,rpcName,pars);
        }

        public void SendAllRT(string rpcName, params object[] pars)
        {
            SendRT("CallSendAllRT",rpcName,pars);
        }

        public async UniTask<bool> Connect(string _address = "localhost", ushort _port = 27014)
        {
            if (client.Connected) return true;
            client.host = _address;
            client.port = _port;
            foreach (var x in rpcHandles)
            {
                client.AddRpcHandle(x);
            }
            OnStartConnect?.Invoke();
            if (await client.Connect())
            {
                OnConnected?.Invoke();
            }
            OnConnectedFailed?.Invoke();
            return false;
        }

        public void Disconnect()
        {
            if (!IsConnected) return;
            client.Close();
            OnDisconnected?.Invoke();
        }
        private void OnReceiveCommand(object command)
        {
            eventSystem.Invoke($"{command.GetType().FullName}.{Constant.System.Internal}",command);
        }

        private void Start()
        {
            client = clientProvider.GetClient();
        }
    }

}