using ShotSimulator.Screen;
using ShotSimulator.Target;
using ShotSimulator.Tool;
using ShotSimulator.Train.Info;
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Random = UnityEngine.Random;

namespace ShotSimulator.Train
{
    public class TrackBallTrainHandle : BaseTrainHandle
    {
        private SphereShotTarget curTarget;

        private TrackBallTrainDifficultyData m_DifficultyData;
        private TrackBallTrainScoreData m_ScoreData;

        private double scoreTime;
        private double punitiveTime;


        private double m_TotalHoverTime;
        private double TotalHoverTime
        {
            get { return m_TotalHoverTime; }
            set
            {
                m_TotalHoverTime = value;
                UpdatePrecision();
            }
        }
        private double m_TotalMissTime;
        private double TotalMissTime
        {
            get { return m_TotalMissTime; }
            set
            {
                m_TotalMissTime = value;
                UpdatePrecision();
            }
        }
        public TrackBallTrainHandle(BaseTrainCallBack callBack, BaseTrainInfo info, DifficultyType difficultyType) : base(callBack, info, difficultyType)
        {
            SetShotTargetInteractiveEvent(ShotTargetInteractiveType.OnHovering, OnHoveringTargetEvent);
            SetShotTargetInteractiveEvent(ShotTargetInteractiveType.OnNotEntering, OnNotEnteringEvent);

            m_DifficultyData = info.GetDifficultyData<TrackBallTrainDifficultyData>(m_DifficultyType);
            m_ScoreData = info.GetScoreData<TrackBallTrainScoreData>(m_DifficultyType);
        }

        private void GenerateShootingTargets()
        {
            GameObject obj = GameObject.Instantiate<GameObject>(Resources.Load<GameObject>("Prefabs/SphereTarget"));
            curTarget = obj.GetComponent<SphereShotTarget>();
            List<Vector3> pos = new List<Vector3>();
            for (int i = 0; i < 20; i++)
            {
                pos.Add(RandomPosition());
            }
            curTarget.onClickCanChangeColor = false;
            curTarget.onHoveringCanChangeColor = true;
            curTarget.defaultColor = ScreenEffectManager.GetInstance().GetTargetColor();
            curTarget.onHoveringColor = Color.red;
            curTarget.Init(1, ReduceHealthTriggerType.None, false, ReduceHealthType.Per, MotionType.Foreach, new Vector3(0, 0, m_DifficultyData.targetDistance), pos, m_DifficultyData.speed);
            curTarget.IsRunning = true;
        }

        private Vector3 RandomPosition()
        {
            Vector2 widthLimt = Vector2.zero;
            Vector2 heightLimt = Vector2.zero;
            switch (m_DifficultyType)
            {
                case DifficultyType.Standard:
                    widthLimt = new Vector2(-4, 4);
                    heightLimt = new Vector2(-1.5f, 1.5f);
                    break;
                case DifficultyType.Advance:
                    widthLimt = new Vector2(-8, 8);
                    heightLimt = new Vector2(-1.5f, 3.5f);
                    break;
                case DifficultyType.Professional:
                    widthLimt = new Vector2(-8, 8);
                    heightLimt = new Vector2(-1.5f, 5f);
                    break;
            }
            Vector3 min = ExtraTool.GetScreenOffsetPosition(ExtraTool.Sphere_Diameter1_ScreenLeftBottomOffset, m_DifficultyData.targetDistance, widthLimt, heightLimt);
            Vector3 max = ExtraTool.GetScreenOffsetPosition(ExtraTool.Sphere_Diameter1_ScreenRightTopOffset, m_DifficultyData.targetDistance, widthLimt, heightLimt);

            return ExtraTool.RandomPosition(min, max);
        }

        private void ResetTarget()
        {
            if (curTarget != null)
            {
                curTarget.IsRunning = false;
                GameObject.Destroy(curTarget.gameObject);
                curTarget = null;
            }
        }
        #region Train
        protected override void ResetTrain()
        {
            ResetTarget();
            scoreTime = 0;
            punitiveTime = 0;

            m_TotalHoverTime = 0;
            m_TotalMissTime = 0;
        }

        public override void StartTrain()
        {
            base.StartTrain();
            GenerateShootingTargets();
        }

        public override void PauseTrain()
        {
            base.PauseTrain();

            curTarget.IsRunning = false;
        }

        public override void ContinueTrain()
        {
            base.ContinueTrain();

            curTarget.IsRunning = true;
        }

        public override void CalculateTrainResult()
        {
            SetResultMetricsDataValue(MetricsType.Precision, Math.Round(TotalHoverTime / (TotalHoverTime + TotalMissTime), 2));
            SetResultMetricsDataValue(MetricsType.AverageTimeOnTarget, Math.Round(TotalHoverTime, 2));
        }
        #endregion
        private void UpdatePrecision()
        {
            SetResultMetricsDataValue(MetricsType.Precision, Math.Round(TotalHoverTime / (TotalHoverTime + TotalMissTime), 2));
        }
        #region ShotTarget
        private void OnHoveringTargetEvent(BaseShotTarget target)
        {
            scoreTime += Time.deltaTime;
            if (scoreTime >= 1)
            {
                int comboS = Mathf.CeilToInt(m_ScoreData.baseScore * (comboNums / 5) * m_ScoreData.comboMul);
                IncreaseScore(m_ScoreData.baseScore + comboS);
                comboNums++;
                scoreTime = 0;
            }
            TotalHoverTime += Time.deltaTime;
        }

        private void OnNotEnteringEvent(BaseShotTarget target)
        {
            punitiveTime += Time.deltaTime;
            if (punitiveTime >= 1)
            {
                comboNums = 0;
                punitiveTime = 0;

                int missPunitiveS = Mathf.CeilToInt(m_ScoreData.baseScore * m_ScoreData.missPunitiveMul);
                IncreaseScore(missPunitiveS * -1);
            }
            TotalMissTime += Time.deltaTime;
        }
        #endregion
    }
}