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

/// <summary>
/// 地面无线电干扰控制
/// </summary>
public class TerrestrialRadioInterferenceManger : MonoBehaviour
{

    public EquipmentCommon equipmentCommon;


    #region  地面无线电干扰数据
    /// <summary>
    /// 干扰频率
    /// </summary>
    public string InterferingFrequency;
    /// <summary>
    /// 干扰模式
    /// </summary>
    public string InterferenceMode;
    /// <summary>
    /// 发射功率
    /// </summary>
    public string TransmittedPower;
    /// <summary>
    /// 干扰角度
    /// </summary>
    public string InterferenceAngle;
    /// <summary>
    /// 干扰距离
    /// </summary>
    public string InterferenceDistance;

    #endregion

    public float detectionRadius = 5f; // 检测范围半径

    #region  启动暂停
    private bool _isStartRehearsing = false;
    /// <summary>
    /// 是否正在预演
    /// </summary>
    public bool isStartRehearsing
    {
        get { return _isStartRehearsing; }
        set
        {
            if (_isStartRehearsing != value)
            {
                _isStartRehearsing = value;
                OnActivationChanged?.Invoke(_isStartRehearsing);
            }
        }
    }
    /// <summary>
    /// 布尔值变化时触发的事件
    /// </summary>
    public event System.Action<bool> OnActivationChanged;
    /// <summary>
    /// 协程对象
    /// </summary>
    private Coroutine timerCoroutine;
    /// <summary>
    /// 定时器运行状态
    /// </summary>
    private bool isTimerRunning = false;
    /// <summary>
    /// 间隔时间
    /// </summary>
    public float interval = 5.0f;
    #endregion

    /// <summary>
    /// 爆炸预制体
    /// </summary>
    public GameObject explodePrefab;
    /// <summary>
    /// 飞机迫降的速度
    /// </summary>
    public float speed = 1;
    /// <summary>
    /// 地面的图层
    /// </summary>
    public LayerMask ground;
    /// <summary>
    /// 驱离返回坐标
    /// </summary>
    [SerializeField]
    public Transform backtransform;

    void Start()
    {
        equipmentCommon = GetComponent<EquipmentCommon>();
        // 订阅布尔值变化事件
        OnActivationChanged += OnActivationChangedHandler;
    }

    // Update is called once per frame
    void Update()
    {
        if (unmannedAerialVehicles.Count > 0 && isDo)
        {
            isDo = false;
            UnmannedAerialVehicle unmannedAerialVehicle = unmannedAerialVehicles.Dequeue();
            Vector3 _pos = unmannedAerialVehicle.transform.position - new Vector3(0, 50, 0);
            unmannedAerialVehicle.transform.LookAt(_pos);
            unmannedAerialVehicle.transform.DOMove(_pos, 1).OnComplete(() =>
            {
                AddBao(unmannedAerialVehicle);
            });
        }
        //Interferencemode();
        //Angularrange();
    }
    void LateUpdate()
    {
        Interferencemode();
    }
    #region  启动暂停
    /// <summary>
    /// 导条变化调用
    /// </summary>
    /// <param name="newValue"></param>
    void OnActivationChangedHandler(bool newValue)
    {
        if (newValue)
        {
            StartTimer();
        }
        else
        {
            StopTimer();
        }
    }


    IEnumerator Timer()
    {
        while (true)
        {
            //Debug.Log("Timer fired at: " + Time.time);
            yield return new WaitForSeconds(0.5f); // 等待一段时间后继续执行
            RadioDisturbance();
            //Interferencemode();
        }
    }

    /// <summary>
    /// 开启
    /// </summary>
    public void StartTimer()
    {
        if (equipmentCommon.isPlayer && timerCoroutine == null)
        {
            timerCoroutine = StartCoroutine(Timer());
            isTimerRunning = true;
        }
    }
    /// <summary>
    /// 停止
    /// </summary>
    public void StopTimer()
    {
        if (equipmentCommon.isPlayer && timerCoroutine != null)
        {
            StopCoroutine(timerCoroutine);
            timerCoroutine = null;
            isTimerRunning = false;
        }
    }
    #endregion

    /// <summary>
    /// 数据写入
    /// </summary>
    /// <param name="weaponitemone"></param>
    public void FillInTheData(List<List_paraItem> weaponitemone)
    {
        //if (equipmentCommon)
        //{
        //string msg = $"send2room {equipmentCommon.equipmentType}+{transform.position.ToString().Replace(" ", "").Replace("(", "").Replace(")", "")}+{transform.eulerAngles.ToString().Replace(" ", "").Replace("(", "").Replace(")", "")}";
        //Debug.Log(msg);
        //_ = SyncCreateRoom.SendMessageAsync(msg);
        //}
        for (int i = 0; i < weaponitemone.Count; i++)
        {
            switch (weaponitemone[i].para_name)
            {
                case "干扰频率:":
                    switch (weaponitemone[i].para_value)
                    {
                        case "0":
                            InterferingFrequency = "1227.60 MHz";
                            break;
                        case "1":
                            InterferingFrequency = "1575.42 MHz";
                            break;
                        case "2":
                            InterferingFrequency = "1381.05 MHz";
                            break;
                        case "3":
                            InterferingFrequency = "2GHz";
                            break;
                        case "4":
                            InterferingFrequency = "4GHz";
                            break;
                        case "5":
                            InterferingFrequency = "5GHz";
                            break;
                        default:
                            break;
                    }
                    //interval= float.Parse(InterferingFrequency);
                    break;
                case "干扰模式:":
                    Debug.LogError(weaponitemone[i].para_value);
                    switch (weaponitemone[i].para_value)
                    {
                        case "0":
                            InterferenceMode = "驱离";
                            break;
                        case "1":
                            InterferenceMode = "迫降";
                            break;
                        default:
                            break;
                    }
                    //InterferenceMode = weaponitemone[i].para_value;
                    break;
                case "发射功率:":
                    //TransmittedPower = weaponitemone[i].para_value;
                    Debug.LogError(weaponitemone[i].para_value);
                    switch (weaponitemone[i].para_value)
                    {
                        case "0":
                            TransmittedPower = "10~30W";
                            break;
                        case "1":
                            TransmittedPower = "30~50W";
                            break;
                        case "2":
                            TransmittedPower = "50~100W";
                            break;
                        default:
                            break;
                    }
                    break;
                case "干扰角度:":
                    Debug.LogError(weaponitemone[i].para_value);
                    InterferenceAngle = weaponitemone[i].para_value;
                    break;
                case "干扰距离:":
                    InterferenceDistance = weaponitemone[i].para_value;
                    detectionRadius = float.Parse(InterferenceDistance);
                    break;
                default:
                    break;
            }
        }
    }


    /// <summary>
    /// 干扰模式
    /// </summary>
    public void Interferencemode()
    {
        Collider[] colliders = Physics.OverlapSphere(transform.position, detectionRadius * 100);//检索范围
        for (int i = 0; i < colliders.Length; i++)
        {
            if (colliders[i].transform.tag == "WRJ")
            {
                UnmannedAerialVehicle unmannedAerialVehicle = null;
                if (colliders[i].GetComponent<UnmannedAerialVehicle>())
                {
                    unmannedAerialVehicle = colliders[i].GetComponent<UnmannedAerialVehicle>();
                }
                UnmannedAerialVehicleManage unmannedAerialVehicleManage = null;
                if (colliders[i].GetComponent<UnmannedAerialVehicleManage>())
                {
                    unmannedAerialVehicleManage = colliders[i].GetComponent<UnmannedAerialVehicleManage>();
                }
                if (TransmittedPower == "10~30W" || TransmittedPower == "30~50W" && unmannedAerialVehicleManage != null)
                {
                    Debug.LogError("发射功率进来了1");
                    Debug.LogError(unmannedAerialVehicleManage.satellitePositioningFrequency);
                    Debug.LogError(InterferingFrequency);
                    if (unmannedAerialVehicleManage.satellitePositioningFrequency == InterferingFrequency && unmannedAerialVehicleManage != null)
                    {
                        Debug.LogError("相同频率进来了1");
                        Debug.LogError(InterferenceMode);
                        Debug.LogError(unmannedAerialVehicleManage != null);

                        if (InterferenceMode == "驱离" && unmannedAerialVehicleManage != null)
                        {
                            Debug.LogError("驱离");
                            //unmannedAerialVehicle.transform.DOKill();
                            //Vector3 trans = unmannedAerialVehicleManage.transform.position;
                            //unmannedAerialVehicleManage.modeSwitch(0);
                            unmannedAerialVehicleManage.transform.DOKill();
                            unmannedAerialVehicleManage.transform.LookAt(new Vector3(-500, 160, 1650));
                            unmannedAerialVehicleManage.transform.DOMove(new Vector3(-500, 160, 1650), 60);
                            //unmannedAerialVehicle.transform.DOKill();
                            //Debug.LogError(unmannedAerialVehicle.name);
                            //unmannedAerialVehicle.transform.parent = null;
                            //unmannedAerialVehicle.transform.Translate(Vector3.forward * speed * Time.deltaTime);
                            //unmannedAerialVehicleManage.transform.position = trans;
                            //unmannedAerialVehicleManage.transform.position = Vector3.Lerp(unmannedAerialVehicleManage.transform.position, new Vector3(-500, 160, 1650), speed * Time.deltaTime);
                            ////unmannedAerialVehicle.transform.position = Vector3.Lerp(unmannedAerialVehicle.transform.position, new Vector3(-500, 160, 1650), speed * Time.deltaTime);
                        }
                        else if (InterferenceMode == "迫降" && unmannedAerialVehicleManage != null)
                        {
                            Debug.LogError("迫降");
                            unmannedAerialVehicleManage.transform.DOKill();
                            //unmannedAerialVehicle.transform.DOKill();
                            //Debug.LogError(unmannedAerialVehicle.name);
                            RaycastHit hit;
                            if (Physics.Raycast(unmannedAerialVehicleManage.transform.position, Vector3.down, out hit, Mathf.Infinity, ground))
                            {
                                if (hit.distance > 1f)
                                {
                                    Debug.LogError(hit.distance);
                                    //unmannedAerialVehicle.transform.parent = null;
                                    //unmannedAerialVehicleManage.transform.Translate(Vector3.down * speed * Time.deltaTime);
                                    hit.point = new Vector3(hit.point.x, hit.point.y + 3, hit.point.z);
                                    //unmannedAerialVehicleManage.transform.LookAt(hit.point);
                                    unmannedAerialVehicleManage.transform.DOMove(hit.point, 6);
                                    //unmannedAerialVehicleManage.transform.position = Vector3.Lerp(unmannedAerialVehicleManage.transform.position, hit.point, speed * Time.deltaTime);
                                }
                                else
                                {
                                    speed = 0;
                                }
                            }
                        }
                        else
                        {
                            Debug.LogError("进攻");
                        }
                    }
                }
                if (TransmittedPower == "50~100W" && unmannedAerialVehicleManage != null)
                {
                    Debug.LogError("功率进来了2");
                    if (unmannedAerialVehicleManage.dataLinkCommunicationFrequency == InterferingFrequency && unmannedAerialVehicleManage != null)
                    {
                        Debug.LogError("频率进来了");
                        if (unmannedAerialVehicleManage != null)
                        {
                            Vector3 one = unmannedAerialVehicleManage.transform.position - transform.position;
                            float angue = Vector3.Angle(transform.forward, one);
                            if (float.Parse(InterferenceAngle) >= angue)
                            {
                                //unmannedAerialVehicleManage.transform.DOKill();
                                Debug.LogError("目标出现在范围内");
                                Debug.LogError(unmannedAerialVehicleManage.maximumFlyingSpeed);
                                unmannedAerialVehicleManage.maximumFlyingSpeed = (float.Parse(unmannedAerialVehicleManage.maximumFlyingSpeed) - 5).ToString();
                                Debug.LogError(unmannedAerialVehicleManage.maximumFlyingSpeed);
                            }
                            else
                            {
                                //unmannedAerialVehicle.transform.DOKill();
                                Debug.LogError("目标没有出现在范围里面");

                            }
                        }
                    }
                }
            }
        }
    }
    /// <summary>
    /// 干扰无人机角度范围
    /// </summary>
    /// <exception cref="NotImplementedException"></exception>
    private void Angularrange()
    {
        Collider[] collider = Physics.OverlapSphere(transform.position, 300);
        for (int i = 0; i < collider.Length; i++)
        {
            if (collider[i].transform.tag == "WRJ")
            {
                UnmannedAerialVehicle unmannedAerialVehicle = collider[i].GetComponent<UnmannedAerialVehicle>();
                Vector3 one = unmannedAerialVehicle.transform.position - transform.position;
                float angue = Vector3.Angle(transform.forward, one);
                if (float.Parse(InterferenceAngle) >= angue)
                {
                    Debug.LogError("目标出现在范围内");

                }
                else
                {
                    Debug.LogError("目标没有出现在范围里面");

                }
            }
        }
    }
    /// <summary>
    /// 开启无线电干扰
    /// </summary>
    public void RadioDisturbance()
    {
        Collider[] colliders = Physics.OverlapSphere(transform.position, detectionRadius); // 检索范围内的所有碰撞体

        for (int i = 0; i < colliders.Length; i++)
        {
            if (colliders[i].transform.tag == "WRJ")
            {
                //Debug.Log("检测到无人机: " + col.name);
                UnmannedAerialVehicle unmannedAerialVehicle = colliders[i].GetComponent<UnmannedAerialVehicle>();
                if (unmannedAerialVehicle)
                {
                    //Debug.Log(col.name+"数据链通信频点...:" + unmannedAerialVehicle.dataLinkCommunicationFrequency);
                    if (unmannedAerialVehicle.dataLinkCommunicationFrequency == "" || InterferingFrequency == "") continue;//无数据不执行
                    if (unmannedAerialVehicle.dataLinkCommunicationFrequency == InterferingFrequency)
                    {
                        Debug.Log("干扰...:" + colliders[i].name + "成功。");
                        //unmannedAerialVehicle.BeAssaulted("无线电干扰");
                        unmannedAerialVehicles.Enqueue(unmannedAerialVehicle);
                    }

                }
            }
        }
    }

    Queue<UnmannedAerialVehicle> unmannedAerialVehicles = new Queue<UnmannedAerialVehicle>();

    private bool isDo = true;
    /// <summary>
    /// 销毁单体无人机
    /// </summary>
    public void AddBao(UnmannedAerialVehicle unmannedAerialVehicle)
    {
        string nowData = GetSyncDis(unmannedAerialVehicle);
        Debug.Log(nowData);
        DeviceManager.Instance.send2roomStr.Enqueue(nowData);
        string currentTime = System.DateTime.Now.ToString();
        string _log = currentTime + "  " + equipmentCommon.equipmentType + "(" + equipmentCommon.deviceID + ")" +
            "攻击了销毁了" + unmannedAerialVehicle.unmannedAerialVehicleManage.equipmentCommon.equipmentType + "(" + unmannedAerialVehicle.unmannedAerialVehicleManage.equipmentCommon.deviceID + ")"
               + "编号" + unmannedAerialVehicle.serialNumber + "子无人机";
        UploadLog(_log);
        GameObject Bao = Instantiate(explodePrefab, unmannedAerialVehicle.transform);
        Bao.transform.localPosition = Vector3.zero;
        Bao.transform.SetParent(null);
        Bao.SetActive(true);
        Destroy(unmannedAerialVehicle.gameObject);
        isDo = true;
    }

    /// <summary>
    ///上传日志
    /// </summary>
    /// <param name="deviceID"></param>
    public void UploadLog(string _log)
    {

        List<UploadLogMain> uploadLogMains = new List<UploadLogMain>();
        UploadLogMain uploadLogMain = new UploadLogMain();
        uploadLogMain.PracticeId = GlobalFlag.practiceSubjectID;
        uploadLogMain.ThinkId = GlobalFlag.currentThinkId;
        uploadLogMain.log = _log;
        uploadLogMains.Add(uploadLogMain);
        string uploadLogMainJson = JsonConvert.SerializeObject(uploadLogMains);
        WWWForm wWWForm = new WWWForm();
        wWWForm.AddField("data", uploadLogMainJson);
        Debug.Log(uploadLogMainJson);
        StartCoroutine(PostString(Url_Addpracticelog, wWWForm, data =>
        {
            Debug.Log(data);
        }));
    }

    /// <summary>
    /// 单个无人机被销毁
    /// </summary>
    /// <returns></returns>
    protected string GetSyncDis(UnmannedAerialVehicle unmannedAerialVehicle)
    {
        return string.Format("{0},{1},{2}", "DroneWasDestroyed", unmannedAerialVehicle.unmannedAerialVehicleManage.equipmentCommon.deviceID, unmannedAerialVehicle.serialNumber);
    }

    private void OnDestroy()
    {
        OnActivationChanged -= OnActivationChangedHandler;
    }
}