using UnityEngine;
using UnityEngine.UI;
using TMPro;
using System;
using System.Linq;
using System.Threading.Tasks;
using GameServer.Client;
using DG.Tweening;
using UnityEngine.Events;
using UnityEngine.SceneManagement;

public class SongDetailsUI : MonoBehaviour
{
    private const string BackSceneName = "selectYourSongFirst";
    private const float ProgressNumberMinX = -370f;
    private const float ProgressNumberMaxX = 362f;

    [Header("this_song_SO")]
    public ScriptableObject this_song_SO;

    [Header("ranking")]
    public Button rankingButton;
    public rankingList rkl;

    [Header("room")]
    public Button roomButton;
    public GameObject askPrefab;
    public GameObject roomDetailsPrefab;
    public GameObject roomRankingPrefab;
    public Transform roomSpawnPoint;

    [Header("basic UI")]
    public Image song_bgImage;

    public Text songNameText;
    public Text artistNameText;
    public Text painterNameText;
    public Text difficultyText;
    public Text difficultyDesciptionText;
    public Text charterNameText;
    public Text dlcNameText;
    public TextMeshProUGUI bpmText;
    public Text songSerialNumberText;
    public Text personalRecordText;

    // Documentation text normalized.
    public Text chartScoreText;

    public Text thisSong_progressText;
    public Text thisSong_lastScoreText; // will show last run total score if available
    public Text idolRecordText;
    public TextMeshProUGUI timeSpentText;
    public TextMeshProUGUI enterTimeText;
    public Text difficultyIdText;
    public Image progressImage;
    public GameObject progressNumberObject;
    public TextMeshProUGUI progressPercentText;
    public Text progressPercentText2;

    public Image rankLevel_img;
    public RankConfig rc;
    //public Image songImage;

    public int id_of_thisSong;

    [Header("Inspector")]
    public GameObject picDetail;
    public Image profound_image;
    public Text detail_informations_text;

    [Header("back to last scene")]
    [SerializeField] private Button backtoLastScene;

    [Header("Inspector")]
    public Button Button_EZ;
    public Button Button_HD;
    public Button Button_IN;
    public Button Button_IM;

    private SongData currentSong;
    private GameObject spawnedAskInstance;
    private GameObject spawnedRoomDetailsInstance;
    private SongData lastSyncedSong;
    private int lastSyncedDifficultyId = int.MinValue;
    private UnityAction difficultyEzAction;
    private UnityAction difficultyHdAction;
    private UnityAction difficultyInAction;
    private UnityAction difficultyImAction;
    private RectTransform progressImageRect;
    private RectTransform progressNumberRect;
    private float progressImageFullWidth = -1f;
    private float progressImageLeftEdgeX;
    private float progressImageScaleX = 1f;
    private bool progressUsesMaskWidthMode;
    [SerializeField] private float progressTweenDuration = 0.35f;
    [SerializeField] private Ease progressTweenEase = Ease.OutCubic;

    private Tween progressBarTween;
    private Tween progressNumberTween;
    private Tween progressTextTween;
    private float currentProgressVisual;
    private float currentProgressTextValue;
    private bool hasStarted;

    private SongData ResolveCurrentSong()
    {
        if (SongDataHolder.SelectedSongData != null)
        {
            currentSong = SongDataHolder.SelectedSongData;
            return currentSong;
        }

        if (currentSong != null)
        {
            return currentSong;
        }

        if (this_song_SO is SongData soSong)
        {
            currentSong = soSong;
            return currentSong;
        }

        return null;
    }

    private void OnEnable()
    {
        currentSong = ResolveCurrentSong();
        CacheProgressUiGeometry(forceRefresh: false);

        ArenaRoomService roomService = ArenaRoomService.Instance;
        if (roomService != null)
        {
            roomService.OnRoomSnapshotChanged -= HandleArenaRoomSnapshotChanged;
            roomService.OnRoomSnapshotChanged += HandleArenaRoomSnapshotChanged;
            HandleArenaRoomSnapshotChanged(roomService.CurrentRoom);
        }

        if (roomButton == null)
        {
            roomButton = FindButtonByName("roomButton");
        }

        if (rankingButton != null)
        {
            rankingButton.onClick.RemoveListener(OnRankingButtonClicked);
            rankingButton.onClick.AddListener(OnRankingButtonClicked);
        }

        if (roomButton != null)
        {
            roomButton.onClick.RemoveListener(OnRoomButtonClicked);
            roomButton.onClick.AddListener(OnRoomButtonClicked);
        }

        if (backtoLastScene != null)
        {
            backtoLastScene.onClick.RemoveListener(OnBackToLastSceneClicked);
            backtoLastScene.onClick.AddListener(OnBackToLastSceneClicked);
        }

        BindDifficultyButtons();
        PrepareDifficultyButtons();

        if (hasStarted)
        {
            ResetProgressVisualState();
            SyncSongDisplay(true);
        }
    }

    private void Update()
    {
        SyncSongDisplay(false);
    }

    private void OnDisable()
    {
        KillProgressTweens();

        ArenaRoomService roomService = ArenaRoomService.Instance;
        if (roomService != null)
        {
            roomService.OnRoomSnapshotChanged -= HandleArenaRoomSnapshotChanged;
        }

        if (rankingButton != null)
        {
            rankingButton.onClick.RemoveListener(OnRankingButtonClicked);
        }

        if (roomButton != null)
        {
            roomButton.onClick.RemoveListener(OnRoomButtonClicked);
        }

        if (backtoLastScene != null)
        {
            backtoLastScene.onClick.RemoveListener(OnBackToLastSceneClicked);
        }

        UnbindDifficultyButtons();
    }

    private void HandleArenaRoomSnapshotChanged(ArenaRoomSnapshot snapshot)
    {
        if (snapshot == null || string.IsNullOrWhiteSpace(snapshot.song_id))
        {
            return;
        }

        if (!int.TryParse(snapshot.song_id, out int songId))
        {
            Debug.LogWarning($"[SongDetailsUI] Invalid arena room song_id: {snapshot.song_id}");
            return;
        }

        SongDataLibrary library = SongDataLibrary.Instance;
        if (library == null)
        {
            Debug.LogWarning("[SongDetailsUI] SongDataLibrary is not initialized.");
            return;
        }

        SongData roomSong = library.GetSongDataByID(songId);
        if (roomSong == null)
        {
            Debug.LogWarning($"[SongDetailsUI] Room song not found for song_id={songId}");
            return;
        }

        int roomDifficultyId = ConvertDifficultyKeyToId(snapshot.difficulty);
        bool sameSong = currentSong != null && currentSong.songID == roomSong.songID;
        bool sameDifficulty = sameSong && currentSong.thisLevel_selectedDifficultyID == roomDifficultyId;
        if (sameSong && sameDifficulty)
        {
            return;
        }

        ApplySongSelection(roomSong, roomDifficultyId);
    }

    private void ApplySongSelection(SongData song, int difficultyId)
    {
        if (song == null)
        {
            return;
        }

        difficultyId = Mathf.Clamp(difficultyId, 0, 3);
        song.thisLevel_selectedDifficultyID = difficultyId;
        currentSong = song;
        this_song_SO = song;
        SongDataHolder.SelectedSongData = song;
        id_of_thisSong = song.songID;

        SyncSongDisplay(true);
    }

    private void SyncSongDisplay(bool force)
    {
        SongData song = ResolveCurrentSong();
        if (song == null)
        {
            if (force || lastSyncedSong != null)
            {
                SetDifficultyButtons(-1);
                if (difficultyText != null) difficultyText.text = string.Empty;
                if (difficultyDesciptionText != null) difficultyDesciptionText.text = string.Empty;
                if (difficultyIdText != null) difficultyIdText.text = string.Empty;
                if (personalRecordText != null) personalRecordText.text = "0";
                if (idolRecordText != null) idolRecordText.text = "0";
                if (chartScoreText != null) chartScoreText.text = "0";
                if (thisSong_lastScoreText != null) thisSong_lastScoreText.text = "0";
                if (rankLevel_img != null && rc != null) rankLevel_img.sprite = rc.defaultSprite;
                if (progressImage != null) progressImage.fillAmount = 0f;
                UpdateProgressUI(0f);
            }

            lastSyncedSong = null;
            lastSyncedDifficultyId = int.MinValue;
            return;
        }

        currentSong = song;
        this_song_SO = song;
        id_of_thisSong = song.songID;

        int selectedDifficulty = Mathf.Clamp(song.thisLevel_selectedDifficultyID, 0, 3);
        bool songChanged = lastSyncedSong != song;
        bool difficultyChanged = lastSyncedDifficultyId != selectedDifficulty;

        if (force || songChanged)
        {
            RefreshSongPresentation(song);
        }

        if (force || songChanged || difficultyChanged)
        {
            SetDifficultyButtons(selectedDifficulty);
            UpdateDifficultyUI(selectedDifficulty);
        }

        lastSyncedSong = song;
        lastSyncedDifficultyId = selectedDifficulty;
    }

    private void RefreshSongPresentation(SongData song)
    {
        if (song == null)
        {
            return;
        }

        if (song_bgImage != null) song_bgImage.sprite = song.GetResolvedBackgroundPic();
        if (songNameText != null) songNameText.text = song.songName;
        if (artistNameText != null) artistNameText.text = song.artistName;
        if (painterNameText != null) painterNameText.text = song.painter;
        if (charterNameText != null) charterNameText.text = song.level_creator;
        if (dlcNameText != null) dlcNameText.text = song.belongsTo_whichDLC;
        if (songSerialNumberText != null) songSerialNumberText.text = song.songID.ToString();
        if (bpmText != null) bpmText.text = LocalizationService.GetFormat("song.details.bpm", song.bpm);
        if (profound_image != null) profound_image.sprite = song.GetResolvedFullscreenSongPicture();
        if (timeSpentText != null) timeSpentText.text = LocalizationService.GetFormat("song.details.play_time", song.time_totalPlayingTime.ToString("F0"));
        if (enterTimeText != null) enterTimeText.text = LocalizationService.GetFormat("song.details.play_count", song.game_enterTimes);
        if (detail_informations_text != null)
        {
            detail_informations_text.text = LocalizationService.GetFormat("song.details.information",
                song.artistName, song.songName, song.painter, song.level_creator, song.belongsTo_whichDLC);
        }
    }

    private int ConvertDifficultyKeyToId(string difficultyKey)
    {
        if (string.IsNullOrWhiteSpace(difficultyKey))
        {
            return 2;
        }

        switch (difficultyKey.Trim().ToLowerInvariant())
        {
            case "ez":
                return 0;
            case "hd":
                return 1;
            case "im":
                return 3;
            case "in":
            default:
                return 2;
        }
    }

    void Start()
    {
        hasStarted = true;
        picDetail.SetActive(false);
        CacheProgressUiGeometry(forceRefresh: false);
        BindDifficultyButtons();
        PrepareDifficultyButtons();
        ResetProgressVisualState();
        SyncSongDisplay(true);
    }

    public void OnRankingButtonClicked()
    {
        SongData song = ResolveCurrentSong();
        if (song == null)
        {
            Debug.LogWarning("[SongDetailsUI] Ranking button clicked, but no song is currently selected.");
            return;
        }

        if (rkl == null)
        {
            Debug.LogWarning("[SongDetailsUI] Ranking button clicked, but rankingList reference is missing.");
            return;
        }

        rkl.Open(song.songID.ToString(), song.songName);
    }

    public void OnBackToLastSceneClicked()
    {
        if (!Bansonic.gTransition.LoadScene(BackSceneName, LoadSceneMode.Single))
        {
            SceneManager.LoadScene(BackSceneName, LoadSceneMode.Single);
        }
    }

    public async void OnRoomButtonClicked()
    {
        SongData song = ResolveCurrentSong();
        if (song == null)
        {
            Debug.LogWarning("[SongDetailsUI] Room button clicked, but no song is currently selected.");
            return;
        }

        ArenaRoomService roomService = ArenaRoomService.Instance;
        if (roomService == null)
        {
            Debug.LogWarning("[SongDetailsUI] ArenaRoomService is missing.");
            return;
        }

        if (roomService.IsInRoom)
        {
            try
            {
                await roomService.RefreshRoomInfo();
                ShowRoomDetails(roomService);
            }
            catch (Exception ex)
            {
                Debug.LogWarning($"[SongDetailsUI] Failed to refresh current room: {ex.Message}");
                DestroyRoomDetailsInstance();
                ShowRoomAsk(song, roomService);
            }
            return;
        }

        DestroyRoomDetailsInstance();
        ShowRoomAsk(song, roomService);
    }

    public void OpenRoomDetailsForCurrentRoom()
    {
        ArenaRoomService roomService = ArenaRoomService.Instance;
        if (roomService == null || !roomService.IsInRoom)
        {
            return;
        }

        HandleArenaRoomSnapshotChanged(roomService.CurrentRoom);
        DestroyAskInstance();
        ShowRoomDetails(roomService);
    }

    private void ShowRoomAsk(SongData song, ArenaRoomService roomService)
    {
        if (spawnedAskInstance != null)
        {
            Destroy(spawnedAskInstance);
        }

        GameObject askTemplate = ResolveAskTemplate();
        if (askTemplate == null)
        {
            Debug.LogWarning("[SongDetailsUI] Ask prefab/template is missing.");
            return;
        }

        spawnedAskInstance = Instantiate(askTemplate, ResolveRoomSpawnParent(), false);
        PrepareSpawnedPanel(spawnedAskInstance);
        RegisterManagedOverlay(spawnedAskInstance, DestroyAskInstance);

        roomAsk ask = spawnedAskInstance.GetComponent<roomAsk>();
        if (ask == null)
        {
            Debug.LogWarning("[SongDetailsUI] Spawned ask object has no roomAsk component.");
            return;
        }

        ask.Bind(
            async () =>
            {
                await roomService.CreateRoom(
                    song.songID.ToString(),
                    song.songName,
                    ResolveSelectedDifficultyKey(song),
                    null);
                try
                {
                    await roomService.RefreshRoomInfo();
                }
                catch (Exception ex)
                {
                    Debug.LogWarning($"[SongDetailsUI] Refresh room info after create failed: {ex.Message}");
                }
                DestroyAskInstance();
                ShowRoomDetails(roomService);
            },
            async roomCode =>
            {
                await roomService.JoinRoom(roomCode, null);
                try
                {
                    await roomService.RefreshRoomInfo();
                }
                catch (Exception ex)
                {
                    Debug.LogWarning($"[SongDetailsUI] Refresh room info after join failed: {ex.Message}");
                }
                DestroyAskInstance();
                ShowRoomDetails(roomService);
            });
    }

    private void ShowRoomDetails(ArenaRoomService roomService)
    {
        if (spawnedRoomDetailsInstance != null)
        {
            roomDetails existing = spawnedRoomDetailsInstance.GetComponent<roomDetails>();
            if (existing != null)
            {
                existing.ConfigureRoomRanking(roomRankingPrefab, ResolveRoomSpawnParent());
                existing.Bind(roomService);
                RegisterManagedOverlay(spawnedRoomDetailsInstance, DestroyRoomDetailsInstance);
            }
            return;
        }

        GameObject roomTemplate = ResolveRoomDetailsTemplate();
        if (roomTemplate == null)
        {
            Debug.LogWarning("[SongDetailsUI] Room details prefab/template is missing.");
            return;
        }

        spawnedRoomDetailsInstance = Instantiate(roomTemplate, ResolveRoomSpawnParent(), false);
        PrepareSpawnedPanel(spawnedRoomDetailsInstance);
        RegisterManagedOverlay(spawnedRoomDetailsInstance, DestroyRoomDetailsInstance);

        roomDetails details = spawnedRoomDetailsInstance.GetComponent<roomDetails>();
        if (details == null)
        {
            Debug.LogWarning("[SongDetailsUI] Spawned room details object has no roomDetails component.");
            return;
        }

        details.ConfigureRoomRanking(roomRankingPrefab, ResolveRoomSpawnParent());
        details.Bind(roomService);
    }

    private void DestroyAskInstance()
    {
        if (spawnedAskInstance != null)
        {
            UIBackStack.Unregister(spawnedAskInstance);
            Destroy(spawnedAskInstance);
            spawnedAskInstance = null;
        }
    }

    private void DestroyRoomDetailsInstance()
    {
        if (spawnedRoomDetailsInstance != null)
        {
            UIBackStack.Unregister(spawnedRoomDetailsInstance);
            Destroy(spawnedRoomDetailsInstance);
            spawnedRoomDetailsInstance = null;
        }
    }

    private GameObject ResolveAskTemplate()
    {
        if (askPrefab != null)
        {
            return askPrefab;
        }

        roomAsk sceneTemplate = FindSceneObject<roomAsk>();
        if (sceneTemplate != null)
        {
            sceneTemplate.gameObject.SetActive(false);
            return sceneTemplate.gameObject;
        }

        return null;
    }

    private GameObject ResolveRoomDetailsTemplate()
    {
        if (roomDetailsPrefab != null)
        {
            return roomDetailsPrefab;
        }

        roomDetails sceneTemplate = FindSceneObject<roomDetails>();
        if (sceneTemplate != null)
        {
            sceneTemplate.gameObject.SetActive(false);
            return sceneTemplate.gameObject;
        }

        return null;
    }

    private Transform ResolveRoomSpawnParent()
    {
        if (roomSpawnPoint != null && roomSpawnPoint.gameObject.activeInHierarchy && roomSpawnPoint.lossyScale.sqrMagnitude > 0.0001f)
        {
            return roomSpawnPoint;
        }

        Canvas canvas = null;
        if (roomButton != null)
        {
            canvas = roomButton.GetComponentsInParent<Canvas>(true).FirstOrDefault();
        }

        if (canvas == null)
        {
            canvas = GetComponentsInParent<Canvas>(true).FirstOrDefault();
        }

        if (canvas != null)
        {
            return canvas.transform;
        }

        return transform;
    }

    private void PrepareSpawnedPanel(GameObject panel)
    {
        if (panel == null)
        {
            return;
        }

        panel.SetActive(true);
        RectTransform rect = panel.GetComponent<RectTransform>();
        if (rect != null)
        {
            rect.localScale = Vector3.one;
            rect.anchoredPosition3D = Vector3.zero;
        }
    }

    private void RegisterManagedOverlay(GameObject panel, Action closeAction)
    {
        if (panel == null)
        {
            return;
        }

        UIBackStack.RegisterOrBump(
            panel,
            () => panel != null && panel.activeInHierarchy,
            () =>
            {
                closeAction?.Invoke();
                return true;
            });
    }

    private Button FindButtonByName(string objectName)
    {
        Button[] buttons = Resources.FindObjectsOfTypeAll<Button>();
        return buttons.FirstOrDefault(b => b != null
            && b.gameObject.scene.IsValid()
            && string.Equals(b.gameObject.name, objectName, StringComparison.Ordinal));
    }

    private static T FindSceneObject<T>() where T : Component
    {
        T[] all = Resources.FindObjectsOfTypeAll<T>();
        return all.FirstOrDefault(item => item != null && item.gameObject.scene.IsValid());
    }

    private string ResolveSelectedDifficultyKey(SongData song)
    {
        int selectedDifficulty = song != null ? song.thisLevel_selectedDifficultyID : 2;
        return selectedDifficulty switch
        {
            0 => "ez",
            1 => "hd",
            3 => "im",
            _ => "in",
        };
    }

    private void SetDifficultyButtons(int selectedDifficulty)
    {
        SetDifficultyButtonAlpha(Button_EZ, selectedDifficulty == 0);
        SetDifficultyButtonAlpha(Button_HD, selectedDifficulty == 1);
        SetDifficultyButtonAlpha(Button_IN, selectedDifficulty == 2);
        SetDifficultyButtonAlpha(Button_IM, selectedDifficulty == 3);
    }

    private void BindDifficultyButtons()
    {
        BindDifficultyButton(Button_EZ, 0, ref difficultyEzAction);
        BindDifficultyButton(Button_HD, 1, ref difficultyHdAction);
        BindDifficultyButton(Button_IN, 2, ref difficultyInAction);
        BindDifficultyButton(Button_IM, 3, ref difficultyImAction);
    }

    private void UnbindDifficultyButtons()
    {
        UnbindDifficultyButton(Button_EZ, difficultyEzAction);
        UnbindDifficultyButton(Button_HD, difficultyHdAction);
        UnbindDifficultyButton(Button_IN, difficultyInAction);
        UnbindDifficultyButton(Button_IM, difficultyImAction);
    }

    private void BindDifficultyButton(Button button, int difficultyId, ref UnityAction cachedAction)
    {
        if (button == null)
        {
            return;
        }

        if (cachedAction != null)
        {
            button.onClick.RemoveListener(cachedAction);
        }

        cachedAction = () => OnDifficultySelected(difficultyId);
        button.onClick.AddListener(cachedAction);
    }

    private void UnbindDifficultyButton(Button button, UnityAction cachedAction)
    {
        if (button == null || cachedAction == null)
        {
            return;
        }

        button.onClick.RemoveListener(cachedAction);
    }

    private void PrepareDifficultyButtons()
    {
        ForceDifficultyButtonVisualMode(Button_EZ);
        ForceDifficultyButtonVisualMode(Button_HD);
        ForceDifficultyButtonVisualMode(Button_IN);
        ForceDifficultyButtonVisualMode(Button_IM);
    }

    private void ForceDifficultyButtonVisualMode(Button button)
    {
        if (button == null)
        {
            return;
        }

        button.transition = Selectable.Transition.None;
    }

    private void SetDifficultyButtonAlpha(Button button, bool active)
    {
        if (button == null)
        {
            return;
        }

        Graphic graphic = button.targetGraphic != null ? button.targetGraphic : button.image;
        if (graphic == null)
        {
            return;
        }

        graphic.DOKill(false);
        graphic.DOFade(active ? 1f : 0f, 0.18f).SetEase(Ease.OutCubic);
    }

    private void OnDifficultySelected(int difficulty)
    {
        if (currentSong != null)
        {
            currentSong.thisLevel_selectedDifficultyID = difficulty;
            SetDifficultyButtons(difficulty);
            UpdateDifficultyUI(difficulty);
        }
    }

    private void UpdateDifficultyUI(int difficulty)
    {
        if (currentSong == null)
        {
            return;
        }

        var entry = GetChartEntry(difficulty);
        if (entry != null)
        {
            if (difficultyText != null)
                difficultyText.text = entry.difficultyLEVEL.ToString("0.0");
            if (difficultyDesciptionText != null)
                difficultyDesciptionText.text = string.IsNullOrEmpty(entry.difficultyDescription) ? entry.difficultyName : entry.difficultyDescription;

            if (difficultyIdText != null)
                difficultyIdText.text = entry.difficultyLEVEL.ToString("0.0");

            UpdateProgressUI(entry.levelProgressForThisDifficulty);

            // read values from SongData (SO)
            int chartPersonal = currentSong.GetPersonalRecord(difficulty); // Documentation text normalized.
            int idol = currentSong.GetIdolRecord(difficulty); // Documentation text normalized.

            // Determine total: prefer stored total if present (>0), otherwise compute chartPersonal + idol
            int total;
            if (entry.totalPersonalRecordForThisDifficulty > 0)
            {
                total = entry.totalPersonalRecordForThisDifficulty;
            }
            else
            {
                total = chartPersonal + idol;
            }

            // show total (personalRecord) and idol separately
            personalRecordText.text = total.ToString();
            if (idolRecordText != null)
                idolRecordText.text = idol.ToString();

            // Documentation text normalized.
            if (chartScoreText != null)
                chartScoreText.text = chartPersonal.ToString();

            // show last run total score if UI text provided
            if (thisSong_lastScoreText != null)
            {
                int lastRun = currentSong.GetChartScore(difficulty);
                thisSong_lastScoreText.text = lastRun.ToString();
            }

            if (rankLevel_img != null && rc != null)
                rankLevel_img.sprite = rc.GetRankSprite(total);

            // also keep per-entry convenience fields in sync for inspector visibility
            entry.chartPersonalRecordForThisDifficulty = chartPersonal;
            entry.idolPersonalRecordForThisDifficulty = idol;
            entry.totalPersonalRecordForThisDifficulty = total;
        }
        else
        {
            if (difficultyText != null)
                difficultyText.text = difficulty.ToString();
            if (difficultyIdText != null)
                difficultyIdText.text = difficulty.ToString();
            UpdateProgressUI(0f);
            if (difficultyDesciptionText != null)
                difficultyDesciptionText.text = "";
            if (personalRecordText != null)
                personalRecordText.text = "0";
            if (idolRecordText != null)
                idolRecordText.text = "0";
            if (chartScoreText != null)
                chartScoreText.text = "0";
            if (thisSong_lastScoreText != null)
                thisSong_lastScoreText.text = "0";
            if (rankLevel_img != null && rc != null)
                rankLevel_img.sprite = rc.defaultSprite;
        }
    }

    private void UpdateProgressUI(float progress)
    {
        CacheProgressUiGeometry(forceRefresh: false);

        // 2. Clamp for visual elements (fillAmount and Object position)
        float clampedProgress = Mathf.Clamp01(progress);

        AnimateProgressVisual(clampedProgress);
        AnimateProgressText(progress);
    }

    private void CacheProgressUiGeometry(bool forceRefresh)
    {
        if (progressImage != null && (forceRefresh || progressImageRect == null))
        {
            progressImageRect = progressImage.rectTransform;
        }

        if (progressNumberObject != null && (forceRefresh || progressNumberRect == null))
        {
            progressNumberRect = progressNumberObject.GetComponent<RectTransform>();
        }

        if (progressImageRect == null)
        {
            return;
        }

        if (forceRefresh || progressImageFullWidth <= 0f)
        {
            progressImageFullWidth = progressImageRect.sizeDelta.x;
            progressImageScaleX = Mathf.Abs(progressImageRect.localScale.x);
            progressImageLeftEdgeX = progressImageRect.anchoredPosition.x - (progressImageFullWidth * progressImageScaleX * 0.5f);
        }

        progressUsesMaskWidthMode = progressImage != null
                                    && progressImage.GetComponent<Mask>() != null
                                    && progressImage.transform.childCount > 0;
    }

    private void ResetProgressVisualState()
    {
        CacheProgressUiGeometry(forceRefresh: false);
        KillProgressTweens();
        currentProgressVisual = 0f;
        currentProgressTextValue = 0f;
        ApplyProgressBarVisual(0f);
        ApplyProgressNumberPosition(0f);
        ApplyProgressTextValue(0f);
    }

    private void KillProgressTweens()
    {
        if (progressBarTween != null && progressBarTween.IsActive())
        {
            progressBarTween.Kill();
        }

        if (progressNumberTween != null && progressNumberTween.IsActive())
        {
            progressNumberTween.Kill();
        }

        if (progressTextTween != null && progressTextTween.IsActive())
        {
            progressTextTween.Kill();
        }
    }

    private void AnimateProgressVisual(float clampedProgress)
    {
        KillProgressTweens();

        progressBarTween = DOTween.To(
                () => currentProgressVisual,
                value =>
                {
                    currentProgressVisual = value;
                    ApplyProgressBarVisual(value);
                },
                clampedProgress,
                progressTweenDuration)
            .SetEase(progressTweenEase)
            .OnComplete(() =>
            {
                currentProgressVisual = clampedProgress;
                ApplyProgressBarVisual(clampedProgress);
            });

        if (progressNumberRect != null)
        {
            progressNumberTween = progressNumberRect
                .DOAnchorPosX(Mathf.Lerp(ProgressNumberMinX, ProgressNumberMaxX, clampedProgress), progressTweenDuration)
                .SetEase(progressTweenEase);
        }
    }

    private void AnimateProgressText(float targetProgressValue)
    {
        float safeTargetValue = Mathf.Max(0f, targetProgressValue);

        progressTextTween = DOTween.To(
                () => currentProgressTextValue,
                value =>
                {
                    currentProgressTextValue = value;
                    ApplyProgressTextValue(value);
                },
                safeTargetValue,
                progressTweenDuration)
            .SetEase(progressTweenEase)
            .OnComplete(() =>
            {
                currentProgressTextValue = safeTargetValue;
                ApplyProgressTextValue(safeTargetValue);
            });
    }

    private void ApplyProgressNumberPosition(float clampedProgress)
    {
        if (progressNumberRect == null)
        {
            return;
        }

        Vector2 anchoredPos = progressNumberRect.anchoredPosition;
        anchoredPos.x = Mathf.Lerp(ProgressNumberMinX, ProgressNumberMaxX, clampedProgress);
        progressNumberRect.anchoredPosition = anchoredPos;
    }

    private void ApplyProgressTextValue(float progressValue)
    {
        int percentValue = Mathf.FloorToInt(Mathf.Max(0f, progressValue) * 100f);
        string textValue = percentValue.ToString() + "%";

        if (progressPercentText != null)
        {
            progressPercentText.text = textValue;
        }

        if (progressPercentText2 != null)
        {
            progressPercentText2.text = textValue;
        }
    }

    private void ApplyProgressBarVisual(float clampedProgress)
    {
        if (progressImage == null)
        {
            return;
        }

        if (progressUsesMaskWidthMode && progressImageRect != null && progressImageFullWidth > 0f)
        {
            float newWidth = progressImageFullWidth * clampedProgress;
            progressImageRect.SetSizeWithCurrentAnchors(RectTransform.Axis.Horizontal, newWidth);

            Vector2 anchoredPos = progressImageRect.anchoredPosition;
            anchoredPos.x = progressImageLeftEdgeX + (newWidth * progressImageScaleX * 0.5f);
            progressImageRect.anchoredPosition = anchoredPos;
            return;
        }

        progressImage.fillAmount = clampedProgress;
    }

    private ChartFileEntry GetChartEntry(int difficulty)
    {
        if (currentSong == null || currentSong.chartFiles == null)
        {
            return null;
        }

        foreach (var entry in currentSong.chartFiles)
        {
            if (entry != null && entry.difficulty == difficulty)
                return entry;
        }
        return null;
    }
}