using System;
using System.Collections.Generic;
using UnityEngine;

public sealed class GlobalAchievementService : MonoBehaviour
{
    private const string SaveCategory = "global_achievement";
    private const string SaveKey = "runtime_state";
    public const string DefaultResourcesPath = "so/globalachievments";
    public const string DefaultEditorAssetFolder = "Assets/Resources/so/globalachievments";

    public static GlobalAchievementService Instance { get; private set; }

    public event Action<GlobalAchievementSO> OnAchievementUnlocked;

    private readonly List<GlobalAchievementSO> definitions = new List<GlobalAchievementSO>();
    private readonly Dictionary<int, GlobalAchievementStateEntry> stateById = new Dictionary<int, GlobalAchievementStateEntry>();
    private readonly Dictionary<GlobalAchievementMetricType, GlobalAchievementMetricEntry> metricByType = new Dictionary<GlobalAchievementMetricType, GlobalAchievementMetricEntry>();

    private GlobalAchievementSaveData saveData;
    private bool initialized;
    private bool loginReportedThisSession;
    private int lastSaveFrame = -1;

    [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
    private static void Bootstrap()
    {
        EnsureInstance();
    }

    public static GlobalAchievementService EnsureInstance()
    {
        if (Instance != null)
        {
            return Instance;
        }

        var host = new GameObject("__global_achievement_service");
        host.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector;
        DontDestroyOnLoad(host);
        Instance = host.AddComponent<GlobalAchievementService>();
        return Instance;
    }

    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }

        Instance = this;
        DontDestroyOnLoad(gameObject);
        InitializeIfNeeded();
    }

    private void OnApplicationPause(bool pauseStatus)
    {
        if (pauseStatus)
        {
            SaveNow();
        }
    }

    private void OnApplicationQuit()
    {
        SaveNow();
    }

    public void InitializeIfNeeded()
    {
        if (initialized)
        {
            return;
        }

        initialized = true;
        GlobalAchievementSaveData loaded;
        if (!SecureSaveVault.TryLoadJson(SaveCategory, SaveKey, out loaded))
        {
            loaded = new GlobalAchievementSaveData();
        }

        saveData = loaded ?? new GlobalAchievementSaveData();
        RebuildCaches();
        LoadDefinitionsFromResources();
        ReportLoginSessionStart();
        RefreshDerivedMetrics();
        SaveNow();
    }

    public void LoadDefinitionsFromResources(string resourcesPath = DefaultResourcesPath)
    {
        InitializeIfNeeded();

        definitions.Clear();
        GlobalAchievementSO[] loadedDefinitions = Resources.LoadAll<GlobalAchievementSO>(resourcesPath);
        if (loadedDefinitions != null && loadedDefinitions.Length > 0)
        {
            definitions.AddRange(loadedDefinitions);
            definitions.Sort(CompareDefinitions);
        }

        SyncMirrorFlagsToDefinitions();
        EvaluateAll();
    }

    public IReadOnlyList<GlobalAchievementSO> GetDefinitions()
    {
        InitializeIfNeeded();
        return definitions;
    }

    public List<GlobalAchievementSnapshot> GetSnapshots()
    {
        InitializeIfNeeded();
        var snapshots = new List<GlobalAchievementSnapshot>(definitions.Count);
        for (int i = 0; i < definitions.Count; i++)
        {
            GlobalAchievementSO definition = definitions[i];
            if (definition == null || definition.achievementId <= 0)
            {
                continue;
            }

            GlobalAchievementStateEntry state = GetOrCreateState(definition.achievementId);
            float currentValue = GetMetric(definition.metricType);
            float targetValue = Mathf.Max(1f, definition.targetValue);
            snapshots.Add(new GlobalAchievementSnapshot
            {
                definition = definition,
                currentValue = currentValue,
                normalizedProgress = Mathf.Clamp01(currentValue / targetValue),
                unlocked = state.unlocked,
                unlockedUtc = state.unlockedUtcTicks > 0 ? new DateTime(state.unlockedUtcTicks, DateTimeKind.Utc) : default(DateTime),
                unlockedDateTimeText = state.unlockedUtcTicks > 0 ? new DateTime(state.unlockedUtcTicks, DateTimeKind.Utc).ToLocalTime().ToString("yyyy-MM-dd HH:mm:ss") : string.Empty,
            });
        }

        return snapshots;
    }

    public float GetMetric(GlobalAchievementMetricType metricType)
    {
        InitializeIfNeeded();
        GlobalAchievementMetricEntry metric;
        if (metricByType.TryGetValue(metricType, out metric))
        {
            return Mathf.Max(0f, metric.value);
        }

        return 0f;
    }

    public void AddMetric(GlobalAchievementMetricType metricType, float delta)
    {
        if (Mathf.Approximately(delta, 0f))
        {
            return;
        }

        InitializeIfNeeded();
        GlobalAchievementMetricEntry metric = GetOrCreateMetric(metricType);
        float nextValue = Mathf.Max(0f, metric.value + delta);
        if (Mathf.Approximately(metric.value, nextValue))
        {
            return;
        }

        metric.value = nextValue;
        PersistMetricsIfChanged(true);
    }

    public void SetMetric(GlobalAchievementMetricType metricType, float value)
    {
        InitializeIfNeeded();
        PersistMetricsIfChanged(SetMetricValue(metricType, value));
    }

    public void SetMetricAtLeast(GlobalAchievementMetricType metricType, float value)
    {
        InitializeIfNeeded();
        GlobalAchievementMetricEntry metric = GetOrCreateMetric(metricType);
        float nextValue = Mathf.Max(0f, value);
        if (nextValue <= metric.value)
        {
            return;
        }

        metric.value = nextValue;
        PersistMetricsIfChanged(true);
    }

    public void ReportLoginSessionStart()
    {
        InitializeIfNeeded();
        if (loginReportedThisSession)
        {
            return;
        }

        loginReportedThisSession = true;
        string currentDateStamp = DateTime.Now.ToString("yyyy-MM-dd");
        if (!string.IsNullOrEmpty(saveData.trustedDateStamp) && string.CompareOrdinal(currentDateStamp, saveData.trustedDateStamp) < 0)
        {
            currentDateStamp = saveData.trustedDateStamp;
        }
        else
        {
            saveData.trustedDateStamp = currentDateStamp;
        }

        if (!string.Equals(saveData.lastLoginDateStamp, currentDateStamp, StringComparison.Ordinal))
        {
            saveData.lastLoginDateStamp = currentDateStamp;
            AddMetric(GlobalAchievementMetricType.LoginDays, 1f);
            return;
        }

        SaveNow();
    }

    public void ReportCurrentCoins(int currentCoins)
    {
        // No current-coin achievement type now, but this remains available as a central probe point
        // for future expansion without changing economy call sites.
    }

    public void ReportCoinsEarned(int amount)
    {
        if (amount <= 0)
        {
            return;
        }

        AddMetric(GlobalAchievementMetricType.TotalCoinsEarned, amount);
    }

    public void RefreshOwnedHeroCount()
    {
        InitializeIfNeeded();
        PersistMetricsIfChanged(RefreshOwnedHeroCountInternal(true));
    }

    public void RefreshOwnedSongCountAndScores()
    {
        InitializeIfNeeded();
        PersistMetricsIfChanged(RefreshOwnedSongCountAndScoresInternal(true));
    }

    public void RefreshDerivedMetrics()
    {
        InitializeIfNeeded();
        StoreOwnershipLedger.EnsureInstance().ForceSyncMirrorFlags();

        bool changed = false;
        changed |= RefreshOwnedHeroCountInternal(false);
        changed |= RefreshOwnedSongCountAndScoresInternal(false);
        PersistMetricsIfChanged(changed);
    }

    public void SaveNow()
    {
        if (!initialized || saveData == null)
        {
            return;
        }

        if (Application.isPlaying && lastSaveFrame == Time.frameCount)
        {
            return;
        }

        lastSaveFrame = Application.isPlaying ? Time.frameCount : -1;
        SecureSaveVault.SaveJson(SaveCategory, SaveKey, saveData);
    }

    private void EvaluateAll()
    {
        for (int i = 0; i < definitions.Count; i++)
        {
            GlobalAchievementSO definition = definitions[i];
            if (definition == null || definition.achievementId <= 0)
            {
                continue;
            }

            GlobalAchievementStateEntry state = GetOrCreateState(definition.achievementId);
            if (state.unlocked)
            {
                continue;
            }

            float currentValue = GetMetric(definition.metricType);
            if (currentValue + 0.0001f < Mathf.Max(0f, definition.targetValue))
            {
                continue;
            }

            Unlock(definition, state);
        }

        SyncMirrorFlagsToDefinitions();
    }

    private bool RefreshOwnedHeroCountInternal(bool syncOwnershipFirst)
    {
        if (syncOwnershipFirst)
        {
            StoreOwnershipLedger.EnsureInstance().ForceSyncMirrorFlags();
        }

        AllyHero_SO[] heroes = Resources.LoadAll<AllyHero_SO>("so/ally");
        if (heroes == null || heroes.Length == 0)
        {
            return SetMetricValue(GlobalAchievementMetricType.OwnedHeroCount, 0f);
        }

        var uniqueIds = new HashSet<int>();
        int unlockedCount = 0;
        for (int i = 0; i < heroes.Length; i++)
        {
            AllyHero_SO hero = heroes[i];
            if (hero == null || hero.ally_heroID <= 0 || !uniqueIds.Add(hero.ally_heroID))
            {
                continue;
            }

            if (hero.isUnlocked)
            {
                unlockedCount++;
            }
        }

        return SetMetricValue(GlobalAchievementMetricType.OwnedHeroCount, unlockedCount);
    }

    private bool RefreshOwnedSongCountAndScoresInternal(bool syncOwnershipFirst)
    {
        if (syncOwnershipFirst)
        {
            StoreOwnershipLedger.EnsureInstance().ForceSyncMirrorFlags();
        }

        SongData[] songs = RuntimeResourcesCache.LoadSongsFromPath("song_songIndex");
        if (songs == null || songs.Length == 0)
        {
            bool emptyChanged = false;
            emptyChanged |= SetMetricValue(GlobalAchievementMetricType.OwnedSongCount, 0f);
            emptyChanged |= SetMetricValue(GlobalAchievementMetricType.BestSingleSongTotalScore, 0f);
            emptyChanged |= SetMetricValue(GlobalAchievementMetricType.TotalSongBestScoreSum, 0f);
            return emptyChanged;
        }

        var uniqueIds = new HashSet<int>();
        int ownedSongCount = 0;
        int bestSingleSongScore = 0;
        long totalSongBestScore = 0L;

        for (int i = 0; i < songs.Length; i++)
        {
            SongData song = songs[i];
            if (song == null || song.songID <= 0 || !uniqueIds.Add(song.songID))
            {
                continue;
            }

            song.EnsurePersistentDataLoaded();

            if (song.isUnlocked)
            {
                ownedSongCount++;
            }

            int highestScore;
            int bestDifficulty;
            string bestDifficultyName;
            song.GetAbsoluteHighestScore(out highestScore, out bestDifficulty, out bestDifficultyName);
            if (highestScore > bestSingleSongScore)
            {
                bestSingleSongScore = highestScore;
            }

            totalSongBestScore += Mathf.Max(0, highestScore);
        }

        bool changed = false;
        changed |= SetMetricValue(GlobalAchievementMetricType.OwnedSongCount, ownedSongCount);
        changed |= SetMetricValue(GlobalAchievementMetricType.BestSingleSongTotalScore, bestSingleSongScore);
        changed |= SetMetricValue(GlobalAchievementMetricType.TotalSongBestScoreSum, totalSongBestScore > float.MaxValue ? float.MaxValue : totalSongBestScore);
        return changed;
    }

    private bool SetMetricValue(GlobalAchievementMetricType metricType, float value)
    {
        GlobalAchievementMetricEntry metric = GetOrCreateMetric(metricType);
        float nextValue = Mathf.Max(0f, value);
        if (Mathf.Approximately(metric.value, nextValue))
        {
            return false;
        }

        metric.value = nextValue;
        return true;
    }

    private void PersistMetricsIfChanged(bool changed)
    {
        if (!changed)
        {
            return;
        }

        EvaluateAll();
        SaveNow();
    }

    private void Unlock(GlobalAchievementSO definition, GlobalAchievementStateEntry state)
    {
        state.unlocked = true;
        state.unlockedUtcTicks = DateTime.UtcNow.Ticks;
        definition.SetUnlockedState(true, state.unlockedUtcTicks);
        GlobalAchievementSteamBridge.TryUnlock(definition);
        if (OnAchievementUnlocked != null)
        {
            OnAchievementUnlocked(definition);
        }
    }

    private GlobalAchievementMetricEntry GetOrCreateMetric(GlobalAchievementMetricType metricType)
    {
        GlobalAchievementMetricEntry metric;
        if (metricByType.TryGetValue(metricType, out metric))
        {
            return metric;
        }

        metric = new GlobalAchievementMetricEntry
        {
            metricType = metricType,
            value = 0f
        };
        metricByType.Add(metricType, metric);
        saveData.metrics.Add(metric);
        return metric;
    }

    private GlobalAchievementStateEntry GetOrCreateState(int achievementId)
    {
        GlobalAchievementStateEntry state;
        if (stateById.TryGetValue(achievementId, out state))
        {
            return state;
        }

        state = new GlobalAchievementStateEntry
        {
            achievementId = achievementId,
            unlocked = false,
            unlockedUtcTicks = 0L
        };
        stateById.Add(achievementId, state);
        saveData.states.Add(state);
        return state;
    }

    private void RebuildCaches()
    {
        stateById.Clear();
        metricByType.Clear();

        if (saveData.metrics == null)
        {
            saveData.metrics = new List<GlobalAchievementMetricEntry>();
        }

        if (saveData.states == null)
        {
            saveData.states = new List<GlobalAchievementStateEntry>();
        }

        for (int i = 0; i < saveData.metrics.Count; i++)
        {
            GlobalAchievementMetricEntry entry = saveData.metrics[i];
            if (entry == null)
            {
                continue;
            }

            metricByType[entry.metricType] = entry;
        }

        for (int i = 0; i < saveData.states.Count; i++)
        {
            GlobalAchievementStateEntry entry = saveData.states[i];
            if (entry == null || entry.achievementId <= 0)
            {
                continue;
            }

            stateById[entry.achievementId] = entry;
        }
    }

    private static int CompareDefinitions(GlobalAchievementSO left, GlobalAchievementSO right)
    {
        if (left == null && right == null)
        {
            return 0;
        }

        if (left == null)
        {
            return 1;
        }

        if (right == null)
        {
            return -1;
        }

        int seriesCompare = string.CompareOrdinal(left.achievementSeriesKey, right.achievementSeriesKey);
        if (seriesCompare != 0)
        {
            return seriesCompare;
        }

        int levelCompare = left.achievementLevel.CompareTo(right.achievementLevel);
        if (levelCompare != 0)
        {
            return levelCompare;
        }

        int sortCompare = left.sortOrder.CompareTo(right.sortOrder);
        if (sortCompare != 0)
        {
            return sortCompare;
        }

        int metricCompare = left.metricType.CompareTo(right.metricType);
        if (metricCompare != 0)
        {
            return metricCompare;
        }

        int targetCompare = left.targetValue.CompareTo(right.targetValue);
        if (targetCompare != 0)
        {
            return targetCompare;
        }

        return left.achievementId.CompareTo(right.achievementId);
    }

    private void SyncMirrorFlagsToDefinitions()
    {
        for (int i = 0; i < definitions.Count; i++)
        {
            GlobalAchievementSO definition = definitions[i];
            if (definition == null || definition.achievementId <= 0)
            {
                continue;
            }

            GlobalAchievementStateEntry state;
            bool unlocked = stateById.TryGetValue(definition.achievementId, out state) && state != null && state.unlocked;
            definition.SetUnlockedState(unlocked, unlocked && state != null ? state.unlockedUtcTicks : 0L);
        }
    }
}