using System.Collections;
using System.Collections.Generic;
using InfraredManager;
using o0InfraredLocate.ZIM;
using SLAMUVC;
using SmartBowSDK;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using ZIM;
using static ScreenLocate;

namespace InfraredDLLManager
{
    [RequireComponent(typeof(BLEManager))]
    public class UIManager : MonoBehaviour
    {

        [Header("蓝牙操作")]
        //连接弓箭按钮
        public Button mConnectBow1P;
        private Text mConnectBowText1P;
        //连接弓箭按钮
        public Button mConnectBow2P;
        private Text mConnectBowText2P;
        //滚动的日志
        public GameObject logObj;
        public Text mScrollViewLogTextBow;
        private int bowLogTextCount = 0;

        //清空日志按钮
        public Button mClearLogBow;
        public Button mControlLogBtn;

        [Header("操作")]


        public Toggle mToggleSinglePoint;

        public Toggle mToggleSinglePointColorRed;

        public Toggle mToggleSinglePointColorGreen;
        //是否设置红色光标识别最大点
        bool bIdentifyRed = true;

        public Text PosInfo;

        #region 需要隐藏的面板节点
        [Header("面板节点")]
        public GameObject[] uiArray;
        public bool bGetPanelActive
        {
            get
            {
                return bPanelActive;
            }
        }
        bool bPanelActive = true;
        #endregion

        //图片数据
        public RawImage rawImage;

        public Transform webCameraViewParent;

        public GameObject loadingPanel;

        //关联的蓝牙脚本
        BLEManager bleManager;

        public BLEManager myBleManager
        {
            get { return bleManager; }
        }

        #region 定位相关参数
        //线段宽度阈值
        public ParamFloatValue lineWidth = new ParamFloatValue("ic_lineWidth", 4.0f);
        //扇形宽度
        public ParamFloatValue fanWidth = new ParamFloatValue("ic_fanWidth", 90.0f);

        public ParamFloatValue captureValue = new ParamFloatValue("ic_captureValue", 30.0f);
        public ParamFloatValue delayValue = new ParamFloatValue("ic_delayValue", 30.0f);

        #endregion

        #region 算法部分接口使用
        InfraredCameraHelper ICHelper;

        [SerializeField] List<RectTransform> _crosshairsInCamera;
        #endregion

        #region 单例
        private static UIManager _Instance;
        public static UIManager GetInstance()
        {
            return _Instance;
        }
        #endregion

        #region 画线
        [Header("画线")]
        [SerializeField] LineGenerator CurUILineGenerator;//当前结果屏幕线条
        #endregion

        void Awake()
        {
            loadingPanel.gameObject.SetActive(true);

            _Instance = this;
            bleManager = GetComponent<BLEManager>();
            if (bleManager) bleManager.OnLogAction += SetLogText;

            Debug.Log("InitInfraredCamera！");
            InitInfraredCamera();
            InitReturnLogReporter();

            SceneManager.sceneLoaded += OnSceneLoaded;

        }

        // Start is called before the first frame update
        void Start()
        {

            mConnectBow1P.onClick.AddListener(() =>
            {
                if (bleManager) bleManager.ConnectBluetoothDevice(bleManager.MyBowSmartBowHelper);
            });
            mConnectBowText1P = mConnectBow1P.GetComponentInChildren<Text>();

            mConnectBow2P.onClick.AddListener(() =>
            {
                if (bleManager) bleManager.ConnectBluetoothDevice(bleManager.MyBowSmartBowHelper2);
            });
            mConnectBowText2P = mConnectBow2P.GetComponentInChildren<Text>();

            mClearLogBow.onClick.AddListener(clearLogText);
            mControlLogBtn.onClick.AddListener(onControlLog);


            InitOffsetBtns();

        }

        void OnDestroy()
        {
            if (bleManager) bleManager.OnLogAction -= SetLogText;
        }

        // Update is called once per frame
        void Update()
        {
            if (ICHelper == null) return;
            Texture texture = ICHelper.GetCameraTexture();

            if (rawImage.texture == null || texture?.GetNativeTexturePtr() != rawImage.texture.GetNativeTexturePtr())
            {
                rawImage.texture = texture;
            }
            //刷新一个fps
            if (reporter && bleManager)
            {
                //reporter.fps 
                bleManager.SetFPS(reporter.fps);
            }

            //更新ui
            if (bleManager)
            {
                //进入游戏
                if (bleManager.MyBowSmartBowHelper != null)
                {
                    BLEUIStatus(bleManager.MyBowSmartBowHelper, mConnectBow1P, mConnectBowText1P, "1P");

                }
                if (bleManager.MyBowSmartBowHelper2 != null)
                {
                    BLEUIStatus(bleManager.MyBowSmartBowHelper2, mConnectBow2P, mConnectBowText2P, "2P");
                }
            }
        }

        #region 更新蓝牙状态
        /// <summary>
        /// 更新蓝牙连接ui
        /// </summary>
        /// <param name="_smartBowHandler"></param>
        /// <param name="mConnectBow"></param>
        /// <param name="mConnectBowText"></param>
        /// <param name="name"></param>
        public void BLEUIStatus(SmartBowHelper _smartBowHandler, Button mConnectBow, Text mConnectBowText, string name = "1P")
        {
            BluetoothStatusEnum bluetoothStatusEnum = _smartBowHandler.GetBluetoothStatus();
            bool mBowConnected = bluetoothStatusEnum == BluetoothStatusEnum.Connected;
            bool mBowIsConnecting = bluetoothStatusEnum == BluetoothStatusEnum.Connecting;
            if (!mBowConnected && !mBowIsConnecting)
            {
                //未连接，未扫描，不是连接中
                mConnectBowText.text = "连接" + name;
                if (!mConnectBow.interactable)
                    mConnectBow.interactable = true;
            }
            else if (mBowIsConnecting)
            {
                //扫描中
                mConnectBowText.text = "扫描中...";
                if (mConnectBow.interactable)
                    mConnectBow.interactable = false;
            }
            else if (mBowConnected)
            {
                //已连接
                mConnectBowText.text = "已连接";
                if (!mConnectBow.interactable)
                    mConnectBow.interactable = true;
            }
        }
        #endregion


        #region 页面ui控制部分
        public void SetLogText(string text)
        {
            //Debug.Log("SetLogText:" + text);
            if (bowLogTextCount > 200)
            {
                clearLogText();
            }
            mScrollViewLogTextBow.text += text + "\n";
            bowLogTextCount++;


        }
        public void clearLogText()
        {
            mScrollViewLogTextBow.text = "";
            bowLogTextCount = 0;
        }

        public void onControlLog()
        {
            logObj.SetActive(!logObj.activeSelf);
        }



  

        // 当场景加载完成时调用的方法
        void OnSceneLoaded(Scene scene, LoadSceneMode mode)
        {
            // 执行加载完成后的操作
            Debug.Log("场景加载完成: " + scene.name);
            if (scene.name == "InfraredGameDouble" || scene.name == "InfraredGameSingle")
            {
                hideManager();
            }
        }

        /// <summary>
        /// 设置单点模式
        /// </summary>
        public void onToggleSinglePoint()
        {
            //Debug.Log("mToggleSinglePoint.isOn:" + mToggleSinglePoint.isOn);
            if (mToggleSinglePoint.isOn)
            {
                ICHelper.SetSinglePoint(true);

                bIdentifyRed = true;
                mToggleSinglePointColorRed.isOn = true;
                mToggleSinglePointColorRed.interactable = false;
                mToggleSinglePointColorGreen.isOn = false;
                mToggleSinglePointColorGreen.interactable = false;

                _infraredOffsetText.text = "单点-1P全屏中心点校准";

                _infraredOffsetBtn2P.interactable = false;
            }
            else
            {
                ICHelper.SetSinglePoint(false);
                mToggleSinglePointColorRed.isOn = true;
                mToggleSinglePointColorRed.interactable = true;
                mToggleSinglePointColorGreen.interactable = true;

                _infraredOffsetText.text = "1P左半屏中心校准\n2P是右半屏中心点校准";

                _infraredOffsetBtn2P.interactable = true;
            }
        }
        /// <summary>
        /// 切换颜色状态
        /// </summary>
        public void onToggleSinglePointColorRed()
        {
            // Debug.Log("mToggleSinglePointColorRed.isOn:" + mToggleSinglePointColorRed.isOn);
            if (mToggleSinglePointColorRed.isOn)
            {
                bIdentifyRed = true;
                mToggleSinglePointColorGreen.isOn = false;
            }

        }
        public void onToggleSinglePointColorGreen()
        {
            //Debug.Log("mToggleSinglePointColorGreen.isOn:" + mToggleSinglePointColorGreen.isOn);
            if (mToggleSinglePointColorGreen.isOn)
            {
                bIdentifyRed = false;
                mToggleSinglePointColorRed.isOn = false;
            }
        }

        public void OnClick_ScreenLocateManual()
        {
            GameObject o = ViewManager2.ShowTestInfraredScreenPositioningView(webCameraViewParent);
            InfraredScreenPositioningView _infraredScreenPositioningView = o.GetComponent<InfraredScreenPositioningView>();//FindObjectOfType<InfraredScreenPositioningView>();
            _infraredScreenPositioningView.enterFromInfraredDemo = true;
            _infraredScreenPositioningView.MyUIManager = this;
        }

        //隐藏控制面板UI
        public void hideManager()
        {
            // transform.parent.GetComponent<Canvas>().gameObject.SetActive(false);
            bPanelActive = false;
            for (int i = 0; i < uiArray.Length; i++)
            {
                uiArray[i].SetActive(false);
            }

        }
        //显示控制面板UI
        public void showManager()
        {
            //  transform.parent.GetComponent<Canvas>().gameObject.SetActive(true);
            bPanelActive = true;
            for (int i = 0; i < uiArray.Length; i++)
            {
                uiArray[i].SetActive(true);
            }
        }

        #endregion

        #region 相机初始化部分
        /// <summary>
        /// 初始化相机
        /// </summary>
        void InitInfraredCamera()
        {
            //SDK创建
            if (ICHelper == null)
            {
                ICHelper = InfraredCameraHelper.GetInstance();

#if UNITY_STANDALONE_WIN || UNITY_EDITOR
                ICHelper.CreateToPc();
#endif
#if UNITY_ANDROID
                //开始时候设置一个默认分辨率
                ICHelper.Create(320, 240);
#endif
                //单点情况下更新
                ICHelper.OnPositionUpdate += (Vector2 point, Vector2 cameraLocation) =>
                {
                    HideUICrosshairs(1);
                    Ray ray = Camera.main.ScreenPointToRay(point);
                    Vector3 rayEndPoint = ray.GetPoint(200);
                    Quaternion quat = Quaternion.LookRotation(rayEndPoint - Camera.main.transform.position);
                    //Object localRotation = quat;

                    ShowUICrosshairs(cameraLocation, 0);
                    ShowGameUICrosshairs(point, 0);

                    if (PosInfo) PosInfo.text = "红:" + point.ToString("F2");
                };
                //双点情况下更新
                ICHelper.OnPositionUpdate2 += (Vector2[] points, Vector2[] cameraLocations) =>
                {
                    string _posText = "";
                    HideUICrosshairs(0);
                    HideUICrosshairs(1);
                    float halfScreenWidth = Screen.width / 2f; // 假设为全屏宽度的一半
                    for (int i = 0; i < points.Length; i++)
                    {
                        Vector2 point = points[i];
                        // 判断是否为右屏并调整坐标
                        if (i == 1)
                        {
                            point.x -= halfScreenWidth; // 同步到右屏坐标系
                        }

                        Ray ray = Camera.main.ScreenPointToRay(point);
                        Vector3 rayEndPoint = ray.GetPoint(200);
                        Quaternion quat = Quaternion.LookRotation(rayEndPoint - Camera.main.transform.position);
                        if (i == 0)
                        {
                            //Object1 localRotation = quat;
                            ShowUICrosshairs(cameraLocations[0], 0);
                            ShowGameUICrosshairs(points[0], 0);
                            _posText += "红0:" + points[0].ToString("F2");

                        }
                        if (i == 1)
                        {
                            //Object2 localRotation = quat;

                            ShowUICrosshairs(cameraLocations[1], 1);
                            ShowGameUICrosshairs(points[1], 1);
                            _posText += "\n";
                            _posText += "黄1:" + points[1].ToString("F2");
                        }
                        if (PosInfo) PosInfo.text = _posText;
                    }

                };

                ICHelper.OnUVCIsReady += (UVCManager.CameraInfo camera) =>
                {
                    //生成控制摄像机的参数滑条
                    Debug.Log("初始化摄像机！");
                    //延迟重新设置一次分辨率
                    StartCoroutine(delayInitOhterInfo(camera));

                };

                //屏幕变化时候
                ICHelper.OnUVCPosUpdate += (list) =>
                {
                    Debug.Log("OnUVCPosUpdate list.Count" + list.Count);
                    SetLocatePointsToCameraRender(list, 1, 1);
                    //InfraredScreenPositioningView 页面
                    if (list.Count == 4)
                    {
                        FindObjectOfType<InfraredScreenPositioningView>()?.SyncScreenPosition();
                    }
                    else
                    {
                        FindObjectOfType<InfraredScreenPositioningView>()?.onReset();
                    }
                };
                //算法准备事件
                ICHelper.OnScreenLocateIsReady += () =>
                {
                    Debug.Log("OnScreenLocateIsReady.");

                    //检测红外亮度阈值
                    SetInfraredFilterValue(infraredFileterValue.Get());
                    _infraredFilter.onValueChanged.AddListener(SetInfraredFilterValue);

                    //默认设置双点模式
                    mToggleSinglePoint.isOn = false;
                    onToggleSinglePoint();

                    InitCenterOffsets(PlayerType.FirstPlayer);
                    InitCenterOffsets(PlayerType.SecondPlayer);

                    //读取完成之后
                    loadingPanel.gameObject.SetActive(false);
                };
            }


        }

        /// <summary>
        /// 更新屏幕下的十字准心位置
        /// </summary>
        /// <param name="value"></param>
        void ShowUICrosshairs(Vector2 newPoint2, int index)
        {
            ////获取一个偏移量，使得最后输出的准心是指向正中心
            //Vector2 newPoint2 = value  - ICHelper.GetCenterOffset(value, "CameraLocation");
            // 检测到光点 
            var pos = newPoint2.pixelToLocalPosition_AnchorCenter(ICHelper.GetUVCCameraInfo().Size, rawImage.rectTransform.rect);
            //红色为最大值则按顺序赋值，反之最小
            int curIndex = 0;
            if (bIdentifyRed)
            {
                curIndex = index;
            }
            else
            {
                curIndex = 1 - index;
            }
            _crosshairsInCamera[curIndex].gameObject.SetActive(true);
            _crosshairsInCamera[curIndex].anchoredPosition = pos;


        }
        /// <summary>
        /// 直接更新全屏UI位置
        /// </summary>
        /// <param name="newPoint2"></param>
        /// <param name="index"></param>
        void ShowGameUICrosshairs(Vector2 newPoint2, int index)
        {
            //红色为最大值则按顺序赋值，反之最小
            int curIndex = 0;
            if (bIdentifyRed)
            {
                curIndex = index;
            }
            else
            {
                curIndex = 1 - index;
            }
            //todo 游戏里面ui show index
      
        }
        void HideUICrosshairs(int index)
        {
            if (bIdentifyRed)
            {
                _crosshairsInCamera[index].gameObject.SetActive(false);
            }
            else
            {
                _crosshairsInCamera[1 - index].gameObject.SetActive(false);
            }
        }

        /// <summary>
        /// 初始化一些游戏配置
        /// </summary>
        /// <returns></returns>
        IEnumerator delayInitOhterInfo(UVCManager.CameraInfo camera)
        {
            yield return new WaitForEndOfFrame();
#if UNITY_ANDROID || UNITY_IOS
            initSlider(camera);
            camera.GetResolutionsStrs();
#endif

#if UNITY_STANDALONE_WIN || UNITY_EDITOR
            initSliderPC();
#endif
        }

        bool showPoints = false;
        public void SetLocatePointsToCameraRender(List<Vector2> points, float w, float h)
        {
            //Transform pointsTF2 = _cameraRender.transform.Find("Points");

            //if (pointsTF2.childCount == points.Count)
            //{
            //    Vector2 texSize = new Vector2(w, h);
            //    for (int i = 0; i < pointsTF2.childCount; i++)
            //    {
            //        Transform pointTF = pointsTF2.GetChild(i);
            //        Vector2 pos = points[i];
            //        pointTF.localPosition = pos.pixelToLocalPosition_AnchorCenter(texSize, _cameraRender.rectTransform.rect);
            //        pointTF.gameObject.SetActive(true);
            //        showPoints = true;
            //    }
            //}
            //else
            //{
            //    for (int i = 0; i < pointsTF2.childCount; i++)
            //    {
            //        Transform pointTF = pointsTF2.GetChild(i);
            //        pointTF.gameObject.SetActive(false);
            //        showPoints = false;
            //    }
            //}
            //绘制数据
            DrawTestLine();
        }

        void DrawTestLine()
        {
            Vector2 texSize = ScreenLocate.Main.getUVCCameraInfoSize;

            // 判断 texSize 是否为有效值
            if (texSize == Vector2.zero)
            {
                Debug.LogWarning("Texture size is zero, cannot proceed with line drawing.");
                return;
            }
            if (ScreenLocate.quadUnityVectorList.Count == 4)
            {
                //绘制白色线段
                var lo = new Vector2(-0.5f, -0.5f);
                CurUILineGenerator.Points = new Vector2[4] {
                2 * (ScreenLocate.quadUnityVectorList[0] + lo),
                2 * (ScreenLocate.quadUnityVectorList[1] + lo),
                2 * (ScreenLocate.quadUnityVectorList[3] + lo),
                2 * (ScreenLocate.quadUnityVectorList[2] + lo) };
            }
        }
        #endregion


        #region 参数控制

        //调试UVC参数
        [Header("相机UVC")]
        [SerializeField] GameObject _cameraParameterPanel;
        [SerializeField] GameObject togglePrefab; // 拖入一个Toggle预设体
        [SerializeField] GameObject sliderPrefab; // 拖入一个Slider预设体
        //存储滑块信息。camera
        public Dictionary<string, ParamFloatValue> ParamFloatValueCameraSlider = new Dictionary<string, ParamFloatValue>();
        //自动曝光
        bool bAutoAE = false;
        Toggle CTRLAEToggle;
        Slider CTRLAEABSSlider;

        string[] sliderNameArray = new string[]{
        "自动曝光模式",
        "曝光时间(绝对)",

        "亮度", //
        "对比度",
        "色调",
        "饱和度",
        "锐度",
        "伽玛",
        //"白平衡温度",
        //"白平衡分量",
        "背光补偿",
        "增益"   };

        string[] sliderStrArray = new string[]{
        "CTRL_AE",
        "CTRL_AE_ABS",

        "PU_BRIGHTNESS",
        "PU_CONTRAST",
        "PU_HUE",
        "PU_SATURATION",
        "PU_SHARPNESS",
        "PU_GAMMA",
        //"PU_WB_TEMP",
        //"PU_WB_COMPO",
        "PU_BACKLIGHT",
        "PU_GAIN" };

        UVCManager.CameraInfo currentCameraInfo;
        //初始化相机参数
        public void initSlider(UVCManager.CameraInfo cameraInfo)
        {
            if (currentCameraInfo != null) return;
            currentCameraInfo = cameraInfo;

            string[] sliderNameArrayKey = new string[] {
                "AutoExposureMode",          // "自动曝光模式"
                "ExposureTimeAbsolute",      // "曝光时间(绝对)"
                "Brightness",                // "亮度"
                "Contrast",                  // "对比度"
                "Hue",                       // "色调"
                "Saturation",                // "饱和度"
                "Sharpness",                 // "锐度"
                "Gamma",                     // "伽玛"
                "BacklightCompensation",     // "背光补偿"
                "Gain"                       // "增益"
            };



            for (int i = 0; i < sliderStrArray.Length; i++)
            {
                string typeStr = sliderStrArray[i];
                Debug.Log("typeStr:" + typeStr);
                // UInt64 _VALUE = cameraInfo.GetTypeByName(typeStr);
                //不支持的，跳过
                bool bContains = cameraInfo.ContainsKey(typeStr);
                if (!bContains) continue;


                if (typeStr == "CTRL_AE")
                {
                    //曝光Toggle
                    GameObject toggleObject = Instantiate(togglePrefab, _cameraParameterPanel.transform);
                    toggleObject.SetActive(true);
                    toggleObject.name = typeStr;

                    Text labelObj = toggleObject.transform.Find("Label").GetComponent<Text>();
                    labelObj.text = sliderNameArray[i];

                    Toggle toggle = toggleObject.GetComponent<Toggle>();
                    CTRLAEToggle = toggle;

                    UVCCtrlInfo _AEInfo = cameraInfo.GetInfo(typeStr);
                    Debug.Log("UVCCtrlInfo:" + _AEInfo.ToString());

                    int _currentValue = cameraInfo.GetValue(typeStr);
                    bAutoAE = _currentValue == 8 ? true : false; //如果当前值是 8，则当前摄像机是自动曝光模式
                    toggle.isOn = bAutoAE;
                    //cameraInfo.SetValue(_VALUE, _currentValue!=8? 8:1);

                    toggle.onValueChanged.AddListener((bool bValue) =>
                    {
                        //Debug.Log("Toggle value changed to: " + bValue + " from " + _VALUE);
                        if (typeStr == "CTRL_AE")
                        {
                            //开关控制是否自动曝光
                            bAutoAE = bValue;
                            if (CTRLAEABSSlider) CTRLAEABSSlider.interactable = !bAutoAE;
                            int _value = bValue ? 8 : 1;
                            //Debug.Log("_value " + _value);
                            cameraInfo.SetValue(typeStr, _value);
                        }

                    });
                }
                else
                {
                    //其余使用slider
                    GameObject sliderObject = Instantiate(sliderPrefab, _cameraParameterPanel.transform);
                    sliderObject.SetActive(true);
                    sliderObject.name = typeStr;

                    Slider slider = sliderObject.GetComponent<Slider>();



                    Text textObj = sliderObject.transform.Find("value").GetComponent<Text>();
                    Text titleTextObj = sliderObject.transform.Find("title").GetComponent<Text>();
                    titleTextObj.text = sliderNameArray[i];//类型名字
                    if (slider != null)
                    {

                        UVCCtrlInfo _UVCCtrlInfo = cameraInfo.GetInfo(typeStr);
                        Debug.Log(_UVCCtrlInfo.ToString());
                        slider.minValue = _UVCCtrlInfo.min;
                        slider.maxValue = _UVCCtrlInfo.max;
                        slider.wholeNumbers = true;

                        int _defValue = _UVCCtrlInfo.def;
                        //指定默认值
                        //5、UVC亮度 - 50
                        //6、UVC对比度 - 50
                        if (typeStr == "PU_BRIGHTNESS")
                        {
                            _defValue = 50;
                        }
                        else if (typeStr == "PU_CONTRAST")
                        {
                            _defValue = 50;
                        }

                        //记录一个typeStr类型的数据存储操作对象
                        ParamFloatValue paramFloatValue = new ParamFloatValue("ic_uvc_" + typeStr, _defValue);
                        ParamFloatValueCameraSlider.Add(typeStr, paramFloatValue);
                        if (typeStr == "PU_BRIGHTNESS" || typeStr == "PU_CONTRAST")
                        {
                            //获取设置默认存储的值
                            int _Value = (int)paramFloatValue.Get();
                            cameraInfo.SetValue(typeStr, _Value);
                            Debug.Log("[InfraredDemo] UVC 设置" + typeStr + "默认值：" + _Value);
                            slider.value = _Value;
                            textObj.text = _Value + "";
                        }
                        else
                        {
                            //获取设置当前值
                            int _currentValue = cameraInfo.GetValue(typeStr);
                            slider.value = _currentValue;
                            textObj.text = _currentValue + "";
                        }


                        //如果是曝光slider
                        if (typeStr == "CTRL_AE_ABS")
                        {
                            CTRLAEABSSlider = slider;
                            slider.interactable = !bAutoAE;
                        }
                        slider.onValueChanged.AddListener((newValue) =>
                        {
                            var _value = Mathf.FloorToInt(newValue);
                            textObj.text = _value + "";
                            //Debug.Log("Slider value changed to: " + newValue + " from " + _VALUE);
                            cameraInfo.SetValue(typeStr, _value);
                            paramFloatValue.Set(_value);

                        });
                    }
                }

            }

        }

        public void OpenUVCPanel()
        {
            _cameraParameterPanel.SetActive(true);
        }

        public void CloseUVCPanel()
        {
            _cameraParameterPanel.SetActive(false);
        }

        public void onResetUVCData()
        {

#if UNITY_ANDROID || UNITY_IOS
            resetUVCData();
#endif

#if UNITY_STANDALONE_WIN || UNITY_EDITOR
            resetPCData();
#endif

        }

        void resetUVCData()
        {
            if (currentCameraInfo == null) return;

            for (int i = 0; i < sliderStrArray.Length; i++)
            {
                string typeStr = sliderStrArray[i];
                // UInt64 _VALUE = currentCameraInfo.GetTypeByName(typeStr);
                bool bContains = currentCameraInfo.ContainsKey(typeStr);
                if (!bContains) continue;

                if (typeStr == "CTRL_AE")
                {
                    //toggle值不进行重置
                    Debug.Log("CTRL_AE 不需要重置");
                }
                else if (typeStr == "CTRL_AE_ABS")
                {
                    if (!bAutoAE)
                    {
                        //如果是手动曝光，重置值
                        Transform trans = _cameraParameterPanel.transform.Find(typeStr);
                        Slider slider = trans.GetComponent<Slider>();
                        Text textObj = trans.Find("value").GetComponent<Text>();
                        UVCCtrlInfo _AEInfo = currentCameraInfo.GetInfo(typeStr);
                        //获取当前值
                        int _currentValue = currentCameraInfo.GetValue(typeStr);
                        Debug.Log("CTRL_AE_ABS:" + _currentValue + " = " + _AEInfo.def + " = " + ",bAutoAE:" + bAutoAE);
                        textObj.text = _AEInfo.def + "";
                        slider.value = _AEInfo.def;
                        if (_AEInfo.def != _currentValue) currentCameraInfo.SetValue(typeStr, _AEInfo.def);
                    }
                }
                else
                {
                    Transform trans = _cameraParameterPanel.transform.Find(typeStr);
                    Slider slider = trans.GetComponent<Slider>();
                    Text textObj = trans.Find("value").GetComponent<Text>();
                    UVCCtrlInfo _UVCCtrlInfo = currentCameraInfo.GetInfo(typeStr);
                    ParamFloatValue paramFloatValue = ParamFloatValueCameraSlider.GetValueOrDefault(typeStr);
                    //重置的值
                    int _defValue = _UVCCtrlInfo.def;
                    if (typeStr == "PU_BRIGHTNESS")
                    {
                        _defValue = (int)paramFloatValue.GetDefault();
                    }
                    else if (typeStr == "PU_CONTRAST")
                    {
                        _defValue = (int)paramFloatValue.GetDefault();
                    }
                    textObj.text = _defValue + "";
                    slider.value = _defValue;
                    //获取当前值
                    int _currentValue = currentCameraInfo.GetValue(typeStr);
                    //重置存储值
                    paramFloatValue.Reset();
                    //存储初始值，设置一次到UVC参数
                    if (_defValue != _currentValue) currentCameraInfo.SetValue(typeStr, _defValue);
                }
            }
        }


        //windows 相机
        string[] sliderNameArrayPC = new string[]{
        "亮度",
        "对比度",};
        string[] sliderNameArrayPCKey = new string[]{
        "Brightness",
        "Contrast",};
        string[] sliderStrArrayPC = new string[]{
        "PU_BRIGHTNESS",
        "PU_CONTRAST"};
        //记录一个typeStr类型的数据存储操作对象
        ParamFloatValue pcBRIGHTNESS = new ParamFloatValue("ic_pc_PU_BRIGHTNESS", 0);
        ParamFloatValue pcCONTRAST = new ParamFloatValue("ic_pc_PU_CONTRAST", 0);
        public void initSliderPC()
        {
            for (int i = 0; i < sliderStrArrayPC.Length; i++)
            {
                string typeStr = sliderStrArrayPC[i];
                GameObject sliderObject = Instantiate(sliderPrefab, _cameraParameterPanel.transform);
                sliderObject.SetActive(true);
                sliderObject.name = typeStr;

                Slider slider = sliderObject.GetComponent<Slider>();
                Text textObj = sliderObject.transform.Find("value").GetComponent<Text>();
                Text titleTextObj = sliderObject.transform.Find("title").GetComponent<Text>();
                titleTextObj.text = sliderNameArrayPC[i];//类型名字
                if (slider != null)
                {
                    slider.minValue = -1;
                    slider.maxValue = 1;
                    //记录一个typeStr类型的数据存储操作对象
                    if (typeStr == "PU_BRIGHTNESS")
                    {
                        //获取设置默认存储的值
                        float _Value = pcBRIGHTNESS.Get();
                        ICHelper.SetBrightness(_Value);
                        Debug.Log("[InfraredDemo] PC 设置 PU_BRIGHTNESS:" + typeStr + "默认值：" + _Value);
                        slider.value = _Value;
                        textObj.text = _Value + "";
                        slider.onValueChanged.AddListener((newValue) =>
                        {
                            var _value = newValue;
                            textObj.text = _value + "";
                            ICHelper.SetBrightness(_value);
                            pcBRIGHTNESS.Set(_value);
                        });
                    }
                    else if (typeStr == "PU_CONTRAST")
                    {
                        //获取设置默认存储的值
                        float _Value = pcCONTRAST.Get();
                        ICHelper.SetContrast(_Value);
                        Debug.Log("[InfraredDemo] PC 设置 PU_CONTRAST:" + typeStr + "默认值：" + _Value);
                        slider.value = _Value;
                        textObj.text = _Value + "";
                        slider.onValueChanged.AddListener((newValue) =>
                        {
                            var _value = newValue;
                            textObj.text = _value + "";
                            ICHelper.SetContrast(_value);
                            pcCONTRAST.Set(_value);
                        });
                    }

                }

            }
        }

        void resetPCData()
        {
            for (int i = 0; i < sliderStrArrayPC.Length; i++)
            {
                string typeStr = sliderStrArrayPC[i];

                Transform trans = _cameraParameterPanel.transform.Find(typeStr);
                Slider slider = trans.GetComponent<Slider>();
                Text textObj = trans.Find("value").GetComponent<Text>();
                //重置的值
                int _defValue = 0;
                if (typeStr == "PU_BRIGHTNESS")
                {
                    _defValue = 0;
                    ICHelper.SetBrightness(_defValue);
                }
                else if (typeStr == "PU_CONTRAST")
                {
                    _defValue = 0;
                    ICHelper.SetContrast(_defValue);
                }
                textObj.text = _defValue + "";
                slider.value = _defValue;
            }
        }
        public class ParamFloatValue
        {
            private string _saveKey;
            private float _valueDefault;
            private bool _valueLoaded;
            private float _value;
            public ParamFloatValue(string saveKey, float valueDefault)
            {
                _saveKey = saveKey;
                _valueDefault = valueDefault;
            }
            public float Get()
            {
                if (!_valueLoaded) _value = PlayerPrefs.GetFloat(_saveKey, _valueDefault);
                return _value;
            }

            public float GetDefault()
            {
                return _valueDefault;
            }

            public string GetKey()
            {
                return _saveKey;
            }
            public void Set(float value)
            {
                _value = value;
                PlayerPrefs.SetFloat(_saveKey, _value);
                PlayerPrefs.Save();
            }
            /// <summary>
            /// 重置成默认值
            /// </summary>
            public void Reset()
            {
                PlayerPrefs.SetFloat(_saveKey, _valueDefault);
                PlayerPrefs.Save();
            }

        }
        /// <summary>
        /// 存储Vector2
        /// </summary>
        public class ParamVector2Value
        {
            private string _saveKey;
            private Vector2 _valueDefault;
            private bool _valueLoaded;
            private Vector2 _value;

            public ParamVector2Value(string saveKey, Vector2 valueDefault)
            {
                _saveKey = saveKey;
                _valueDefault = valueDefault;
            }

            public Vector2 Get()
            {
                if (!_valueLoaded)
                {
                    float x = PlayerPrefs.GetFloat(_saveKey + "_x", _valueDefault.x);
                    float y = PlayerPrefs.GetFloat(_saveKey + "_y", _valueDefault.y);
                    _value = new Vector2(x, y);
                    _valueLoaded = true;
                }
                return _value;
            }

            public Vector2 GetDefault()
            {
                return _valueDefault;
            }

            public string GetKey()
            {
                return _saveKey;
            }

            public void Set(Vector2 value)
            {
                _value = value;
                PlayerPrefs.SetFloat(_saveKey + "_x", _value.x);
                PlayerPrefs.SetFloat(_saveKey + "_y", _value.y);
                PlayerPrefs.Save();
            }

            /// <summary>
            /// 重置成默认值
            /// </summary>
            public void Reset()
            {
                PlayerPrefs.SetFloat(_saveKey + "_x", _valueDefault.x);
                PlayerPrefs.SetFloat(_saveKey + "_y", _valueDefault.y);
                PlayerPrefs.Save();
            }
        }
        #endregion


        #region 相机感光度(默认修改对比度)
        public void onSetSliderCustomValue(Slider _slider, float min = 0.0f, float max = 10.0f)
        {
            onSetSliderValue(_slider, "PU_CONTRAST", min, max);
        }
        public void onSliderCustomEvent(float value, float min = 0.0f, float max = 10.0f)
        {
            onSliderEvent(value, "PU_CONTRAST", min, max);
        }

        public void onSetSliderCustomBrightnessValue(Slider _slider, float min = 0.0f, float max = 10.0f)
        {
            onSetSliderValue(_slider, "PU_BRIGHTNESS", min, max);
        }
        public void onSliderCustomBrightnessEvent(float value, float min = 0.0f, float max = 10.0f)
        {
            onSliderEvent(value, "PU_BRIGHTNESS", min, max);
        }
        public void onSetSliderValue(Slider _slider, string typeStr = "PU_CONTRAST", float min = 0.0f, float max = 10.0f)
        {
            if (BluetoothWindows.IsWindows())
            {
                float v = typeStr == "PU_CONTRAST" ? ICHelper.GetContrast() : ICHelper.GetBrightness();
                // 目标区间 [0, 10] 的边界值
                double targetMin = min;
                double targetMax = max;
                double originalMin = -1;
                double originalMax = 1;
                // 计算转换后的值
                double v2 = MapValue(v, originalMin, originalMax, targetMin, targetMax);

                Debug.Log("PC获取相机的感光度 " + typeStr + " ：" + v + " = " + v2);
                _slider.SetValueWithoutNotify((float)v2);
                return;
            }
            //功能也改为UVC的对比度
            if (ICHelper != null)
            {
                //string typeStr = "PU_CONTRAST";//"PU_BRIGHTNESS";
                //UInt64 _VALUE = currentCameraInfo.GetTypeByName(typeStr);
                UVCCtrlInfo _UVCCtrlInfo = currentCameraInfo.GetInfo(typeStr);
                float v = currentCameraInfo.GetValue(typeStr); // ICHelper.GetBrightness();
                                                               //float v2 = (v / _UVCCtrlInfo.max) * 10;

                // 目标区间 [0, 10] 的边界值
                double targetMin = min;
                double targetMax = max;
                double originalMin = _UVCCtrlInfo.min;
                double originalMax = _UVCCtrlInfo.max;
                // 计算转换后的值
                double v2 = MapValue(v, originalMin, originalMax, targetMin, targetMax);


                Debug.Log("获取相机的感光度" + typeStr + "： " + v + " = " + v2);
                _slider.SetValueWithoutNotify((float)v2);
            }
            else _slider.SetValueWithoutNotify(5);
        }

        public void onSliderEvent(float value, string typeStr = "PU_CONTRAST", float min = 0.0f, float max = 10.0f)
        {
            // string typeStr = "PU_CONTRAST";// "PU_BRIGHTNESS";
            //pc
            if (BluetoothWindows.IsWindows())
            {
                Transform trans = _cameraParameterPanel.transform.Find(typeStr);
                Slider slider = trans.GetComponent<Slider>();
                Text textObj = trans.Find("value").GetComponent<Text>();
                // 原始区间和目标区间的边界值
                double originalMin = min;
                double originalMax = max;
                double targetMin = -1;
                double targetMax = 1;
                // 计算转换后的值
                double result = MapValue(value, originalMin, originalMax, targetMin, targetMax);

                float _current = (float)result;
                //Debug.Log("_current:" + _current + " , result:" + result);
                textObj.text = _current + "";
                slider.value = _current;
                if (typeStr == "PU_CONTRAST")
                {
                    ICHelper.SetContrast(_current);
                    pcCONTRAST.Set(_current);
                }
                else
                {
                    ICHelper.SetBrightness(_current);
                    pcBRIGHTNESS.Set(_current);
                }

                return;
            }

            //修改亮度时，调试界面的亮度也应该一起修改
            //功能也改为UVC的对比度
            if (ICHelper != null)
            {
                //Slider slider = transform.Find("InfraredCamera/Layout/SliderBrightness")
                //    .GetComponent<Slider>();

                // UInt64 _VALUE = currentCameraInfo.GetTypeByName(typeStr);
                Transform trans = _cameraParameterPanel.transform.Find(typeStr);
                Slider slider = trans.GetComponent<Slider>();

                Text textObj = trans.Find("value").GetComponent<Text>();
                UVCCtrlInfo _UVCCtrlInfo = currentCameraInfo.GetInfo(typeStr);
                int _currentUVCValue = currentCameraInfo.GetValue(typeStr);
                //value 0 ~ 10
                // 原始区间和目标区间的边界值
                double originalMin = min;
                double originalMax = max;
                double targetMin = _UVCCtrlInfo.min;
                double targetMax = _UVCCtrlInfo.max;
                // 计算转换后的值
                double result = MapValue(value, originalMin, originalMax, targetMin, targetMax);

                int _current = (int)(result);
                Debug.Log("_current:" + value + " , result:" + result);
                textObj.text = _current + "";
                slider.value = _current;
                //dUVCParameters.GetValueOrDefault(typeStr).Set(_current);
                //存储初始值，设置一次到UVC参数
                if (_currentUVCValue != _current) currentCameraInfo.SetValue(typeStr, _current);

            }
        }

        public static double MapValue(double value, double originalMin, double originalMax, double targetMin, double targetMax)
        {
            // 线性插值公式
            return targetMin + (value - originalMin) * (targetMax - targetMin) / (originalMax - originalMin);
        }
        #endregion


        /// <summary>
        /// 提取转换四边形的方法
        /// </summary>
        /// <param name="quad"></param>
        /// <param name="texSize"></param>
        /// <returns></returns>
        public Vector2[] ConvertQuadToPoints(QuadrilateralInCamera quad, Vector2 texSize)
        {
            if (quad == null || quad.Quad == null || quad.Quad.Count < 4)
            {
                Debug.LogWarning("Invalid quadrilateral data provided.");
                return new Vector2[0]; // 返回空数组以避免异常
            }

            Vector2 offset = new Vector2(-0.5f, -0.5f); // 假设 'lo' 是某个已定义的偏移量
            return new Vector2[4] {
        2 * (new Vector2(quad.Quad[0].x / texSize.x, quad.Quad[0].y / texSize.y) + offset),
        2 * (new Vector2(quad.Quad[1].x / texSize.x, quad.Quad[1].y / texSize.y) + offset),
        2 * (new Vector2(quad.Quad[3].x / texSize.x, quad.Quad[3].y / texSize.y) + offset),
        2 * (new Vector2(quad.Quad[2].x / texSize.x, quad.Quad[2].y / texSize.y) + offset)
         };
        }

        #region 中心点定位
        [Header("红外点")]
        [SerializeField] Text _infraredOffsetText;
        [SerializeField] Button _infraredOffsetBtn1P;
        [SerializeField] Button _infraredOffsetBtn2P;
        //准心的偏移值
        public ParamVector2Value cameraLocationValue = new ParamVector2Value("ic_cameraLocation", Vector2.zero);
        public ParamVector2Value screenUVValue = new ParamVector2Value("ic_screenUV", Vector2.zero);
        public ParamVector2Value cameraLocationValue1P = new ParamVector2Value("ic_cameraLocation1P", Vector2.zero);
        public ParamVector2Value screenUVValue1P = new ParamVector2Value("ic_screenUV1P", Vector2.zero);
        public ParamVector2Value cameraLocationValue2P = new ParamVector2Value("ic_cameraLocation2P", Vector2.zero);
        public ParamVector2Value screenUVValue2P = new ParamVector2Value("ic_screenUV2P", Vector2.zero);

        /// <summary>
        /// 偏移点按钮
        /// </summary>
        public void InitOffsetBtns()
        {
            _infraredOffsetBtn1P.onClick.AddListener(() =>
            {
                SetAdjustPointsOffset(PlayerType.FirstPlayer);
            });
            _infraredOffsetBtn2P.onClick.AddListener(() =>
            {
                SetAdjustPointsOffset(PlayerType.SecondPlayer);
            });
        }

        /// <summary>
        /// 设置存储的中心偏移位置
        /// </summary>
        public void InitCenterOffset()
        {
            //ICHelper.SetCenterOffset(cameraLocationValue.Get(), "CameraLocation");
            //ICHelper.SetCenterOffset(screenUVValue.Get(), "ScreenUV");
        }

        /// <summary>
        /// 重置中心点
        /// </summary>
        public void ResetCenterOffset()
        {
            ICHelper.ResetCenterOffset();
        }
        /// <summary>
        /// 撤销中心点
        /// </summary>
        public void RevokeCenterOffset()
        {
            ICHelper.RevokeCenterOffset();
        }
        /// <summary>
        /// 重置定位数据
        /// </summary>
        public void ResetPositioningData(bool bSyncLocal = false)
        {
            ICHelper.ClearInfraredPositioningData(bSyncLocal);
        }

        /// <summary>
        /// 设置存储的中心偏移位置--双点
        /// </summary>
        public void InitCenterOffsets(PlayerType playerType)
        {
            if (ICHelper.IsSinglePoint())
            {
                ICHelper.SetCenterOffset(cameraLocationValue.Get(), "CameraLocation");
                ICHelper.SetCenterOffset(screenUVValue.Get(), "ScreenUV");
            }
            else
            {

                ICHelper.SetCenterOffsets(playerType, playerType == PlayerType.FirstPlayer ? cameraLocationValue1P.Get() : cameraLocationValue2P.Get(), "CameraLocation");
                ICHelper.SetCenterOffsets(playerType, playerType == PlayerType.FirstPlayer ? screenUVValue1P.Get() : screenUVValue2P.Get(), "ScreenUV");
            }

        }
        /// <summary>
        /// 撤销中心点--双点
        /// </summary>
        public void RevokeCenterOffsets()
        {
            ICHelper.RevokeCenterOffsets();
        }

        /// <summary>
        /// 重置中心点--双点
        /// </summary>
        public void ResetCenterOffsets()
        {
            ICHelper.ResetCenterOffsets();
        }
        /// <summary>
        /// 校准中心点偏移量，双点情况下要设置 SetCenterOffsets
        /// </summary>
        /// <param name="playerType">玩家类型</param>
        public void SetAdjustPointsOffset(PlayerType playerType)
        {
            var buffer = ICHelper.getScreenLocate().infraredSpotBuffer;
            if (buffer != null)
            {

                if (playerType == PlayerType.FirstPlayer && buffer[0].CameraLocation != null)
                {
                    if (ICHelper.IsSinglePoint())
                    {  //单点
                        var centerOffset = ICHelper.GetCenterOffset(buffer[0].CameraLocation.Value);
                        cameraLocationValue.Set(centerOffset);
                        var uvCenterOffset = ICHelper.GetCenterOffset(buffer[0].ScreenUV.Value, "ScreenUV");
                        screenUVValue.Set(uvCenterOffset);
                    }
                    else
                    {
                        var centerOffset = ICHelper.GetCenterOffset(buffer[0].CameraLocation.Value, true);
                        cameraLocationValue1P.Set(centerOffset);
                        ICHelper.SetCenterOffsets(playerType, centerOffset);
                        var uvCenterOffset = ICHelper.GetCenterOffset(buffer[0].ScreenUV.Value, true, "ScreenUV");
                        screenUVValue1P.Set(uvCenterOffset);
                        ICHelper.SetCenterOffsets(playerType, uvCenterOffset, "ScreenUV");
                    }
                }
                if (playerType == PlayerType.SecondPlayer && buffer[1].CameraLocation != null)
                {
                    var centerOffset = ICHelper.GetCenterOffset(buffer[1].CameraLocation.Value, false);
                    cameraLocationValue2P.Set(centerOffset);
                    ICHelper.SetCenterOffsets(playerType, centerOffset);
                    var uvCenterOffset = ICHelper.GetCenterOffset(buffer[1].ScreenUV.Value, false, "ScreenUV");
                    screenUVValue2P.Set(uvCenterOffset);
                    ICHelper.SetCenterOffsets(playerType, uvCenterOffset, "ScreenUV");
                }
            }
        }
        #endregion

        #region Log 控制台
        //控制台
        private bool s_LogReporterInited = false;
        Reporter reporter;

        public void InitReturnLogReporter()
        {
            if (s_LogReporterInited) return;
            s_LogReporterInited = true;
            GameObject obj = (GameObject)Instantiate(Resources.Load("Prefabs/LogReporter"));
            reporter = obj.GetComponent<Reporter>();
            Debug.LogWarning("在屏幕上画个圈即可打开控制台");
        }
        #endregion


        #region 准心
        //红外准心，默认打开吧
        public ParamFloatValue crosshairValue1P = new ParamFloatValue("ic_crosshairValue1P", 1);
        public ParamFloatValue crosshairValue2P = new ParamFloatValue("ic_crosshairValue2P", 1);
        /// <summary>
        /// 初始化时候获取设置和存储来控制显示准心
        /// </summary>
        /// <returns></returns>
        public bool bInitCrosshairShow(PlayerType playerType)
        {
            if (playerType == PlayerType.FirstPlayer)
                return getCrosshairValue(playerType) == 1 ? true : false;
            else
                return getCrosshairValue(playerType) == 1 ? true : false;
        }

        /// <summary>
        /// 获取弓箭准心存储值 
        /// </summary>
        /// <returns></returns>
        public int getCrosshairValue(PlayerType playerType)
        {
            if (playerType == PlayerType.FirstPlayer)
                return (int)crosshairValue1P.Get();
            else
                return (int)crosshairValue2P.Get();
        }

        public void setCrosshairValue(PlayerType playerType, bool bshow)
        {
            if (playerType == PlayerType.FirstPlayer)
                crosshairValue1P.Set(bshow ? 1 : 0);
            else
                crosshairValue2P.Set(bshow ? 1 : 0);

        }
        #endregion

        #region 亮度检测部分
        //红外线阈值
        [Header("红外线阈值")]
        [SerializeField] Slider _infraredFilter;
        //亮度过滤阈值  - 0.8
        public ParamFloatValue infraredFileterValue = new ParamFloatValue("ic_infraredFileterValue", 0.8f);

        public void SetInfraredFilterValue(float v)
        {
            infraredFileterValue.Set(v);
            _infraredFilter.SetValueWithoutNotify(infraredFileterValue.Get());
            _infraredFilter.transform.Find("value").GetComponent<Text>().text = infraredFileterValue.Get().ToString("f1");
            ICHelper.SetInfraredLocateBrightnessThreshold(infraredFileterValue.Get());
        }
        #endregion
    }
}