// WPFMA-SDK needs Unity 2022.3 (VRChat's version); on older Unity this file is skipped and WPFMAUnityVersionNotice explains why.
#if UNITY_2022_3_OR_NEWER
using System;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

namespace WPFMA.Vrca
{
    public static class WPFMAShaderResolver
    {
        private static readonly string[] WrapperPrefixes =
        {
            "d4rkpl4y3r/Optimizer/s_",
            "d4rkpl4y3r/Optimizer/",
            "Hidden/Locked/",
            "Hidden/InternalLocked/",
            "Locked/"
        };

        private static readonly string[] StrongTokens =
        {
            "liltoon", "arktoon", "sunao", "unlit", "silent",
            "orels", "mochie", "xiexe", "amplify", "shatter", "fur"
        };

        public static string RecoverBaseName(string shaderName)
        {
            if (string.IsNullOrEmpty(shaderName))
                return string.Empty;

            string name = shaderName;

            bool stripped = true;
            while (stripped)
            {
                stripped = false;
                foreach (var prefix in WrapperPrefixes)
                {
                    if (name.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
                    {
                        name = name.Substring(prefix.Length);
                        stripped = true;
                        break;
                    }
                }
            }

            int lastSlash = name.LastIndexOf('/');
            if (lastSlash >= 0 && IsNoise(name.Substring(lastSlash + 1)))
                name = name.Substring(0, lastSlash);

            return name;
        }

        public static Shader FindFamilyMatch(string shaderName, IEnumerable<Shader> candidates, out string reason)
        {
            reason = null;

            string baseName = RecoverBaseName(shaderName);
            if (string.IsNullOrEmpty(baseName))
                return null;

            var wanted = Tokenize(baseName);
            if (wanted.Count == 0)
                return null;

            bool hintIsStrong = wanted.Any(t => StrongTokens.Contains(t));

            Shader best = null;
            int bestScore = int.MinValue;
            int bestMatches = 0;

            foreach (var candidate in candidates)
            {
                if (candidate == null || string.IsNullOrEmpty(candidate.name))
                    continue;

                string candidateName = candidate.name;
                string leaf = candidateName.Substring(candidateName.LastIndexOf('/') + 1);
                var have = Tokenize(leaf);
                if (have.Count == 0)
                    continue;

                int matches = have.Count(t => wanted.Contains(t));
                if (matches == 0)
                    continue;

                bool candidateIsStrong = have.Any(t => StrongTokens.Contains(t) && wanted.Contains(t));
                if (hintIsStrong && !candidateIsStrong)
                    continue;

                int score = matches * 10 - Math.Abs(have.Count - matches) * 3;

                if (candidateName.IndexOf("Old Versions", StringComparison.OrdinalIgnoreCase) >= 0)
                    score -= 25;
                if (candidateName.StartsWith("Hidden/", StringComparison.Ordinal))
                    score -= 40;

                if (score > bestScore)
                {
                    bestScore = score;
                    best = candidate;
                    bestMatches = matches;
                }
            }

            if (best == null)
                return null;

            bool confident = hintIsStrong
                ? bestMatches >= 1
                : bestMatches >= 2 && bestMatches >= wanted.Count - 2;

            if (!confident)
                return null;

            reason = "matched '" + shaderName + "' → family '" + baseName + "' → '" + best.name + "'";
            return best;
        }

        private static List<string> Tokenize(string value)
        {
            var tokens = new List<string>();
            var current = new System.Text.StringBuilder();

            foreach (char c in value)
            {
                if (char.IsLetterOrDigit(c))
                    current.Append(char.ToLowerInvariant(c));
                else
                    Flush(tokens, current);
            }

            Flush(tokens, current);
            return tokens;
        }

        private static void Flush(List<string> tokens, System.Text.StringBuilder current)
        {
            if (current.Length == 0)
                return;

            string token = current.ToString();
            current.Length = 0;

            if (!IsNoise(token) && !tokens.Contains(token))
                tokens.Add(token);
        }

        private static bool IsNoise(string token)
        {
            if (string.IsNullOrEmpty(token) || token.Length <= 1)
                return true;

            bool allDigits = true;
            bool allHex = true;

            foreach (char c in token)
            {
                if (!char.IsDigit(c))
                    allDigits = false;
                if (!Uri.IsHexDigit(c))
                    allHex = false;
            }

            if (allDigits)
                return true;

            return allHex && token.Length >= 6;
        }
    }
}
#endif
