using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using DG.Tweening;
using Yarn.Unity;
using System.Linq;
using UnityEngine.UI;
using AibisDream.FixSystem;
using AibisDream.Framework;
using AibisDream.Kit;
using AibisDream.SaveSystem;
using UnityEngine.ResourceManagement.AsyncOperations;
using Sequence = DG.Tweening.Sequence;

namespace AibisDream
{
    public class EyeSystem : MonoBehaviour
    {
        private const string MemorySpritePath = "Sprite/Memory/{0}.png";

        [SerializeField] private List<EyeTarget> targets = new();
        public List<EyeTarget> Targets => targets;

        private EyeTarget currentTarget;
        public EyeTarget CurrentTarget => currentTarget;

        [Header("Memory Overlay (UI)")]
        public Image memoryRender;
        public GameObject eyeView;

        [Header("Focus Pan Bounds")]
        [SerializeField] private Vector2 focusMinBounds = new(30.2f, -4.5f);
        [SerializeField] private Vector2 focusMaxBounds = new(50.2f, 5f);

        [Header("Visual Tuning")]
        [SerializeField] private EyeVisualSettings visualSettings = new();

        [SerializeField] private EyeViewportOverlay viewportOverlay;

        [Tooltip("Play 模式下改 Visual Tuning 后，自动对当前目标重播一次 Focused 效果（如 ColorIn）。")]
        [SerializeField] private bool replayFocusedEffectOnSettingsChange = true;

        public EyeVisualSettings VisualSettings => visualSettings;

        private IEyeStateEffect eyeStateEffect;
        private EyeColorState _currentState = EyeColorState.CannotImagineColor;
        private MouseFollowAndZoom mouseFollowAndZoom;
        private Sequence glitchin;

        public EyeColorState GetCurrentColorState() => _currentState;

        /// <summary>Eye/UF 演出倍速（默认见 Visual Tuning → Presentation Speed）。</summary>
        public float PresentationSpeed => Mathf.Max(0.01f, visualSettings != null ? visualSettings.presentationSpeed : 1f);

        public float ScaleDuration(float duration) => duration / PresentationSpeed;

        public float GetEffectTransitionDuration() => ScaleDuration(visualSettings.GetDurationForState(_currentState));

        private void PlayPresentationSfx(string eventName)
        {
            AudioManager.Instance.PlaySfx(eventName, pitch: PresentationSpeed);
        }

        /// <summary>仅「可想象色彩」上色时眨眼；无 autoBlink / 失焦眨眼。</summary>
        private bool ShouldBlinkForImagine()
        {
            return _currentState == EyeColorState.CanImagineColor;
        }

        private IEnumerator WaitForFocusMovement(float moveDuration)
        {
            if (!EnsureMouseFollowAndZoom())
            {
                yield break;
            }

            yield return mouseFollowAndZoom.WaitForFocusMove(moveDuration);
        }

        private IEnumerator RunFocusedEffectWithPreBlink(EyeTarget target)
        {
            if (EnsureMouseFollowAndZoom())
            {
                yield return mouseFollowAndZoom.WaitForFocusMove();
            }

            float duration = GetEffectTransitionDuration();
            EyeViewportOverlay overlay = EnsureViewportOverlay();

            if (overlay != null && Application.isPlaying && ShouldBlinkForImagine())
            {
                yield return overlay.PlayPreEffectBlinkThen(
                    2,
                    visualSettings,
                    () => eyeStateEffect?.ApplyFocusedEffect(target, this),
                    visualSettings.imagineEffectAtBlinkOpen,
                    visualSettings.imagineBlinkGap,
                    PresentationSpeed);
            }
            else
            {
                eyeStateEffect?.ApplyFocusedEffect(target, this);
            }

            yield return new WaitForSeconds(duration);
        }

        private IEnumerator RunBlurOut(EyeTarget target, float duration)
        {
            duration = ScaleDuration(duration);
            if (target != null)
            {
                target.BlurOut(duration);
            }

            yield return new WaitForSeconds(duration);
        }

        /// <summary>
        /// 换目标时的失焦：只做效果，不眨眼（眨眼仅在想象上色 FadeIn）。
        /// CanImagineColor 下若颜色已是失焦态，仍需补 BlurIn，否则未上色过的目标会一直保持清晰。
        /// </summary>
        private void ApplyUnfocusedEffectSilent(EyeTarget target)
        {
            if (target == null || eyeStateEffect == null)
            {
                return;
            }

            if (_currentState == EyeColorState.CanImagineColor
                && target.IsAtUnfocusedColorState(visualSettings))
            {
                target.BlurIn(GetEffectTransitionDuration());
                return;
            }

            eyeStateEffect.ApplyUnfocusedEffect(target, this);
        }

        private IEnumerator RunUnfocusedEffect(EyeTarget target)
        {
            if (target == null || eyeStateEffect == null)
            {
                yield break;
            }

            eyeStateEffect.ApplyUnfocusedEffect(target, this);
            yield return new WaitForSeconds(GetEffectTransitionDuration());
        }

        private void OnValidate()
        {
            ApplyVisualSettingsNow(
                previewIdleState: !Application.isPlaying,
                replayFocusedEffect: Application.isPlaying && replayFocusedEffectOnSettingsChange,
                touchViewportOverlay: false);
        }

        /// <summary>
        /// 将 Visual Tuning 推送到所有 EyeTarget。Edit 模式预览 idle；Play 模式可选重播当前目标效果。
        /// </summary>
        public void ApplyVisualSettingsNow(
            bool previewIdleState = false,
            bool replayFocusedEffect = false,
            bool touchViewportOverlay = true)
        {
            if (targets == null)
            {
                return;
            }

            foreach (EyeTarget target in targets)
            {
                if (target == null)
                {
                    continue;
                }

                target.BindVisualSettings(visualSettings);
                if (previewIdleState)
                {
                    target.ApplyIdlePreviewState();
                }
            }

            if (touchViewportOverlay && Application.isPlaying)
            {
                EnsureViewportOverlay()?.ApplySettings(visualSettings);
            }

            if (!replayFocusedEffect || !Application.isPlaying || currentTarget == null || eyeStateEffect == null)
            {
                return;
            }

            currentTarget.KillVisualTweens();
            eyeStateEffect.ApplyFocusedEffect(currentTarget, this);
        }

        private void ApplyVisualSettingsToTargets()
        {
            ApplyVisualSettingsNow();
        }

        public enum EyeColorState
        {
            CanImagineColor,
            CannotImagineColor,
            EyeDisorder,
            CanSeeColor,
            HaveChip
        }

        private void Awake()
        {
            Init();
        }

        private EyeViewportOverlay EnsureViewportOverlay()
        {
            if (viewportOverlay != null)
            {
                return viewportOverlay;
            }

            viewportOverlay = GetComponentInChildren<EyeViewportOverlay>(true);
            if (viewportOverlay == null)
            {
                viewportOverlay = gameObject.AddComponent<EyeViewportOverlay>();
            }

            return viewportOverlay;
        }

        private bool EnsureMouseFollowAndZoom()
        {
            if (mouseFollowAndZoom != null)
            {
                return true;
            }

            mouseFollowAndZoom = FindObjectOfType<MouseFollowAndZoom>(true);
            if (mouseFollowAndZoom == null)
            {
                Debug.LogError("[EyeSystem] MouseFollowAndZoom 未找到，无法进入视觉模块。", this);
                return false;
            }

            return true;
        }

        private Vector2 GetFocusViewportSize()
        {
            if (EnsureMouseFollowAndZoom())
            {
                Vector2 viewportSize = mouseFollowAndZoom.GetViewportWorldSize();
                if (viewportSize.sqrMagnitude > 0f)
                {
                    return viewportSize;
                }
            }

            Camera focusCamera = CameraKit.Instance != null
                ? CameraKit.Instance.GetCurrentCamera()
                : Camera.main;
            if (focusCamera == null || !focusCamera.orthographic)
            {
                return Vector2.zero;
            }

            float height = focusCamera.orthographicSize * 2f;
            return new Vector2(height * focusCamera.aspect, height);
        }

        private static Transform GetFocusTransform(EyeTarget target)
        {
            if (target == null)
            {
                return null;
            }

            return target.targetTransform ? target.targetTransform : target.transform;
        }

        public void FocusOnTarget(EyeTarget target, float duration)
        {
            Transform focusTransform = GetFocusTransform(target);
            if (focusTransform == null || !EnsureMouseFollowAndZoom())
            {
                return;
            }

            if (duration > 0.01f)
            {
                PlayPresentationSfx("event:/ActionFB/visualturn");
            }

            mouseFollowAndZoom.MoveFocusTo(
                focusTransform,
                ScaleDuration(duration),
                focusMinBounds,
                focusMaxBounds,
                GetFocusViewportSize());
        }

        public void Init()
        {
            FixSystemCenter.SystemDic.Register(this);
        }

        public EyeSnapshotDto CaptureEyeSnapshot()
        {
            return new EyeSnapshotDto { eyeColorState = _currentState.ToString() };
        }

        public void ApplyEyeSnapshot(EyeSnapshotDto dto)
        {
            if (dto == null || string.IsNullOrEmpty(dto.eyeColorState))
            {
                return;
            }

            if (Enum.TryParse(dto.eyeColorState, true, out EyeColorState state))
            {
                SetEyeColorState(state);
            }
        }

        public void OnEnter()
        {
            if (!EnsureMouseFollowAndZoom())
            {
                return;
            }

            mouseFollowAndZoom.SetIsActive(true);
            mouseFollowAndZoom.SetIsLock(false);
            mouseFollowAndZoom.ResetPanOrigin();
            ApplyVisualSettingsToTargets();
            InitializeAllTargets();
            EnsureViewportOverlay()?.EnterModule(visualSettings);
        }

        /// <summary>
        /// UF 等密集演出：抑制非显式眨眼（含想象过渡眨眼）；Yarn EyeBlink 仍可用。
        /// </summary>
        public void SetNonExplicitBlinkSuppressed(bool suppressed)
        {
            EnsureViewportOverlay()?.SetNonExplicitBlinkSuppressed(suppressed);
        }

        private void InitializeAllTargets()
        {
            foreach (EyeTarget target in targets)
            {
                target.Init();
            }

            if (currentTarget != null)
            {
                eyeStateEffect?.InitializeEffect(currentTarget, this);
            }
        }

        public void OnShow()
        {
        }

        public void OnExit()
        {
            EnsureViewportOverlay()?.ExitModule();

            if (currentTarget != null)
            {
                eyeStateEffect?.CleanupEffect(CurrentTarget);
            }

            if (EnsureMouseFollowAndZoom())
            {
                mouseFollowAndZoom.SetIsActive(false);
            }

            currentTarget = null;
        }

        private void Start()
        {
            ApplyVisualSettingsToTargets();
            if (targets != null)
            {
                foreach (EyeTarget target in targets)
                {
                    target?.Init();
                }
            }

            SetEyeColorState(_currentState);
            EnsureMouseFollowAndZoom();
        }

        public EyeTarget FindEyeTargetByName(string name)
        {
            return Targets.FirstOrDefault(target => target.gameObject.name == name);
        }

        public void SetTarget(EyeTarget newTarget)
        {
            if (newTarget == null)
            {
                Debug.LogError("Target is null in SetTarget");
                return;
            }

            StartCoroutine(SetTargetCoroutine(newTarget.gameObject.name));
        }

        [YarnCommand("EyeBlink")]
        public void EyeBlink(float duration = 0f)
        {
            EnsureViewportOverlay()?.PlayBlink(
                duration > 0f ? duration : null,
                restartAutoBlinkAfter: true,
                presentationSpeed: PresentationSpeed);
        }

        [YarnCommand("set_Eyetarget")]
        public IEnumerator SetTargetCoroutine(string targetName, bool startDialogue = true)
        {
            if (!EnsureMouseFollowAndZoom())
            {
                yield break;
            }

            mouseFollowAndZoom.SetIsLock(true);
            EyeTarget target = FindEyeTargetByName(targetName);
            if (target == null)
            {
                Debug.LogError("Invalid EyeTarget name: " + targetName);
                yield break;
            }

            YarnVariableStorage.Instance.SetValue("$currentEyeTarget", target.name);

            if (currentTarget == target)
            {
                mouseFollowAndZoom.SetIndicatorTarget(currentTarget);
                if (startDialogue)
                {
                    DialogController.Instance.StartDialogNode("重复看同一个目标");
                    yield return RunBlurOut(currentTarget, visualSettings.targetSwitchDuration);
                }

                yield break;
            }

            EyeTarget leavingTarget = currentTarget;
            if (leavingTarget != null)
            {
                ApplyUnfocusedEffectSilent(leavingTarget);
            }

            const float focusMoveDuration = 1f;
            float scaledFocusMove = ScaleDuration(focusMoveDuration);
            FocusOnTarget(target, focusMoveDuration);

            yield return WaitForFocusMovement(scaledFocusMove);

            currentTarget = target;
            mouseFollowAndZoom.SetIndicatorTarget(currentTarget);
            yield return RunBlurOut(currentTarget, visualSettings.targetSwitchDuration);

            if (startDialogue)
            {
                DialogController.Instance.StartDialogNode("IntoEyeView");
            }
        }

        [YarnCommand("Set_MouseMovementLockState")]
        public void SetMouseMovementLockState(bool isActive)
        {
            if (!EnsureMouseFollowAndZoom())
            {
                return;
            }

            mouseFollowAndZoom.SetIsLock(isActive);
        }

        [YarnCommand("EyeEffect_FadeIn")]
        public IEnumerator EyeEffect_FadeIn()
        {
            if (currentTarget == null)
            {
                yield break;
            }

            if (_currentState == EyeColorState.CanImagineColor
                && currentTarget.IsAtFocusedColorState(visualSettings))
            {
                yield break;
            }

            PlayPresentationSfx("event:/ActionFB/color_imagine");
            yield return RunFocusedEffectWithPreBlink(currentTarget);
        }

        [YarnCommand("EyeEffect_FadeOut")]
        public IEnumerator EyeEffect_FadeOut()
        {
            if (currentTarget == null)
            {
                yield break;
            }

            if (_currentState == EyeColorState.CanImagineColor
                && currentTarget.IsAtUnfocusedColorState(visualSettings))
            {
                yield break;
            }

            PlayPresentationSfx("event:/ActionFB/color_imagine");
            yield return RunUnfocusedEffect(currentTarget);
        }

        [YarnCommand("EyeEffect_Init")]
        public void EyeEffectInit()
        {
            ApplyVisualSettingsToTargets();
            InitializeAllTargets();
        }

        [YarnCommand("EyeEffect_Clean")]
        public void EyeEffectClean()
        {
            if (currentTarget != null)
            {
                eyeStateEffect?.CleanupEffect(currentTarget);
            }
        }

        [YarnCommand("set_EyeColorState")]
        public void SetEyeColorStateForYarn(string state)
        {
            if (!Enum.TryParse(state, true, out EyeColorState eyeState))
            {
                throw new ArgumentException("Invalid eye state: " + state, nameof(state));
            }

            SetEyeColorState(eyeState);
        }

        private void SetEyeColorState(EyeColorState state)
        {
            _currentState = state;
            eyeStateEffect = state switch
            {
                EyeColorState.CanImagineColor => new CanImagineColorEffect(),
                EyeColorState.CannotImagineColor => new CannotImagineColorEffect(),
                EyeColorState.EyeDisorder => new EyeDisorderEffect(),
                EyeColorState.CanSeeColor => new CanSeeColorEffect(),
                EyeColorState.HaveChip => new HaveChip(),
                _ => throw new ArgumentException("Unknown eye state: " + state, nameof(state))
            };
        }

        [YarnCommand("Set_Saturation")]
        public IEnumerator Set_Saturation(float targetSaturation, float duration)
        {
            targetSaturation = Mathf.Clamp01(targetSaturation);
            duration = ScaleDuration(duration);

            Sequence saturationSequence = DOTween.Sequence();
            if (!TryJoinTargetSaturation(saturationSequence, targetSaturation, duration))
            {
                Debug.LogWarning("[EyeSystem] 无可用 EyeTarget 饱和度 tween。", this);
                yield break;
            }

            Tween saturationTween = ScreenEffectManager.Instance != null
                ? ScreenEffectManager.Instance.TweenSaturation(targetSaturation, duration)
                : null;
            if (saturationTween != null)
            {
                saturationSequence.Join(saturationTween);
            }

            yield return saturationSequence.WaitForCompletion();
        }

        [YarnCommand("EyeGlitch_in")]
        public IEnumerator EyeGlitch_in()
        {
            if (!TryStartUnifiedGlitch())
            {
                Debug.LogWarning("[EyeSystem] 无可用 EyeTarget Glitch tween。", this);
            }

            yield return new WaitForSeconds(ScaleDuration(visualSettings.glitchInDuration));
        }

        [YarnCommand("EyeGlitch_out")]
        public void EyeGlitch_out(float duration)
        {
            float resolved = duration > 0f ? duration : visualSettings.glitchOutDuration;
            TryStopUnifiedGlitch(ScaleDuration(resolved));
        }

        [YarnCommand("set_EyeColor")]
        public IEnumerator SetEyeColor(string color, string memoryName = null)
        {
            if (memoryRender == null)
            {
                Debug.LogError("[EyeSystem] memoryRender 未赋值。", this);
                yield break;
            }

            Material memoryMaterial = memoryRender.material;
            memoryRender.sprite = null;
            memoryMaterial.SetFloat("_FullDistortionFade", 0f);
            memoryMaterial.SetFloat("_SqueezePower", 18f);

            if (memoryName != null)
            {
                var memoryKey = string.Format(MemorySpritePath, memoryName);
                var memoryHandle = ResourceSystem.LoadAsync<Sprite>(memoryKey);
                yield return memoryHandle;
                if (memoryHandle.Status != AsyncOperationStatus.Succeeded || memoryHandle.Result == null)
                {
                    Debug.LogWarning("Memory not found: " + memoryKey);
                    yield break;
                }

                memoryRender.sprite = memoryHandle.Result;
                memoryRender.gameObject.SetActive(true);

                float fadeIn = ScaleDuration(1.5f);
                float hold = ScaleDuration(1.5f);
                float squeeze = ScaleDuration(2f);
                float fadeOut = ScaleDuration(0.5f);
                float fadeOutAt = fadeIn + hold + squeeze;

                Sequence memorySequence = DOTween.Sequence();
                memorySequence.Append(memoryMaterial.DOFloat(0.85f, "_FullDistortionFade", fadeIn));
                memorySequence.AppendInterval(hold);
                memorySequence.Append(memoryMaterial.DOFloat(0f, "_SqueezePower", squeeze));
                memorySequence.Insert(fadeOutAt, memoryMaterial.DOFloat(0f, "_FullDistortionFade", fadeOut).OnComplete(() =>
                {
                    memoryRender.gameObject.SetActive(false);
                }));

                yield return memorySequence.WaitForCompletion();
            }

            Sequence sequence = DOTween.Sequence();

            Sequence waveIn = CreateTargetRoundWaveSequence(1f, ScaleDuration(visualSettings.roundWaveInDuration));
            if (waveIn != null)
            {
                sequence.Append(waveIn);
            }

            sequence.AppendCallback(() => { EyeGlitch_out(visualSettings.glitchOutDuration); });

            Sequence waveOut = CreateTargetRoundWaveSequence(0f, ScaleDuration(visualSettings.roundWaveOutDuration));
            if (waveOut != null)
            {
                sequence.Append(waveOut);
            }

            sequence.Play();
            yield return sequence.WaitForCompletion();
        }

        [YarnCommand("EyeGetColor")]
        public void GetColor()
        {
            SetEyeColorState(EyeColorState.CanImagineColor);
            foreach (EyeTarget target in targets)
            {
                target.ColorBack();
            }
        }

        public void SetUnifiedUfWeights(float ascii, float dream, float memory)
        {
            foreach (EyeTarget target in targets)
            {
                target.SetUfWeights(ascii, dream, memory);
            }
        }

        public Tween TweenUnifiedUfWeights(float ascii, float dream, float memory, float duration)
        {
            duration = ScaleDuration(duration);
            Sequence sequence = DOTween.Sequence();
            bool hasTween = false;

            foreach (EyeTarget target in targets)
            {
                Tween tween = target.TweenUfWeights(ascii, dream, memory, duration);
                if (tween == null)
                {
                    continue;
                }

                sequence.Join(tween);
                hasTween = true;
            }

            return hasTween ? sequence : null;
        }

        private bool TryJoinTargetSaturation(Sequence sequence, float saturation, float duration)
        {
            bool hasTween = false;
            foreach (EyeTarget target in targets)
            {
                Tween tween = target.TweenSaturation(saturation, duration);
                if (tween == null)
                {
                    continue;
                }

                sequence.Join(tween);
                hasTween = true;
            }

            return hasTween;
        }

        private bool TryStartUnifiedGlitch()
        {
            glitchin?.Kill();
            glitchin = DOTween.Sequence();
            bool hasTween = false;

            foreach (EyeTarget target in targets)
            {
                Sequence targetGlitch = target.StartUnifiedGlitch(ScaleDuration(visualSettings.glitchInDuration));
                if (targetGlitch == null)
                {
                    continue;
                }

                glitchin.Join(targetGlitch);
                hasTween = true;
            }

            return hasTween;
        }

        private bool TryStopUnifiedGlitch(float duration)
        {
            bool hasTarget = false;
            if (glitchin != null && glitchin.IsActive())
            {
                glitchin.Kill();
                hasTarget = true;
            }

            foreach (EyeTarget target in targets)
            {
                if (!target.TryGetUnifiedVisual(out _))
                {
                    continue;
                }

                target.StopUnifiedGlitch(duration);
                hasTarget = true;
            }

            return hasTarget;
        }

        private Sequence CreateTargetRoundWaveSequence(float value, float duration)
        {
            Sequence sequence = DOTween.Sequence();
            bool hasTween = false;

            foreach (EyeTarget target in targets)
            {
                Tween tween = target.TweenRoundWave(value, duration);
                if (tween != null)
                {
                    sequence.Join(tween);
                    hasTween = true;
                }
            }

            return hasTween ? sequence : null;
        }
    }
}