using System;
using System.Collections;
using UnityEngine;
using UnityEngine.InputSystem;

public class FishingGameManager : MonoBehaviour
{
    public enum ResultType
    {
        Perfect,
        Good,
        Miss
    }

    [Header("Auto Bind")]
    [Tooltip("현재 만든 Prefab 구조 기준으로 비어 있는 참조를 자동 연결합니다.")]
    [SerializeField] private bool autoBindMissingReferences = true;

    [Header("References")]
    [Tooltip("낚시 UI 전체 루트입니다. UI를 자동으로 켜고 끄고 싶을 때만 연결하세요.")]
    [SerializeField] private GameObject uiRoot;

    [SerializeField] private FishingGaugeUI ui;
    [SerializeField] private FishingRewardSystem rewardSystem;
    [SerializeField] private FishingHapticManager haptic;
    [SerializeField] private RotateUI centerIconRotate;

    [Header("XR Controller Input")]
    [Tooltip("낚시 판정을 실행할 컨트롤러 입력입니다. 예: XRI Right Interaction / Select")]
    [SerializeField] private InputActionReference submitAction;

    [Tooltip("낚시를 다시 시작할 컨트롤러 입력입니다. 필요 없으면 비워둬도 됩니다.")]
    [SerializeField] private InputActionReference resetAction;

    [Tooltip("씬에 Input Action Manager가 없거나 액션이 자동 활성화되지 않으면 켜두세요.")]
    [SerializeField] private bool enableInputActionsManually = true;

    [Header("Pointer")]
    [SerializeField] private float pointerAngle;
    [SerializeField] private float pointerSpeed = 180f;
    [SerializeField] private float minSpeed = 180f;
    [SerializeField] private float maxSpeed = 450f;

    [Header("Zone")]
    [SerializeField] private float startZoneSize = 90f;
    [SerializeField] private float zoneSize = 90f;
    [SerializeField] private float minZoneSize = 30f;
    [SerializeField] private float maxZoneSize = 120f;
    [SerializeField] private float zoneCenter;

    [Header("Catch Rules")]
    [Tooltip("아이템 1개를 낚기 위해 필요한 성공 횟수입니다.")]
    [SerializeField] private int requiredSuccesses = 3;

    [Tooltip("아이템 1개를 낚는 동안 허용되는 실패 횟수입니다. 초과하면 낚싯줄이 끊어진 것으로 처리합니다.")]
    [SerializeField] private int allowedFails = 3;

    [Header("Pond Cleanup Rules")]
    [Tooltip("연못을 맑게 만들기 위해 필요한 쓰레기성 아이템 수입니다. 쓰레기, 병, 봉지가 여기에 포함됩니다.")]
    [SerializeField] private int requiredCleanupItems = 3;

    [Tooltip("연못이 맑아진 뒤 다음 성공 낚시에서 기억의 조각을 확정으로 낚습니다.")]
    [SerializeField] private bool guaranteeMemoryPieceAfterCleaned = true;

    [Tooltip("StartFishing을 호출할 때 쓰레기 수거/연못 상태를 초기화합니다.")]
    [SerializeField] private bool resetPondStateOnStart = true;

    [Header("Round Settings")]
    [SerializeField] private float nextRoundDelay = 0.35f;
    [SerializeField] private float nextCatchDelay = 2.0f;
    [SerializeField] private bool randomDirectionEachRound = true;
    [SerializeField] private bool resetDifficultyEachCatch = true;
    [SerializeField] private bool startOnAwake = true;

    [Header("Final Result Settings")]
    [Tooltip("최종 결과를 잠깐 보여준 뒤 uiRoot를 자동으로 끕니다. uiRoot가 비어 있으면 동작하지 않습니다.")]
    [SerializeField] private bool hideUIRootAfterFinalResult = false;

    [SerializeField] private float finalResultShowTime = 1.5f;

    [Header("Debug")]
    [SerializeField] private bool showDebugLog = true;

    private int successCount;
    private int failCount;
    private int cleanupItemCount;
    private int totalCaughtItems;

    // 임시 낚시 세션 카운트입니다. 나중에 공용 인벤토리와 연결할 때는 저장용으로 쓰지 말고 UI 표시용으로만 쓰세요.
    private int sessionFishCount;
    private int sessionTrashCount;
    private int sessionMemoryPieceCount;
    private int sessionCompassCount;

    private bool clockwise = true;
    private bool activeGame;
    private bool inputLocked;
    private bool pondCleaned;
    private bool memoryPieceCollected;

    private bool submitActionWasEnabled;
    private bool resetActionWasEnabled;

    private Coroutine nextRoundRoutine;
    private Coroutine nextCatchRoutine;
    private Coroutine finalResultRoutine;

    public bool IsActiveGame => activeGame;
    public bool IsPondCleaned => pondCleaned;
    public bool IsMemoryPieceCollected => memoryPieceCollected;
    public int SuccessCount => successCount;
    public int FailCount => failCount;
    public int CleanupItemCount => cleanupItemCount;
    public int RequiredCleanupItems => requiredCleanupItems;
    public int TotalCaughtItems => totalCaughtItems;
    public int SessionFishCount => sessionFishCount;
    public int SessionTrashCount => sessionTrashCount;
    public int SessionMemoryPieceCount => sessionMemoryPieceCount;
    public int SessionCompassCount => sessionCompassCount;

    public event Action<FishingItemType, int> ItemCaught;

    private void OnEnable()
    {
        RegisterInputAction(submitAction, OnSubmitAction, ref submitActionWasEnabled);
        RegisterInputAction(resetAction, OnResetAction, ref resetActionWasEnabled);
    }

    private void OnDisable()
    {
        UnregisterInputAction(submitAction, OnSubmitAction, submitActionWasEnabled);
        UnregisterInputAction(resetAction, OnResetAction, resetActionWasEnabled);
    }

    private void Start()
    {
        if (autoBindMissingReferences)
            AutoBindMissingReferences();

        ValidateRuntimeSettings();

        if (startOnAwake)
        {
            StartFishing();
        }
        else
        {
            InitializeIdleUI();
        }
    }

    private void Update()
    {
        if (!activeGame)
            return;

        if (inputLocked)
            return;

        RotatePointer();
    }

    private void OnValidate()
    {
        ValidateRuntimeSettings();
    }



    [ContextMenu("Auto Bind Fishing References")]
    public void AutoBindMissingReferences()
    {
        Transform searchRoot = GetSearchRoot();

        if (uiRoot == null)
        {
            Transform canvasTransform = FindTransformRecursive(searchRoot, "FishingCanvas");
            if (canvasTransform != null)
                uiRoot = canvasTransform.gameObject;
        }

        if (ui == null)
            ui = searchRoot != null ? searchRoot.GetComponentInChildren<FishingGaugeUI>(true) : GetComponentInChildren<FishingGaugeUI>(true);

        if (rewardSystem == null)
            rewardSystem = searchRoot != null ? searchRoot.GetComponentInChildren<FishingRewardSystem>(true) : GetComponentInChildren<FishingRewardSystem>(true);

        if (haptic == null)
            haptic = searchRoot != null ? searchRoot.GetComponentInChildren<FishingHapticManager>(true) : GetComponentInChildren<FishingHapticManager>(true);

        if (centerIconRotate == null)
        {
            Transform centerIconTransform = FindTransformRecursive(searchRoot, "CenterIcon");
            if (centerIconTransform != null)
                centerIconRotate = centerIconTransform.GetComponent<RotateUI>();

            if (centerIconRotate == null && searchRoot != null)
                centerIconRotate = searchRoot.GetComponentInChildren<RotateUI>(true);
        }
    }

    private Transform GetSearchRoot()
    {
        Transform current = transform;

        while (current.parent != null)
            current = current.parent;

        return current;
    }

    private Transform FindTransformRecursive(Transform current, string targetName)
    {
        if (current == null || string.IsNullOrEmpty(targetName))
            return null;

        if (NormalizeName(current.name) == NormalizeName(targetName))
            return current;

        for (int i = 0; i < current.childCount; i++)
        {
            Transform found = FindTransformRecursive(current.GetChild(i), targetName);
            if (found != null)
                return found;
        }

        return null;
    }

    private string NormalizeName(string value)
    {
        return value.Replace(" ", string.Empty)
                    .Replace("_", string.Empty)
                    .Replace("-", string.Empty)
                    .ToLowerInvariant();
    }

    private void RegisterInputAction(InputActionReference actionReference, System.Action<InputAction.CallbackContext> callback, ref bool wasEnabled)
    {
        if (actionReference == null || actionReference.action == null)
            return;

        wasEnabled = actionReference.action.enabled;
        actionReference.action.performed += callback;

        if (enableInputActionsManually && !wasEnabled)
            actionReference.action.Enable();
    }

    private void UnregisterInputAction(InputActionReference actionReference, System.Action<InputAction.CallbackContext> callback, bool wasEnabled)
    {
        if (actionReference == null || actionReference.action == null)
            return;

        actionReference.action.performed -= callback;

        if (enableInputActionsManually && !wasEnabled)
            actionReference.action.Disable();
    }

    private void ValidateRuntimeSettings()
    {
        requiredSuccesses = Mathf.Max(1, requiredSuccesses);
        allowedFails = Mathf.Max(1, allowedFails);
        requiredCleanupItems = Mathf.Max(1, requiredCleanupItems);

        minSpeed = Mathf.Max(1f, minSpeed);
        maxSpeed = Mathf.Max(minSpeed, maxSpeed);
        pointerSpeed = Mathf.Clamp(pointerSpeed, minSpeed, maxSpeed);

        minZoneSize = Mathf.Clamp(minZoneSize, 1f, 360f);
        maxZoneSize = Mathf.Clamp(maxZoneSize, minZoneSize, 360f);
        startZoneSize = Mathf.Clamp(startZoneSize, minZoneSize, maxZoneSize);
        zoneSize = Mathf.Clamp(zoneSize, minZoneSize, maxZoneSize);

        nextRoundDelay = Mathf.Max(0f, nextRoundDelay);
        nextCatchDelay = Mathf.Max(0f, nextCatchDelay);
        finalResultShowTime = Mathf.Max(0f, finalResultShowTime);

        pointerAngle = Normalize(pointerAngle);
        zoneCenter = Normalize(zoneCenter);
        cleanupItemCount = Mathf.Max(0, cleanupItemCount);
        totalCaughtItems = Mathf.Max(0, totalCaughtItems);
    }

    private void InitializeIdleUI()
    {
        if (ui != null)
        {
            ui.InitializeFishingUI();
            ui.UpdateCounter(0, requiredSuccesses, 0, allowedFails);
            ui.UpdateFishingProgress(cleanupItemCount, requiredCleanupItems, pondCleaned, memoryPieceCollected, totalCaughtItems);
            ui.UpdateInventoryUI(sessionFishCount, sessionTrashCount, sessionMemoryPieceCount, sessionCompassCount);
            ui.SetPointerRotation(0f);
            ui.SetZone(0f, startZoneSize);
        }

        if (centerIconRotate != null)
            centerIconRotate.StopRotate();
    }

    public void StartFishing()
    {
        ValidateRuntimeSettings();
        StopRunningRoutines();

        if (uiRoot != null)
            uiRoot.SetActive(true);

        if (resetPondStateOnStart)
            ResetPondState();

        if (ui != null)
            ui.InitializeFishingUI();

        StartNewCatchAttempt();

        if (showDebugLog)
            Debug.Log("기묘한 낚시터 시작");
    }

    public void StopFishing(bool hideUI = false)
    {
        StopRunningRoutines();

        activeGame = false;
        inputLocked = true;

        if (centerIconRotate != null)
            centerIconRotate.StopRotate();

        if (hideUI && uiRoot != null)
            uiRoot.SetActive(false);
    }

    public void ResetFishing()
    {
        StartFishing();
    }

    public void ResetPondState()
    {
        successCount = 0;
        failCount = 0;
        cleanupItemCount = 0;
        totalCaughtItems = 0;
        sessionFishCount = 0;
        sessionTrashCount = 0;
        sessionMemoryPieceCount = 0;
        sessionCompassCount = 0;
        pondCleaned = false;
        memoryPieceCollected = false;
    }

    private void StartNewCatchAttempt()
    {
        successCount = 0;
        failCount = 0;
        inputLocked = false;
        activeGame = true;

        if (resetDifficultyEachCatch)
        {
            pointerAngle = 0f;
            pointerSpeed = minSpeed;
            zoneSize = startZoneSize;
        }

        clockwise = UnityEngine.Random.value > 0.5f;

        if (centerIconRotate != null)
        {
            centerIconRotate.ResetRotation();
            centerIconRotate.StartRotate();
        }

        RandomizeZone();
        UpdateUI();
    }

    private void StopRunningRoutines()
    {
        if (nextRoundRoutine != null)
        {
            StopCoroutine(nextRoundRoutine);
            nextRoundRoutine = null;
        }

        if (nextCatchRoutine != null)
        {
            StopCoroutine(nextCatchRoutine);
            nextCatchRoutine = null;
        }

        if (finalResultRoutine != null)
        {
            StopCoroutine(finalResultRoutine);
            finalResultRoutine = null;
        }
    }

    private void RotatePointer()
    {
        float dir = clockwise ? 1f : -1f;

        pointerAngle += dir * pointerSpeed * Time.deltaTime;
        pointerAngle = Normalize(pointerAngle);

        if (ui != null)
            ui.SetPointerRotation(pointerAngle);
    }

    public void SubmitAttempt()
    {
        if (!activeGame)
            return;

        if (inputLocked)
            return;

        inputLocked = true;

        if (ui != null)
            ui.HideControllerGuide();

        ResultType result = EvaluateResult();

        if (ui != null)
        {
            ui.ShowResultForType(result);
            ui.FlashFeedbackForType(result);
        }

        switch (result)
        {
            case ResultType.Perfect:
                OnPerfect();
                break;

            case ResultType.Good:
                OnGood();
                break;

            case ResultType.Miss:
                OnMiss();
                break;
        }

        if (successCount >= requiredSuccesses)
        {
            CatchItemSuccess();
            return;
        }

        if (failCount >= allowedFails)
        {
            FishingFail();
            return;
        }

        nextRoundRoutine = StartCoroutine(NextRoundRoutine());
    }

    private ResultType EvaluateResult()
    {
        float delta = Mathf.Abs(Mathf.DeltaAngle(pointerAngle, zoneCenter));

        float perfectRange = zoneSize * 0.2f;
        float goodRange = zoneSize * 0.5f;

        if (delta <= perfectRange)
            return ResultType.Perfect;

        if (delta <= goodRange)
            return ResultType.Good;

        return ResultType.Miss;
    }

    private void OnPerfect()
    {
        successCount++;

        zoneSize *= 0.9f;
        pointerSpeed *= 1.05f;

        if (haptic != null)
            haptic.Perfect();

        if (showDebugLog)
            Debug.Log("낚시 판정: Perfect");

        ClampDifficulty();
        UpdateUI();
    }

    private void OnGood()
    {
        successCount++;

        zoneSize *= 0.95f;
        pointerSpeed *= 1.02f;

        if (haptic != null)
            haptic.Good();

        if (showDebugLog)
            Debug.Log("낚시 판정: Good");

        ClampDifficulty();
        UpdateUI();
    }

    private void OnMiss()
    {
        failCount++;

        zoneSize *= 1.05f;
        pointerSpeed *= 0.95f;

        if (haptic != null)
            haptic.Miss();

        if (showDebugLog)
            Debug.Log("낚시 판정: Miss");

        ClampDifficulty();
        UpdateUI();
    }

    private IEnumerator NextRoundRoutine()
    {
        yield return new WaitForSeconds(nextRoundDelay);

        if (!activeGame)
        {
            nextRoundRoutine = null;
            yield break;
        }

        if (randomDirectionEachRound)
            clockwise = UnityEngine.Random.value > 0.5f;

        RandomizeZone();
        UpdateUI();

        inputLocked = false;
        nextRoundRoutine = null;
    }

    private void CatchItemSuccess()
    {
        activeGame = false;
        inputLocked = true;

        if (centerIconRotate != null)
            centerIconRotate.StopRotate();

        bool forceMemoryPiece = pondCleaned && guaranteeMemoryPieceAfterCleaned && !memoryPieceCollected;

        FishingRewardSystem.CatchResult catchResult;

        if (rewardSystem != null)
            catchResult = rewardSystem.RollCatch(pondCleaned, forceMemoryPiece);
        else
            catchResult = new FishingRewardSystem.CatchResult(FishingItemType.Fish, "생선", false, false);

        ApplyCatchResult(catchResult);
    }

    private void ApplyCatchResult(FishingRewardSystem.CatchResult catchResult)
    {
        totalCaughtItems++;

        AddToSessionCounts(catchResult.ItemType);
        ItemCaught?.Invoke(catchResult.ItemType, 1);

        bool pondJustCleaned = false;
        string extraHint = string.Empty;

        if (catchResult.CountsAsCleanupItem)
        {
            cleanupItemCount = Mathf.Min(cleanupItemCount + 1, requiredCleanupItems);
            extraHint = $"연못 정화 {cleanupItemCount}/{requiredCleanupItems}";

            if (!pondCleaned && cleanupItemCount >= requiredCleanupItems)
            {
                pondCleaned = true;
                pondJustCleaned = true;
                extraHint = "연못이 맑아졌다. 기억의 조각이 모습을 드러낸다.";
            }
        }

        if (catchResult.IsMemoryPiece)
        {
            memoryPieceCollected = true;
            extraHint = "잃어버린 기억의 일부다.";
        }

        UpdateUI();

        if (ui != null)
        {
            ui.HighlightSlotForItem(catchResult.ItemType);

            if (!catchResult.IsMemoryPiece)
                ui.ShowCaughtItem(catchResult.ItemType, catchResult.DisplayName, catchResult.CountsAsCleanupItem, extraHint);

            if (pondJustCleaned)
                ui.ShowNotice("연못이 맑아졌다!\n기억의 조각이 모습을 드러냈다!");

            // 기억의 조각 획득은 FinalResultPanel에서 크게 보여줍니다.
            // NoticePanel까지 동시에 띄우면 ShowFinalResult에서 바로 숨겨져 연출이 겹칠 수 있습니다.
        }

        if (showDebugLog)
            Debug.Log($"{catchResult.DisplayName}을(를) 낚았다!");

        if (catchResult.IsMemoryPiece)
        {
            FishingSuccess();
            return;
        }

        nextCatchRoutine = StartCoroutine(NextCatchRoutine());
    }

    private IEnumerator NextCatchRoutine()
    {
        yield return new WaitForSeconds(nextCatchDelay);

        if (memoryPieceCollected)
        {
            nextCatchRoutine = null;
            yield break;
        }

        StartNewCatchAttempt();
        nextCatchRoutine = null;
    }


    private void AddToSessionCounts(FishingItemType itemType)
    {
        switch (itemType)
        {
            case FishingItemType.Fish:
                sessionFishCount++;
                break;

            case FishingItemType.Trash:
            case FishingItemType.Bottle:
            case FishingItemType.PlasticBag:
                sessionTrashCount++;
                break;

            case FishingItemType.MemoryPiece:
                sessionMemoryPieceCount++;
                break;

            case FishingItemType.OldCompass:
                sessionCompassCount++;
                break;
        }
    }

    private void ClampDifficulty()
    {
        zoneSize = Mathf.Clamp(zoneSize, minZoneSize, maxZoneSize);
        pointerSpeed = Mathf.Clamp(pointerSpeed, minSpeed, maxSpeed);
    }

    private void RandomizeZone()
    {
        zoneCenter = UnityEngine.Random.Range(0f, 360f);
    }

    private void UpdateUI()
    {
        if (ui == null)
            return;

        ui.SetZone(zoneCenter, zoneSize);
        ui.UpdateCounter(successCount, requiredSuccesses, failCount, allowedFails);
        ui.UpdateFishingProgress(cleanupItemCount, requiredCleanupItems, pondCleaned, memoryPieceCollected, totalCaughtItems);
        ui.UpdateInventoryUI(sessionFishCount, sessionTrashCount, sessionMemoryPieceCount, sessionCompassCount);
    }

    private void FishingSuccess()
    {
        activeGame = false;
        inputLocked = true;

        if (centerIconRotate != null)
            centerIconRotate.StopRotate();

        UpdateUI();

        if (ui != null)
            ui.ShowFinalResult("기억의 조각 획득!\n기묘한 낚시터 클리어!");

        if (showDebugLog)
            Debug.Log("기묘한 낚시터 클리어");

        BeginFinalResultRoutineIfNeeded();
    }

    private void FishingFail()
    {
        activeGame = false;
        inputLocked = true;

        if (centerIconRotate != null)
            centerIconRotate.StopRotate();

        if (ui != null)
            ui.ShowFinalResult("낚싯줄이 끊어졌다!\n다시 천천히 낚아보자.");

        if (showDebugLog)
            Debug.Log("낚시 실패: 낚싯줄 끊어짐");

        BeginFinalResultRoutineIfNeeded();
    }

    private void BeginFinalResultRoutineIfNeeded()
    {
        if (!hideUIRootAfterFinalResult || uiRoot == null)
            return;

        if (finalResultRoutine != null)
            StopCoroutine(finalResultRoutine);

        finalResultRoutine = StartCoroutine(HideUIRootAfterFinalResultRoutine());
    }

    private IEnumerator HideUIRootAfterFinalResultRoutine()
    {
        yield return new WaitForSeconds(finalResultShowTime);

        if (uiRoot != null)
            uiRoot.SetActive(false);

        finalResultRoutine = null;
    }

    private float Normalize(float angle)
    {
        angle %= 360f;

        if (angle < 0f)
            angle += 360f;

        return angle;
    }

    private void OnSubmitAction(InputAction.CallbackContext context)
    {
        SubmitAttempt();
    }

    private void OnResetAction(InputAction.CallbackContext context)
    {
        ResetFishing();
    }
}