using ProjectBase.UI;
using ShotSimulator.Target;
using ShotSimulator.Tool;
using ShotSimulator.Train.Info;
using ShotSimulator.UI;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Android;
using UnityEngine.Events;
using UnityEngine.EventSystems;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

namespace ShotSimulator.Train
{
    public class TrainTaskLoader : MonoSingleton<TrainTaskLoader>
    {
        public MetricsTypeConfig m_MetricsTypeConfig;

        private BaseTrainInfo[] m_TrainInfos;

        private BaseTrainHandle curTrainHandle = null;

        private BaseFirearmData[] m_FirearmDatas;
        [SerializeField]
        private BaseFirearmData curFirearmData = null;

        private BaseShotTarget curShootingTarget = null;
        public BaseTrainInfo[] TrainInfos
        {
            get { return m_TrainInfos; }
            private set { m_TrainInfos = value; }
        }
        public BaseFirearmData[] FirearmDatas
        {
            get { return m_FirearmDatas; }
            private set { m_FirearmDatas = value; }
        }
        public BaseTrainHandle CurTrainHandle
        {
            get { return curTrainHandle; }
        }
        public BaseFirearmData CurFirearmData
        {
            get { return curFirearmData; }
        }
        private string current_EnvScene = string.Empty;
        private void Awake()
        {
            if (!Permission.HasUserAuthorizedPermission(Permission.ExternalStorageRead))
            {
                Permission.RequestUserPermission(Permission.ExternalStorageRead);
            }

            TrainInfos = Resources.LoadAll<BaseTrainInfo>("ScriptableObjects/TrainInfo");
            FirearmDatas = Resources.LoadAll<BaseFirearmData>("ScriptableObjects/Firearm");
            m_MetricsTypeConfig = Resources.Load<MetricsTypeConfig>("ScriptableObjects/Config/指标类型表");

            curFirearmData = GetFirearmData(Main.GetInstance().CurrentFirearmDevice);
            Debug.Log("[TrainTaskLoader] CurrentFirearmDevice：" + Main.GetInstance().CurrentFirearmDevice.ToString());
            Debug.Log("[TrainTaskLoader] curFirearmData：" + curFirearmData.gunName);
            //VirtualMouse.GetInstance().SetCurCursorType(CursorType.DefaultCursor);
        }

        private BaseFirearmData GetFirearmData(FirearmDeviceType type)
        {
            for(int i = 0; i < FirearmDatas.Length; i++)
            {
                if (FirearmDatas[i].firearmDeviceType == type)
                {
                    return FirearmDatas[i];
                }
            }
            return null;
        }

        public void Shoot(float speed)
        {
            if (VirtualMouse.GetInstance().IsSelectUIObject()) return;

            if (curTrainHandle == null) return;
            if (!curTrainHandle.IsRunning || curTrainHandle.IsPause) return;

//#if UNITY_EDITOR || UNITY_STANDALONE
//            curTrainHandle.OnShottedTarget(curShootingTarget, Input.mousePosition);
//#elif UNITY_ANDROID
            curTrainHandle.OnShottedTarget(curShootingTarget, VirtualMouse.GetInstance().screenPos);
//#endif
        }

        public void ChangedMagazineStatus(SmartBowSDK.BluetoothDeviceType bleDeviceType, SmartBowSDK.BluetoothDeviceStatus gunStatusEnum)
        {
            if (curTrainHandle == null) return;
            if (!curTrainHandle.IsRunning || curTrainHandle.IsPause) return;

            switch (gunStatusEnum)
            {
                case SmartBowSDK.BluetoothDeviceStatus.MagazineSeparation:
                    curTrainHandle.SeparationMagazine();
                    break;
                case SmartBowSDK.BluetoothDeviceStatus.MagazineLoading:
                    curTrainHandle.ReloadMagazine();
                    break;
                case SmartBowSDK.BluetoothDeviceStatus.Chambered:
                    curTrainHandle.IsChambered = true;
                    break;
            }
        }
        private void Update()
        {
            if (curTrainHandle == null) return;
            if (!curTrainHandle.IsRunning || curTrainHandle.IsPause) return;
//#if UNITY_EDITOR || UNITY_STANDALONE
//            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
//#else
            Ray ray = Camera.main.ScreenPointToRay(VirtualMouse.GetInstance().screenPos);
//#endif
            if (Physics.Raycast(ray, out var hit, 100f, 1 << LayerMask.NameToLayer("ShotTarget")))
            {
                BaseShotTarget newTarget = hit.transform.GetComponentInParent<BaseShotTarget>();
                if (curShootingTarget == null)
                {
                    curShootingTarget = newTarget;
                    curTrainHandle.OnEnteredTarget(curShootingTarget);
                }
                else
                {
                    if (curShootingTarget == newTarget)
                    {
                        curTrainHandle.OnHoveringTarget(curShootingTarget);
                    }
                    else
                    {
                        curTrainHandle.OnExitedTarget(curShootingTarget);
                        curShootingTarget = newTarget;
                        curTrainHandle.OnEnteredTarget(curShootingTarget);
                    }
                }
            }
            else
            {
                if (curShootingTarget != null)
                {
                    curTrainHandle.OnExitedTarget(curShootingTarget);
                    curShootingTarget = null;
                }
                curTrainHandle.OnNotEnteringTarget(null);
            }

#if UNITY_EDITOR || UNITY_STANDALONE
            if (Input.GetMouseButtonDown(0))
            {
                Shoot(0);
            }
            if (Input.GetKeyDown(KeyCode.R))
            {
                ChangedMagazineStatus(SmartBowSDK.BluetoothDeviceType.Pistol1, SmartBowSDK.BluetoothDeviceStatus.MagazineLoading);
            }
            else if (Input.GetKeyDown(KeyCode.S))
            {
                if (curTrainHandle == null) return;
                if (!curTrainHandle.IsRunning || curTrainHandle.IsPause) return;

                curTrainHandle.SeparationMagazine();
            }
            if (Input.GetKeyDown(KeyCode.C))
            {
                ChangedMagazineStatus(SmartBowSDK.BluetoothDeviceType.Pistol1, SmartBowSDK.BluetoothDeviceStatus.Chambered);
            }
#endif
        }

        public void PrepareTrain(BaseTrainInfo info, DifficultyType type)
        {
            BaseTrainCallBack callback = NewTrainCallBack();
            curTrainHandle = ConstructorTrainHandle(info.trainHandleClassName, info, callback, type);
            LoadEnvironmentScene(info.environmentScene, () => { curTrainHandle.PrepareTrain(); });
        }

        private void LoadEnvironmentScene(string sceneName, UnityAction action)
        {
            if (current_EnvScene != string.Empty && current_EnvScene != sceneName)
            {
                ScenesManager.GetInstance().UnloadSceneAsyn(current_EnvScene, null);
            }
            if (current_EnvScene != sceneName)
            {
                current_EnvScene = sceneName;

                ScenesManager.GetInstance().LoadSceneAsyn(sceneName, action, LoadSceneMode.Additive);
            }
            else
            {
                if (action != null)
                {
                    action();
                }
            }
        }

        private BaseTrainHandle ConstructorTrainHandle(string typeName, BaseTrainInfo info, BaseTrainCallBack callback, DifficultyType type)
        {
            object instance = Activator.CreateInstance(Type.GetType(typeName), callback, info, type);

            BaseTrainHandle handle = instance as BaseTrainHandle;
            handle.InitGunData(curFirearmData);

            return instance as BaseTrainHandle;
        }

        public void StartTrainTask()
        {
            curTrainHandle.StartTrain();
        }

        private BaseTrainCallBack NewTrainCallBack()
        {
            BaseTrainCallBack callBack = new BaseTrainCallBack();
            callBack.AddTrainCallBack(TrainEventType.OnPrepare, OnPrepareTrainCallBack);
            callBack.AddTrainCallBack(TrainEventType.OnStartTrain, OnStartTrainCallBack);
            callBack.AddTrainCallBack(TrainEventType.OnPauseTrain, OnContinueOrPauseTrainCallBack);
            callBack.AddTrainCallBack(TrainEventType.OnContinueTrain, OnContinueOrPauseTrainCallBack);
            callBack.AddTrainCallBack(TrainEventType.OnExitTrain, OnExitTrainCallBack);
            callBack.AddTrainCallBack(TrainEventType.OnCompleteTrain, OnCompleteTrainCallBack);

            return callBack;
        }

        public void SetContinueOrPauseTrain(bool pause)
        {
            if (curTrainHandle != null)
            {
                if (pause)
                {
                    curTrainHandle.PauseTrain();
                }
                else
                {
                    curTrainHandle.ContinueTrain();
                }
            }
        }

        public void FinishTrain()
        {
            if (curTrainHandle != null)
            {
                curTrainHandle.ExitTrain();
                curTrainHandle = null;
            }
        }

        public void ReStartTrain()
        {
            if (curTrainHandle != null)
            {
                curTrainHandle.PrepareTrain();
            }
        }
        public void OnPrepareTrainCallBack(BaseTrainHandle handle)
        {
            UIManager.GetInstance().HideAllUIView();
            UIManager.GetInstance().ShowUIView("ExecuteTrainUIView", handle);
            UIManager.GetInstance().ShowUIView("CursorUIView", CursorType.UICursor);
        }
        public void OnStartTrainCallBack(BaseTrainHandle handle)
        {
            CursorUIView view = UIManager.GetInstance().GetOnShowUIView("CursorUIView") as CursorUIView;
            view.SetArguments(handle.TrainInfo.cursorType);
        }

        public void OnCompleteTrainCallBack(BaseTrainHandle handle)
        {
            UIManager.GetInstance().HideAllUIView();
            UIManager.GetInstance().ShowUIView("TrainSettlementUIView", handle);
            UIManager.GetInstance().ShowUIView("CursorUIView", CursorType.UICursor);
        }

        public void OnContinueOrPauseTrainCallBack(BaseTrainHandle handle)
        {
            CursorUIView view = UIManager.GetInstance().GetOnShowUIView("CursorUIView") as CursorUIView;
            if (handle.IsPause)
            {
                view.SetArguments(CursorType.UICursor);
            }
            else
            {
                view.SetArguments(handle.TrainInfo.cursorType);
            }
        }

        public void OnExitTrainCallBack(BaseTrainHandle handle)
        {
            UIManager.GetInstance().HideAllUIView();
            UIManager.GetInstance().ShowUIView("TrainTaskInfoUIView");
            UIManager.GetInstance().ShowUIView("CursorUIView", CursorType.UICursor);
        }
    }
}