using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Mirror;
using LitJson;
using System;
using UnityCommon;

namespace DTYJ
{
    /// <summary>
    /// 网络动画播放器
    /// </summary>
    public class NetworkAnimPlayer : NetworkBehaviour
    {
        public static NetworkAnimPlayer instance;
        private void Awake()
        {
            instance = this;
        }
        /// <summary>
        /// 普通一次性动画 电梯上下行、紧急停车按钮动画等
        /// </summary>
        /// <param name="path"></param>
        /// <param name="animName"></param>
        [Command(requiresAuthority = false)]
        public void CmdPlayAnim(string path, string animName)
        {
            RPCPlayAnim(path, animName);
        }
        [ClientRpc]
        public void RPCPlayAnim(string path, string animName)
        {
            var anim = GameObject.Find(path).GetComponent<Animation>();
            anim.Play(string.IsNullOrEmpty(animName) ? anim.name : animName);
        }

        #region 普通门的动画
        /// <summary>
        /// 记录门开关状态 string 动画路径 bool true - 开
        /// </summary>
        private Dictionary<string, bool> dicNormalAnimSwitch = new Dictionary<string, bool>();
        /// <summary>
        /// 普通开关动画  如：门等
        /// </summary>
        /// <param name="path"></param>
        /// <param name="animName"></param>
        [Command(requiresAuthority = false)]
        public void CmdPlayAnimNormalSwitch(string path_animName)
        {
            if (dicNormalAnimSwitch.ContainsKey(path_animName))
                dicNormalAnimSwitch[path_animName] = !dicNormalAnimSwitch[path_animName];
            else
                dicNormalAnimSwitch[path_animName] = true;
            RpcPlayAnimNormalSwitch(path_animName, dicNormalAnimSwitch[path_animName]);
        }
        [ClientRpc]
        public void RpcPlayAnimNormalSwitch(string path_animName, bool isOpen)
        {
            Debug.Log(path_animName + isOpen);
            var arr = path_animName.Split('|');
            var anim = GameObject.Find(arr[0]).GetComponent<Animation>();
            var animationName = arr[1];
            Debug.Log(anim);
            Debug.Log("animationName:" + animationName);
            Debug.Log(anim.clip.name);
            anim[animationName].time = isOpen ? 0 : anim[animationName].length;
            anim[animationName].speed = isOpen ? 1 : -1;
            anim[animationName].wrapMode = WrapMode.Once;
            anim.CrossFade(animationName);
        }
        [TargetRpc]
        public void RpcPlayAnimNormalSwitch_conn(NetworkConnection target, string path_animName, bool isOpen)
        {
            var arr = path_animName.Split('|');
            var anim = GameObject.Find(arr[0]).GetComponent<Animation>();
            var animationName = arr[1];
            anim[animationName].time = isOpen ? 0 : anim[animationName].length;
            anim[animationName].speed = isOpen ? 1 : -1;
            anim[animationName].wrapMode = WrapMode.Once;
            anim.CrossFade(animationName);
        }
        /// <summary>
        /// 同步门动画状态
        /// </summary>
        [Server]
        public void AsyncPlayAnimNormalSwitch(NetworkConnection target)
        {
            foreach (var item in dicNormalAnimSwitch)
            {
                RpcPlayAnimNormalSwitch_conn(target, item.Key, item.Value);
            }
        }
        #endregion

        #region 设置设备状态
        public void SendCmdToServer(int cmd, object obj)
        {
            var cmdData = new { cmd = cmd, data = obj };
            CmdSendCmdToServer(Newtonsoft.Json.JsonConvert.SerializeObject(cmdData));
        }

        /// <summary>
        /// 发送命令到协同服务器
        /// </summary>
        /// <param name="json"></param>
        [Command(requiresAuthority = false)]
        public void CmdSendCmdToServer(string json)
        {
            Debug.Log("发送消息到协同服务器：" + json);
            try
            {
                //CMDData cMDData = new CMDData();
                //cMDData.cmd = cmd;
                //cMDData.data = JsonMapper.ToObject(jsonData);
                //var json = JsonMapper.ToJson(cMDData);
                OnlineCtrl.Instance.SendCmdToServer(json);
            }
            catch (Exception e)
            {
                Debug.LogError(e.Message);
            }
        }
        //[Command(requiresAuthority = false)]
        //public void CmdSetEquipState(string equipType, int state_0, int state_2)
        //{
        //    RpcSetEquipState(equipType, state_0, state_2);
        //}
        //[ClientRpc]
        //public void RpcSetEquipState(string equipType, int state_0, int state_2)
        //{

        //}
        #endregion


        #region 消息处理
        [Server]
        public void OnMsgReceived2(int cmd, JsonData obj)
        {
            string jsonStr = obj.ToJson();
            switch (cmd)
            {
                case 10101:
                    TrainHandle(jsonStr);
                    break;
                case 10105:
                    TrainDoorHandle(jsonStr);
                    break;
                case 10201:
                    AFCGateMachine(jsonStr);
                    break;
                case 10202:
                    AFCTVM(jsonStr);
                    break;
                case 10301:
                    PlatformDoorClose(jsonStr);
                    break;
                case 10302:
                    PlatformDoorCtrl(jsonStr);
                    break;
                case 10401:
                    VerticalElevator(jsonStr);
                    break;
                case 10402:
                    Elevator(jsonStr);
                    break;
                case 10501:
                    KeLiu(jsonStr);
                    break;
                case 10601:
                    ShuiZai(jsonStr);
                    break;
                default:
                    break;
            }
        }

        //[Server]
        //public void OnMsgReceived(CMDData cmdData)
        //{
        //switch (cmdData.cmd)
        //{
        //    case 10101:
        //        TrainHandle(cmdData);
        //        break;
        //    case 10201:
        //        AFCGateMachine(cmdData);
        //        break;
        //    case 10202:
        //        AFCTVM(cmdData);
        //        break;
        //    case 10301:
        //        PlatformDoorClose(cmdData);
        //        break;
        //    case 10302:
        //        PlatformDoorCtrl(cmdData);
        //        break;
        //    case 10401:
        //        VerticalElevator(cmdData);
        //        break;
        //    case 10402:
        //        Elevator(cmdData);
        //        break;
        //    default:
        //        break;
        //}
        //}
        #region 列车控制
        readonly Dictionary<string, TrainCtrl> dicTrains = new Dictionary<string, TrainCtrl>();
        public void TrainHandle(string jsonData)
        {
            var trainInfo = JsonMapper.ToObject<TrainInfo>(jsonData);
            //var trainInfo = cmdData.GetData<TrainInfo>();
            if (dicTrains.ContainsKey(trainInfo.trainNo))
                dicTrains[trainInfo.trainNo].MsgHandle(trainInfo);
            else
            {
                var prefabTrain = OnlineNetworkManager.singleton.spawnPrefabs[2];
                GameObject train = GameObject.Instantiate(prefabTrain);
                train.transform.position = Vector3.up * 1000 * dicTrains.Count;
                train.name = trainInfo.trainNo;
                NetworkServer.Spawn(train);
                //train.transform.position = Vector3.up * 1000 * dicTrains.Count;
                //train.name = trainInfo.trainNo;
                dicTrains[trainInfo.trainNo] = train.GetComponent<TrainCtrl>();
                dicTrains[trainInfo.trainNo].RpcSetName(trainInfo.trainNo);
            }
        }
        public void TrainDoorHandle(string jsonData)
        {
            TrainDoorState trainDoorState = JsonMapper.ToObject<TrainDoorState>(jsonData);
            RpcSetTrainDoor(trainDoorState.trainNo, trainDoorState.state);
            if (trainDoorState.state == 1)
            {
                if (TrainCtrl.trainStop_xiaxing == trainDoorState.trainNo)
                {
                    OnlineCtrl.Instance.chengKeCtrl.ShangChe(2);
                    OnlineCtrl.Instance.chengKeCtrl.XiaChe(trainDoorState.trainNo);
                }
                if (TrainCtrl.trainStop_shangxing == trainDoorState.trainNo)
                {
                    OnlineCtrl.Instance.chengKeCtrl.ShangChe(1);
                    OnlineCtrl.Instance.chengKeCtrl.XiaChe(trainDoorState.trainNo);
                }
            }
        }
        [ClientRpc]
        public void RpcSetTrainDoor(string trainNo, int doorState)
        {
            if (TrainCtrl.TrainCtrlDic.ContainsKey(trainNo))
                TrainCtrl.TrainCtrlDic[trainNo].TrainDoor(doorState);
        }
        #endregion

        /// <summary>
        /// 闸机控制
        /// </summary>
        /// <param name="cmdData"></param>
        public void AFCGateMachine(string jsonStr)
        {
            AFCZhaJi data = JsonMapper.ToObject<AFCZhaJi>(jsonStr);
            RpcAFCGateMachine(data.gateMachineNo, data.state, data.direction);
        }
        [ClientRpc]
        public void RpcAFCGateMachine(string gateMachineNo, int state, int dir)
        {
            ZhaJiCtrl.Instance.SetGateState(gateMachineNo, state, dir);
        }

        public void AFCTVM(string jsonStr)
        {
            AFCTVM data = JsonMapper.ToObject<AFCTVM>(jsonStr);
            RpcAFCTVM(data.tvmNo, data.state);
        }
        [ClientRpc]
        public void RpcAFCTVM(string tvmNo, int state)
        {
            TvmCtrl.Instance.SetTVM(tvmNo, state);
        }

        public void PlatformDoorClose(string jsonStr)
        {
            ZhanTaiMenSuoBi data = JsonMapper.ToObject<ZhanTaiMenSuoBi>(jsonStr);
            RpcPlatformDoorCtrl(data.platformDoorNo, data.state);
        }
        /// <summary>
        /// 单活动门控制状态
        /// </summary>
        /// <param name="cmdData"></param>
        public void PlatformDoorCtrl(string jsonStr)
        {
            //ZhanTaiMenKongZhi data = JsonMapper.ToObject<ZhanTaiMenKongZhi>(jsonStr);
            //RpcPlatformDoorCtrl(data.platformDoorNo, data.state);
        }
        [ClientRpc]
        public void RpcPlatformDoorCtrl(string platformDoorNo, int state)
        {
            PlatformDoorController.Instance.SetDoor(platformDoorNo, state);
        }
        public void VerticalElevator(string jsonStr) { }
        public void Elevator(string jsonStr)
        {

            DianFuTi data = JsonMapper.ToObject<DianFuTi>(jsonStr);
            RpcElevator(data.elevatorNo, data.state);
        }
        [ClientRpc]
        public void RpcElevator(string nnumber, int state)
        {
            DianFuTiCtrl.Instance.SetState(nnumber, state);
        }

        public void KeLiu(string jsonStr)
        {
            KeLiuData data = JsonMapper.ToObject<KeLiuData>(jsonStr);
            ControllerPanel.instance?.CmdSetJinZhanSpeed((int)data.speedOfEntry);
        }

        private void ShuiZai(string jsonStr)
        {
            ShuiZaiData data = JsonMapper.ToObject<ShuiZaiData>(jsonStr);
            ControllerPanel.instance?.CmdSetShuiZai(data.isTurnOn, (float)data.strength);
        }

        #endregion
    }
}