using System.Collections.Generic;
using UnityEngine;
using AdamThinkDevicesData;
using AdamSync;
using Newtonsoft.Json;
using static InterfaceManager;
using System.Collections;
using UnityEngine.Events;

/// <summary>
/// 设备
/// </summary>
public class EquipmentCommon : MonoBehaviour
{
    public EquipmentCommon equipmentCommon;

    /// <summary>
    /// 场景所在方
    /// </summary>
    public SelectedSide selectedSide = SelectedSide.Other;

    public string equipmentType = "";

    /// <summary>
    /// 设备唯一ID
    /// </summary>
    public string deviceID;
    /// <summary>
    /// 是否是本人创建的设备
    /// </summary>
    public bool isPlayer
    {
        get { return _isPlayer; }
        set
        {
            if (_isPlayer != value)
            {
                ISPlayer = value;
                _isPlayer = value;
                OnActivationIsPlayer?.Invoke(_isPlayer);
            }
        }
    }
    public bool ISPlayer;
    public event System.Action<bool> OnActivationIsPlayer;
    private bool _isPlayer = false;


    // 布尔值变化时触发的事件
    public event System.Action<bool> OnActivationChanged;


    private bool _isStartRehearsing = false;
    // 属性绑定布尔值，并在值变化时触发事件
    public bool isStartRehearsing
    {
        get { return _isStartRehearsing; }
        set
        {
            if (_isStartRehearsing != value)
            {
                _isStartRehearsing = value;
                OnActivationChanged?.Invoke(_isStartRehearsing);
            }
        }
    }
    /// <summary>
    /// 爆炸预制体
    /// </summary>
    public GameObject explodePrefab;

    public UnityAction<string> onDeviceDelete;

    void Awake()
    {
        equipmentCommon = GetComponent<EquipmentCommon>();
        DeviceManager.Instance.devices.Add(this);
        // 订阅布尔值变化事件
        OnActivationChanged += OnActivationChangedHandler;
        //
        OnActivationIsPlayer += OnActivationChangedIsPlayer;
    }
    void Start()
    {
        _isStartRehearsing = GlobalFlag.isStartRehearsing;
    }


    void OnActivationChangedIsPlayer(bool newValue)
    {
        if (newValue && equipmentType == "蜂群无人机")
        {

        }
    }
    /// <summary>
    /// 导条 暂停开始控制
    /// </summary>
    /// <param name="newValue"></param>
    void OnActivationChangedHandler(bool newValue)
    {
        switch (equipmentType)
        {
            case "激光火控平台":
                LaserFireControlPlatformManger laserFireControlPlatformManger = GetComponent<LaserFireControlPlatformManger>();
                laserFireControlPlatformManger.isStartRehearsing = isStartRehearsing;
                break;
            case "探测雷达":
                RadarManger radarManger = GetComponent<RadarManger>();
                radarManger.isStartRehearsing = isStartRehearsing;
                break;
            case "地面无线电干扰":
                TerrestrialRadioInterferenceManger terrestrialRadioInterferenceManger = GetComponent<TerrestrialRadioInterferenceManger>();
                terrestrialRadioInterferenceManger.isStartRehearsing = isStartRehearsing;
                break;
            case "蜂群无人机":
                UnmannedAerialVehicleManage unmannedAerialVehicleManage = GetComponent<UnmannedAerialVehicleManage>();
                unmannedAerialVehicleManage.isStartRehearsing = isStartRehearsing;
                break;
            case "频谱探测":
                Spectrumdetection spectrumdetection = GetComponent<Spectrumdetection>();
                spectrumdetection.isStartRehearsing = isStartRehearsing;
                break;
            case "微波武器":
                Microwaveweapon microwaveweapon = GetComponent<Microwaveweapon>();
                microwaveweapon.isStartRehearsing = isStartRehearsing;
                break;
            default:
                break;
        }
    }

    //参数：action：updatepracticedevicedetail
    //参数：id：设备id
    //参数：bdxx：部队信息
    //参数：line：线路
    //参数：my_rate：自身频率
    //参数：scan_rate：扫描频率

    /// <summary>
    /// 修改数据库单个信息
    /// </summary>
    /// <param name="attribute"></param>
    /// <param name="newInfo"></param>
    public void SetDatabaseInfo(string attribute, string newInfo)
    {
        Dictionary<string, string> replaceInfoDic = new Dictionary<string, string>();
        replaceInfoDic.Add("id", deviceID);
        replaceInfoDic.Add(attribute, newInfo);
        StartCoroutine(AsyncWebReq.PostData2(Url_UpdatePracticeDevicedetail, replaceInfoDic));
    }

    /// <summary>
    /// 物体生成时接受数据
    /// </summary>
    /// <param name="weaponitemone"></param>
    public void FillInTheData(List<List_paraItem> weaponitemone, AdamThinkDevicesData.DataItem data)
    {
        //向其他的单位发送创建信息
        if (isPlayer && equipmentCommon)//但是是由我自主创建的时候发送一次 且只发送一次
        {
            Dictionary<string, string> replaceInfoDic = new Dictionary<string, string>();
            string paraListJson = JsonConvert.SerializeObject(weaponitemone);
            replaceInfoDic.Add("PracticeId", GlobalFlag.roomID);
            Debug.Log(GlobalFlag.roomID);
            replaceInfoDic.Add("PracticeSubjectId", GlobalFlag.practiceSubjectID);
            replaceInfoDic.Add("device_name", equipmentCommon.equipmentType);
            replaceInfoDic.Add("para_list", paraListJson);
            replaceInfoDic.Add("r1", $"{transform.position.x},{transform.position.y},{transform.position.z},{transform.eulerAngles.x},{transform.eulerAngles.y},{transform.eulerAngles.z}");
            if (gameObject.GetComponent<UnmannedAerialVehicleManage>())
            {
                replaceInfoDic.Add("r2", ((int)gameObject.GetComponent<UnmannedAerialVehicleManage>().wrjModel).ToString());
                replaceInfoDic.Add("bdxx", gameObject.GetComponent<UnmannedAerialVehicleManage>().groupId.ToString());
            }
            replaceInfoDic.Add("r3", GlobalFlag.currentUser.user_id);
            StartCoroutine(AsyncWebReq.PostData2(Url_AddDeviceAndGetDeviceId, replaceInfoDic, ResultsInfo =>
            {
                ReturnDeviceID returnID = JsonConvert.DeserializeObject<ReturnDeviceID>(ResultsInfo);
                deviceID = returnID.data;
                string msg = $"send2room {equipmentCommon.equipmentType},{transform.position.ToString().Replace(" ", "").Replace("(", "").Replace(")", "")},{transform.eulerAngles.ToString().Replace(" ", "").Replace("(", "").Replace(")", "") + "," + deviceID}";
                _ = SyncCreateRoom.SendMessageAsync(msg);
                UploadLog(deviceID);
            }));
        }
        if (data.my_rate != null && data.my_rate != "")
        {
            weaponitemone = Weaponitemone(data);
        }


        //填入数据
        switch (equipmentType)
        {
            case "激光火控平台":
                LaserFireControlPlatformManger laserFireControlPlatformManger = GetComponent<LaserFireControlPlatformManger>();
                laserFireControlPlatformManger.FillInTheData(weaponitemone);
                //laserFireControlPlatformManger.isStartRehearsing = isStartRehearsing;
                break;
            case "探测雷达":
                RadarManger radarManger = GetComponent<RadarManger>();
                radarManger.FillInTheData(weaponitemone);
                radarManger.isStartRehearsing = isStartRehearsing;
                break;
            case "地面无线电干扰":
                TerrestrialRadioInterferenceManger terrestrialRadioInterferenceManger = GetComponent<TerrestrialRadioInterferenceManger>();
                terrestrialRadioInterferenceManger.FillInTheData(weaponitemone, deviceID);
                terrestrialRadioInterferenceManger.isStartRehearsing = isStartRehearsing;

                break;
            case "蜂群无人机":
                UnmannedAerialVehicleManage unmannedAerialVehicleManage = GetComponent<UnmannedAerialVehicleManage>();
                unmannedAerialVehicleManage.MatrixFormation(30, 1);
                unmannedAerialVehicleManage.FillInTheData(weaponitemone, deviceID);
                unmannedAerialVehicleManage.isStartRehearsing = isStartRehearsing;
                DroneViewDisplay.Instance.CreateUI(unmannedAerialVehicleManage, false);

                break;
            case "频谱探测":
                Spectrumdetection spectrumdetection = GetComponent<Spectrumdetection>();
                spectrumdetection.FillInTheData(weaponitemone);
                spectrumdetection.isStartRehearsing = isStartRehearsing;
                break;
            case "微波武器":
                Microwaveweapon microwaveweapon = GetComponent<Microwaveweapon>();
                microwaveweapon.FillInTheData(weaponitemone);
                microwaveweapon.isStartRehearsing = isStartRehearsing;
                break;
            default:
                break;
        }

    }

    /// <summary>
    /// 
    /// </summary>
    /// <param name="weaponitemone"></param>
    /// <returns></returns>
    public List<List_paraItem> Weaponitemone(AdamThinkDevicesData.DataItem data)
    {
        List<List_paraItem> _weaponitemone = data.list_para;

        return _weaponitemone;
    }

    /// <summary>
    ///上传日志
    /// </summary>
    /// <param name="deviceID"></param>
    public void UploadLog(string deviceID)
    {
        string currentTime = System.DateTime.Now.ToString();
        List<UploadLogMain> uploadLogMains = new List<UploadLogMain>();
        UploadLogMain uploadLogMain = new UploadLogMain();
        uploadLogMain.PracticeId = GlobalFlag.practiceSubjectID;
        uploadLogMain.ThinkId = GlobalFlag.currentThinkId;
        string log = currentTime + "  " + equipmentType + "(" + deviceID + ")" + "生成 ";
        uploadLogMain.log = log;
        uploadLogMains.Add(uploadLogMain);
        string uploadLogMainJson = JsonConvert.SerializeObject(uploadLogMains);
        WWWForm wWWForm = new WWWForm();
        wWWForm.AddField("data", uploadLogMainJson);
        StartCoroutine(PostString(Url_Addpracticelog, wWWForm, data =>
        {
            //Debug.Log(data);
        }));
    }


    /// <summary>
    /// 已有路径
    /// </summary>
    public Queue<Vector3> positions = new Queue<Vector3>();
    private void Update()
    {
        StartMoveObjectAlongPath();
    }

    public bool isMove = true;
    /// <summary>
    /// 按规划路径开始移动
    /// </summary>
    public void StartMoveObjectAlongPath()
    {
        if (isMove && positions.Count > 0)
        {
            isMove = false;
            Vector3 _positions = positions.Dequeue();
            UnmannedAerialVehicleManage unmannedAerialVehicleManage = GetComponent<UnmannedAerialVehicleManage>();
            if (unmannedAerialVehicleManage)
                StartCoroutine(unmannedAerialVehicleManage.MoveObjectAlongPath(_positions, true)); // 启动协程，按规划的路线移动物体
        }
    }




    /// <summary>
    /// 设备交互同步消息接收
    /// </summary>
    /// <param name="data"></param>
    public void ReceivingPositionAngle(string[] data)
    {
        switch (data[0])
        {
            case "DronePosition"://无人机位置信息传递
                if (!isPlayer)
                {
                    Vector3 pos = new Vector3(float.Parse(data[2]), float.Parse(data[3]), float.Parse(data[4]));
                    positions.Enqueue(pos);
                }
                    
                break;
            case "Lasing"://
                if (!isPlayer)
                {
                    LaserFireControlPlatformManger laserFireControlPlatformManger = GetComponent<LaserFireControlPlatformManger>();
                    if (laserFireControlPlatformManger)
                        laserFireControlPlatformManger.NonSelfGeneratedEmissionLaser(data);
                }
               
                break;
            case "Micow"://微波武器发射位置
                if (!isPlayer) {
                    Microwaveweapon microwaveweapon = GetComponent<Microwaveweapon>();
                    if (microwaveweapon)
                    {
                        microwaveweapon.Microwavetransmission(data);
                    }
                }
                break;
            case "SingleDronePosition"://无人机攻击目标锁定
                Debug.Log("接受...:" + data[0] + "," + data[1] + "," + data[2] + "," + data[3] + "," + data[4]);
                UnmannedAerialVehicleManage unmannedAerialVehicleManage = GetComponent<UnmannedAerialVehicleManage>();
                if (unmannedAerialVehicleManage && unmannedAerialVehicleManage.wrjModel == WRJModel.自杀式无人机)
                {
                    for (int i = 0; i < unmannedAerialVehicleManage.unmannedAerialVehicles.Count; i++)
                    {
                        if (unmannedAerialVehicleManage.unmannedAerialVehicles[i])
                        {
                            Vector3 Pos = new Vector3(float.Parse(data[2]), float.Parse(data[3]), float.Parse(data[4]));
                            unmannedAerialVehicleManage.unmannedAerialVehicles[i].AttAck(Pos);
                        }
                    }
                }
                break;

            case "WRJExpel"://驱离无人机
                UnmannedAerialVehicleManage unmannedAerialVehicleManageExpel = GetComponent<UnmannedAerialVehicleManage>();
                if (unmannedAerialVehicleManageExpel)
                {
                    unmannedAerialVehicleManageExpel.CheckSatellitePositioningFrequency(data[2]);
                }
                break;
            case "DroneWasDestroyed"://单个无人机被销毁
                UnmannedAerialVehicleManage _unmannedAerialVehicleManage = GetComponent<UnmannedAerialVehicleManage>();
                if (_unmannedAerialVehicleManage)
                {
                    UnmannedAerialVehicle unmannedAerialVehicle = _unmannedAerialVehicleManage.unmannedAerialVehicles.Find(x => x.serialNumber == data[2]);
                    if (unmannedAerialVehicle)
                    {
                        unmannedAerialVehicle.AddBao(false);
                    }
                }
                break;
            case "WRJDitch"://无线电干扰无人机同步
                UnmannedAerialVehicleManage _unmannedAerialVehicleManageDitch = GetComponent<UnmannedAerialVehicleManage>();
                if (_unmannedAerialVehicleManageDitch)
                {
                    UnmannedAerialVehicle unmannedAerialVehicle = _unmannedAerialVehicleManageDitch.unmannedAerialVehicles.Find(x => x.serialNumber == data[2]);
                    if (unmannedAerialVehicle)
                    {
                        unmannedAerialVehicle.CheckSatellitePositioningFrequency(data[3]);
                    }
                }
                break;
            case "Planedata"://微波武器消灭无人机
                UnmannedAerialVehicleManage unmannedAerialVehicleManage1 = GetComponent<UnmannedAerialVehicleManage>();
                if (unmannedAerialVehicleManage1)
                {
                    UnmannedAerialVehicle unmannedAerialVehicle = unmannedAerialVehicleManage1.unmannedAerialVehicles.Find(x => x.serialNumber == data[2]);
                    if (unmannedAerialVehicle)
                    {
                        StartCoroutine(UnmannedAerialVehicleAddBao(unmannedAerialVehicle));
                    }
                }
                break;
            case "SetToBeDestroyed"://设备被销毁
                onDeviceDelete?.Invoke(deviceID);
                DroneViewDisplay.Instance.DistroyUI(deviceID);
                GameObject Bao = Instantiate(explodePrefab, transform);
                Bao.transform.localPosition = Vector3.zero;
                Bao.transform.SetParent(null);
                Bao.SetActive(true);
                Destroy(transform.gameObject);
                break;
            case "SetToBeDestroyedTwo"://设备被收回
                onDeviceDelete?.Invoke(deviceID);
                Destroy(transform.gameObject);
                break;
            case "Teleportation":
                Vector3 pos1 = new Vector3(float.Parse(data[2]), float.Parse(data[3]), float.Parse(data[4]));
                transform.position = pos1;
                break;
            default:
                break;
        }
    }

    IEnumerator UnmannedAerialVehicleAddBao(UnmannedAerialVehicle unmannedAerialVehicle)
    {
        yield return new WaitForSeconds(0.6f);
        unmannedAerialVehicle.AddBao(false);
    }

    private void OnDestroy()
    {
        // 订阅布尔值变化事件
        OnActivationChanged -= OnActivationChangedHandler;
        //
        OnActivationIsPlayer -= OnActivationChangedIsPlayer;
    }
}

public enum SelectedSide
{
    Rad,
    Blue,
    Director,
    Other
}