using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using finder2e_foundry_converter.Services;

namespace finder2e_foundry_converter.Converters
{
    public struct Result<T>
    {
        public T Value { get; }
        public string? Error { get; }
        public bool IsSuccess => Error == null;

        private Result(T value, string? error)
        {
            Value = value;
            Error = error;
        }

        public static Result<T> Success(T value) => new Result<T>(value, null);
        public static Result<T> Failure(string error) => new Result<T>(default!, error);
    }

    public static class NpcConverter
    {
        private static Dictionary<string, object> ParseToml(string content)
        {
            var root = new Dictionary<string, object>();
            var currentTable = root;

            var lines = content.Split(new[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
            foreach (var rawLine in lines)
            {
                var line = rawLine.Trim();
                if (string.IsNullOrEmpty(line) || line.StartsWith("#"))
                    continue;

                if (line.StartsWith("[") && line.EndsWith("]"))
                {
                    var section = line.Substring(1, line.Length - 2).Trim();
                    var parts = section.Split('.');

                    currentTable = root;
                    foreach (var p in parts)
                    {
                        var part = p.Trim().Trim('"');
                        if (!currentTable.TryGetValue(part, out var next) || !(next is Dictionary<string, object>))
                        {
                            var newTable = new Dictionary<string, object>();
                            currentTable[part] = newTable;
                            currentTable = newTable;
                        }
                        else
                        {
                            currentTable = (Dictionary<string, object>)next;
                        }
                    }
                }
                else if (line.Contains("="))
                {
                    var idx = line.IndexOf('=');
                    var key = line.Substring(0, idx).Trim().Trim('"');
                    var valStr = line.Substring(idx + 1).Trim();

                    if (string.IsNullOrEmpty(key)) continue;

                    currentTable[key] = ParseTomlValue(valStr);
                }
            }

            return root;
        }

        private static object ParseTomlValue(string valStr)
        {
            if (valStr.StartsWith("{") && valStr.EndsWith("}"))
            {
                var inlineTable = new Dictionary<string, object>();
                var content = valStr.Substring(1, valStr.Length - 2).Trim();
                if (!string.IsNullOrEmpty(content))
                {
                    var pairs = content.Split(',');
                    foreach (var pair in pairs)
                    {
                        var idx = pair.IndexOf('=');
                        if (idx >= 0)
                        {
                            var k = pair.Substring(0, idx).Trim().Trim('"');
                            var vStr = pair.Substring(idx + 1).Trim();
                            inlineTable[k] = ParseTomlValue(vStr);
                        }
                    }
                }
                return inlineTable;
            }

            if (valStr.StartsWith("\"") && valStr.EndsWith("\""))
            {
                return valStr.Substring(1, valStr.Length - 2);
            }

            if (long.TryParse(valStr, out var num))
            {
                return num;
            }

            return valStr;
        }

        private static Result<Dictionary<string, object>> LoadTableDocument(string normalizedSystem)
        {
            string path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config", $"{normalizedSystem}_tables.toml");
            try
            {
                if (!File.Exists(path))
                {
                    // Fallback attempt: sometimes config might be in working directory during dev
                    var alternativePath = Path.Combine(Directory.GetCurrentDirectory(), "config", $"{normalizedSystem}_tables.toml");
                    if (File.Exists(alternativePath))
                    {
                        path = alternativePath;
                    }
                }

                string rawContents = File.ReadAllText(path);
                try
                {
                    var document = ParseToml(rawContents);
                    return Result<Dictionary<string, object>>.Success(document);
                }
                catch (Exception ex)
                {
                    return Result<Dictionary<string, object>>.Failure($"failed to parse {path}: {ex.Message}");
                }
            }
            catch (Exception ex)
            {
                return Result<Dictionary<string, object>>.Failure($"failed to read {path}: {ex.Message}");
            }
        }

        private static object? Navigate(Dictionary<string, object> doc, params string[] path)
        {
            object current = doc;
            foreach (var key in path)
            {
                if (current is Dictionary<string, object> dict)
                {
                    if (!dict.TryGetValue(key, out var next))
                        return null;
                    current = next;
                }
                else
                {
                    return null;
                }
            }
            return current;
        }

        public static Result<int> AbilityScoreModifier(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            if (normalizedTier != "extreme" && normalizedTier != "high" && normalizedTier != "moderate" && normalizedTier != "low")
            {
                return Result<int>.Failure($"unsupported ability modifier tier `{normalizedTier}`; expected `extreme`, `high`, `moderate`, or `low`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "ability_modifiers", "levels", level.ToString(), normalizedTier);
            if (value == null)
            {
                return Result<int>.Failure($"no ability modifier entry found for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
            }

            if (value is long number)
            {
                if (number < int.MinValue || number > int.MaxValue)
                {
                    return Result<int>.Failure($"ability modifier value `{number}` is out of range for i32");
                }
                return Result<int>.Success((int)number);
            }
            if (value is string text && text == "n/a")
            {
                return Result<int>.Failure($"ability modifier tier `{normalizedTier}` is unavailable for level `{level}`");
            }

            return Result<int>.Failure($"invalid ability modifier value for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
        }

        public static Result<int> PerceptionModifier(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            if (normalizedTier != "extreme" && normalizedTier != "high" && normalizedTier != "moderate" && normalizedTier != "low" && normalizedTier != "terrible")
            {
                return Result<int>.Failure($"unsupported perception tier `{normalizedTier}`; expected `extreme`, `high`, `moderate`, `low`, or `terrible`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "perception", "levels", level.ToString(), normalizedTier);
            if (value == null)
            {
                return Result<int>.Failure($"no perception entry found for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
            }

            if (value is long number)
            {
                if (number < int.MinValue || number > int.MaxValue)
                {
                    return Result<int>.Failure($"perception value `{number}` is out of range for i32");
                }
                return Result<int>.Success((int)number);
            }

            return Result<int>.Failure($"invalid perception value for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
        }

        public static Result<int> SkillModifier(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            if (normalizedTier != "extreme" && normalizedTier != "high" && normalizedTier != "moderate" && normalizedTier != "low")
            {
                return Result<int>.Failure($"unsupported skill tier `{normalizedTier}`; expected `extreme`, `high`, `moderate`, or `low`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "skills", "levels", level.ToString(), normalizedTier);
            if (value == null)
            {
                return Result<int>.Failure($"no skill entry found for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
            }

            if (value is long number)
            {
                if (number < int.MinValue || number > int.MaxValue)
                {
                    return Result<int>.Failure($"skill value `{number}` is out of range for i32");
                }
                return Result<int>.Success((int)number);
            }

            if (value is Dictionary<string, object> range && normalizedTier == "low")
            {
                if (!range.TryGetValue("minimum", out var minObj) || minObj is not long minLong)
                {
                    return Result<int>.Failure($"missing skill minimum for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
                }
                if (!range.TryGetValue("maximum", out var maxObj) || maxObj is not long maxLong)
                {
                    return Result<int>.Failure($"missing skill maximum for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
                }

                if (minLong < int.MinValue || minLong > int.MaxValue)
                {
                    return Result<int>.Failure($"skill minimum `{minLong}` is out of range for i32");
                }
                if (maxLong < int.MinValue || maxLong > int.MaxValue)
                {
                    return Result<int>.Failure($"skill maximum `{maxLong}` is out of range for i32");
                }

                int minimum = (int)minLong;
                int maximum = (int)maxLong;

                if (minimum > maximum)
                {
                    return Result<int>.Failure($"invalid skill range for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
                }

                return Result<int>.Success(Random.Shared.Next(minimum, maximum + 1));
            }

            return Result<int>.Failure($"invalid skill value for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
        }

        public static Result<int> Ac(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            if (normalizedTier != "extreme" && normalizedTier != "high" && normalizedTier != "moderate" && normalizedTier != "low")
            {
                return Result<int>.Failure($"unsupported armor class tier `{normalizedTier}`; expected `extreme`, `high`, `moderate`, or `low`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "armor_class", "levels", level.ToString(), normalizedTier);
            if (value == null)
            {
                return Result<int>.Failure($"no armor class entry found for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
            }

            if (value is long number)
            {
                if (number < int.MinValue || number > int.MaxValue)
                {
                    return Result<int>.Failure($"armor class value `{number}` is out of range for i32");
                }
                return Result<int>.Success((int)number);
            }

            return Result<int>.Failure($"invalid armor class value for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
        }

        public static Result<int> SavingThrow(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            if (normalizedTier != "extreme" && normalizedTier != "high" && normalizedTier != "moderate" && normalizedTier != "low" && normalizedTier != "terrible")
            {
                return Result<int>.Failure($"unsupported saving throw tier `{normalizedTier}`; expected `extreme`, `high`, `moderate`, `low`, or `terrible`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "saving_throws", "levels", level.ToString(), normalizedTier);
            if (value == null)
            {
                return Result<int>.Failure($"no saving throw entry found for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
            }

            if (value is long number)
            {
                if (number < int.MinValue || number > int.MaxValue)
                {
                    return Result<int>.Failure($"saving throw value `{number}` is out of range for i32");
                }
                return Result<int>.Success((int)number);
            }

            return Result<int>.Failure($"invalid saving throw value for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
        }

        public static Result<int> Hp(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            if (normalizedTier != "high" && normalizedTier != "moderate" && normalizedTier != "low")
            {
                return Result<int>.Failure($"unsupported hit point tier `{normalizedTier}`; expected `high`, `moderate`, or `low`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "hit_points", "levels", level.ToString(), normalizedTier);
            if (value == null)
            {
                return Result<int>.Failure($"no hit point entry found for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
            }

            if (value is Dictionary<string, object> range)
            {
                if (!range.TryGetValue("minimum", out var minObj) || minObj is not long minLong)
                {
                    return Result<int>.Failure($"missing hit point minimum for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
                }
                if (!range.TryGetValue("maximum", out var maxObj) || maxObj is not long maxLong)
                {
                    return Result<int>.Failure($"missing hit point maximum for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
                }

                if (minLong < int.MinValue || minLong > int.MaxValue)
                {
                    return Result<int>.Failure($"hit point minimum `{minLong}` is out of range for i32");
                }
                if (maxLong < int.MinValue || maxLong > int.MaxValue)
                {
                    return Result<int>.Failure($"hit point maximum `{maxLong}` is out of range for i32");
                }

                int minimum = (int)minLong;
                int maximum = (int)maxLong;

                if (minimum > maximum)
                {
                    return Result<int>.Failure($"invalid hit point range for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
                }

                return Result<int>.Success(Random.Shared.Next(minimum, maximum + 1));
            }

            return Result<int>.Failure($"invalid hit point value for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
        }

        public static Result<int> ResistanceOrWeakness(int level, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var levelTable = Navigate(docResult.Value!, "resistances_and_weaknesses", "levels", level.ToString());
            if (levelTable == null || levelTable is not Dictionary<string, object> range)
            {
                return Result<int>.Failure($"no resistance/weakness entry found for system `{normalizedSystem}`, level `{level}`");
            }

            if (!range.TryGetValue("minimum", out var minObj) || minObj is not long minLong)
            {
                return Result<int>.Failure($"missing resistance/weakness minimum for system `{normalizedSystem}`, level `{level}`");
            }
            if (!range.TryGetValue("maximum", out var maxObj) || maxObj is not long maxLong)
            {
                return Result<int>.Failure($"missing resistance/weakness maximum for system `{normalizedSystem}`, level `{level}`");
            }

            if (minLong < int.MinValue || minLong > int.MaxValue)
            {
                return Result<int>.Failure($"resistance/weakness minimum `{minLong}` is out of range for i32");
            }
            if (maxLong < int.MinValue || maxLong > int.MaxValue)
            {
                return Result<int>.Failure($"resistance/weakness maximum `{maxLong}` is out of range for i32");
            }

            int minimum = (int)minLong;
            int maximum = (int)maxLong;

            if (minimum > maximum)
            {
                return Result<int>.Failure($"invalid resistance/weakness range for system `{normalizedSystem}`, level `{level}`");
            }

            return Result<int>.Success(Random.Shared.Next(minimum, maximum + 1));
        }

        public static Result<int> StrikeAttackBonus(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            if (normalizedTier != "extreme" && normalizedTier != "high" && normalizedTier != "moderate" && normalizedTier != "low")
            {
                return Result<int>.Failure($"unsupported strike attack bonus tier `{normalizedTier}`; expected `extreme`, `high`, `moderate`, or `low`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "strike_attack_bonus", "levels", level.ToString(), normalizedTier);
            if (value == null)
            {
                return Result<int>.Failure($"no strike attack bonus entry found for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
            }

            if (value is long number)
            {
                if (number < int.MinValue || number > int.MaxValue)
                {
                    return Result<int>.Failure($"strike attack bonus value `{number}` is out of range for i32");
                }
                return Result<int>.Success((int)number);
            }

            return Result<int>.Failure($"invalid strike attack bonus value for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
        }

        public static Result<string> StrikeDamageRoll(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<string>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            if (normalizedTier != "extreme" && normalizedTier != "high" && normalizedTier != "moderate" && normalizedTier != "low")
            {
                return Result<string>.Failure($"unsupported strike damage tier `{normalizedTier}`; expected `extreme`, `high`, `moderate`, or `low`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<string>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "strike_damage", "levels", level.ToString(), normalizedTier);
            if (value == null || value is not Dictionary<string, object> damageTable)
            {
                return Result<string>.Failure($"no strike damage entry found for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
            }

            if (damageTable.TryGetValue("dice", out var diceObj) && diceObj is string dice)
            {
                return Result<string>.Success(dice);
            }

            return Result<string>.Failure($"invalid strike damage roll for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
        }

        public static Result<int> StrikeDamageAverage(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            if (normalizedTier != "extreme" && normalizedTier != "high" && normalizedTier != "moderate" && normalizedTier != "low")
            {
                return Result<int>.Failure($"unsupported strike damage tier `{normalizedTier}`; expected `extreme`, `high`, `moderate`, or `low`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "strike_damage", "levels", level.ToString(), normalizedTier);
            if (value == null || value is not Dictionary<string, object> damageTable)
            {
                return Result<int>.Failure($"no strike damage entry found for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
            }

            if (damageTable.TryGetValue("average", out var avgObj) && avgObj is long average)
            {
                if (average < int.MinValue || average > int.MaxValue)
                {
                    return Result<int>.Failure($"strike damage average `{average}` is out of range for i32");
                }
                return Result<int>.Success((int)average);
            }

            return Result<int>.Failure($"invalid strike damage average for system `{normalizedSystem}`, level `{level}`, tier `{normalizedTier}`");
        }

        public static Result<string> AreaDamageRoll(int level, bool unlimited, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string column = unlimited ? "unlimited" : "limited";

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<string>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<string>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "area_damage", "levels", level.ToString(), column);
            if (value == null || value is not Dictionary<string, object> damageTable)
            {
                return Result<string>.Failure($"no area damage entry found for system `{normalizedSystem}`, level `{level}`, column `{column}`");
            }

            if (damageTable.TryGetValue("dice", out var diceObj) && diceObj is string dice)
            {
                return Result<string>.Success(dice);
            }

            return Result<string>.Failure($"invalid area damage roll for system `{normalizedSystem}`, level `{level}`, column `{column}`");
        }

        public static Result<int> AreaDamageAverage(int level, bool unlimited, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string column = unlimited ? "unlimited" : "limited";

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "area_damage", "levels", level.ToString(), column);
            if (value == null || value is not Dictionary<string, object> damageTable)
            {
                return Result<int>.Failure($"no area damage entry found for system `{normalizedSystem}`, level `{level}`, column `{column}`");
            }

            if (damageTable.TryGetValue("average", out var avgObj) && avgObj is long average)
            {
                if (average < int.MinValue || average > int.MaxValue)
                {
                    return Result<int>.Failure($"area damage average `{average}` is out of range for i32");
                }
                return Result<int>.Success((int)average);
            }

            return Result<int>.Failure($"invalid area damage average for system `{normalizedSystem}`, level `{level}`, column `{column}`");
        }

        public static Result<int> SpellDc(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();
            string column = normalizedTier switch
            {
                "extreme" => "extreme_dc",
                "high" => "high_dc",
                "moderate" => "moderate_dc",
                _ => null!
            };

            if (column == null)
            {
                return Result<int>.Failure($"unsupported spell dc tier `{normalizedTier}`; expected `extreme`, `high`, or `moderate`");
            }

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "spellcasting", "levels", level.ToString(), column);
            if (value == null)
            {
                return Result<int>.Failure($"no spell dc entry found for system `{normalizedSystem}`, level `{level}`, column `{column}`");
            }

            if (value is long number)
            {
                if (number < int.MinValue || number > int.MaxValue)
                {
                    return Result<int>.Failure($"spell dc value `{number}` is out of range for i32");
                }
                return Result<int>.Success((int)number);
            }

            return Result<int>.Failure($"invalid spell dc value for system `{normalizedSystem}`, level `{level}`, column `{column}`");
        }

        public static Result<int> SpellAttackBonus(int level, string modifierTier, string system)
        {
            string normalizedSystem = system.Trim().ToLowerInvariant();
            string normalizedTier = modifierTier.Trim().ToLowerInvariant();
            string column = normalizedTier switch
            {
                "extreme" => "extreme_spell_attack",
                "high" => "high_spell_attack",
                "moderate" => "moderate_spell_attack",
                _ => null!
            };

            if (column == null)
            {
                return Result<int>.Failure($"unsupported spell attack bonus tier `{normalizedTier}`; expected `extreme`, `high`, or `moderate`");
            }

            if (normalizedSystem != "pf2e" && normalizedSystem != "sf2e")
            {
                return Result<int>.Failure($"unsupported game system `{normalizedSystem}`; expected `pf2e` or `sf2e`");
            }

            var docResult = LoadTableDocument(normalizedSystem);
            if (!docResult.IsSuccess) return Result<int>.Failure(docResult.Error!);

            var value = Navigate(docResult.Value!, "spellcasting", "levels", level.ToString(), column);
            if (value == null)
            {
                return Result<int>.Failure($"no spell attack bonus entry found for system `{normalizedSystem}`, level `{level}`, column `{column}`");
            }

            if (value is long number)
            {
                if (number < int.MinValue || number > int.MaxValue)
                {
                    return Result<int>.Failure($"spell attack bonus value `{number}` is out of range for i32");
                }
                return Result<int>.Success((int)number);
            }

            return Result<int>.Failure($"invalid spell attack bonus value for system `{normalizedSystem}`, level `{level}`, column `{column}`");
        }
    }

    public class NpcGenerator
    {
        private readonly ILlmService _llmService;
        private Dictionary<string, (string question, string constraints)> _prompts = new();
        private string _retryPrefix = "";

        public NpcGenerator(ILlmService llmService)
        {
            _llmService = llmService;
        }

        /// <summary>
        /// Load all prompts from llmflow/npc.toml
        /// </summary>
        public async Task LoadPromptsAsync()
        {
            _prompts.Clear();
            _retryPrefix = "";

            var cwd = Directory.GetCurrentDirectory();
            var tomlPath = Path.Combine(cwd, "llmflow", "npc.toml");

            if (!File.Exists(tomlPath))
            {
                Console.WriteLine($"Warning: TOML file not found at {tomlPath}");
                return;
            }

            var lines = await File.ReadAllLinesAsync(tomlPath);
            string? currentSection = null;

            foreach (var rawLine in lines)
            {
                var line = rawLine.Trim();
                if (string.IsNullOrEmpty(line) || line.StartsWith("#")) continue;

                // Parse section headers [section_name]
                if (line.StartsWith("[") && line.EndsWith("]"))
                {
                    currentSection = line.Substring(1, line.Length - 2).Trim();
                    continue;
                }

                // Parse key = "value"
                if (line.Contains("="))
                {
                    var idx = line.IndexOf('=');
                    var key = line.Substring(0, idx).Trim();
                    var valStr = line.Substring(idx + 1).Trim().Trim('"');

                    if (key == "retry_prefix")
                    {
                        _retryPrefix = valStr;
                        Console.WriteLine($"Loaded retry_prefix");
                    }
                    else if (currentSection != null)
                    {
                        if (key == "question")
                        {
                            if (!_prompts.ContainsKey(currentSection))
                                _prompts[currentSection] = (valStr, string.Empty);
                            else
                                _prompts[currentSection] = (valStr, _prompts[currentSection].constraints);
                        }
                        else if (key == "constraints")
                        {
                            if (!_prompts.ContainsKey(currentSection))
                                _prompts[currentSection] = (string.Empty, valStr);
                            else
                                _prompts[currentSection] = (_prompts[currentSection].question, valStr);
                        }
                    }
                }
            }

            Console.WriteLine($"Loaded {_prompts.Count} prompt sections from npc.toml");
        }

        /// <summary>
        /// Ask LLM a question with up to 3 retry attempts and constraint validation
        /// </summary>
        public async Task<(bool success, string response)> AskLlmAsync(
            string baseUrl,
            string model,
            string promptKey,
            Dictionary<string, string> replacements,
            List<string> imagePaths)
        {
            if (!_prompts.TryGetValue(promptKey, out var prompt_tuple))
            {
                Console.WriteLine($"Warning: Prompt '{promptKey}' not found in loaded prompts");
                return (false, string.Empty);
            }

            var (questionTemplate, constraints) = prompt_tuple;
            var prompt = questionTemplate;
            foreach (var kvp in replacements)
            {
                prompt = prompt.Replace($"{{{kvp.Key}}}", kvp.Value);
            }

            string lastResponse = string.Empty;

            for (int attempt = 1; attempt <= 3; attempt++)
            {
                Console.WriteLine($"\n=== Asking LLM for '{promptKey}' (attempt {attempt}/3) ===");
                Console.WriteLine($"Prompt: {prompt}");
                if (!string.IsNullOrWhiteSpace(constraints))
                    Console.WriteLine($"Constraints: {constraints}");

                var resp = await _llmService.AskAsync(baseUrl, model, prompt, imagePaths);
                var trimmed = resp?.Trim() ?? string.Empty;

                Console.WriteLine($"LLM Response: '{trimmed}'");

                // Check for error response
                if (trimmed.StartsWith("Error:", StringComparison.OrdinalIgnoreCase))
                {
                    Console.WriteLine($"-> Response is an error, will retry");
                    prompt = _retryPrefix + "\nPrevious error: " + trimmed + "\n\n" + questionTemplate;
                    foreach (var kvp in replacements)
                    {
                        prompt = prompt.Replace($"{{{kvp.Key}}}", kvp.Value);
                    }
                    lastResponse = trimmed;
                    continue;
                }

                // Validate against constraints if available
                if (!string.IsNullOrWhiteSpace(constraints))
                {
                    var (isValid, normalizedResponse) = ValidateResponse(trimmed, constraints);
                    if (isValid)
                    {
                        Console.WriteLine($"✓ Response is valid: '{normalizedResponse}'");
                        return (true, normalizedResponse);
                    }
                    else
                    {
                        Console.WriteLine($"✗ Response '{trimmed}' does not match constraints");
                        if (attempt < 3)
                        {
                            prompt = _retryPrefix + $"\nPrevious response was: '{trimmed}'\n\nPlease respond with the correct format:\n{constraints}\n\n{questionTemplate}";
                            foreach (var kvp in replacements)
                            {
                                prompt = prompt.Replace($"{{{kvp.Key}}}", kvp.Value);
                            }
                        }
                        lastResponse = trimmed;
                        continue;
                    }
                }
                else
                {
                    // No constraints, accept any non-empty response
                    if (!string.IsNullOrWhiteSpace(trimmed))
                    {
                        Console.WriteLine($"✓ Response accepted (no constraints)");
                        return (true, trimmed);
                    }
                    else
                    {
                        Console.WriteLine($"✗ Empty response, will retry");
                        if (attempt < 3)
                        {
                            prompt = _retryPrefix + "\nPrevious response was empty.\n\n" + questionTemplate;
                            foreach (var kvp in replacements)
                            {
                                prompt = prompt.Replace($"{{{kvp.Key}}}", kvp.Value);
                            }
                        }
                        lastResponse = trimmed;
                    }
                }
            }

            Console.WriteLine($"\n✗✗✗ Failed to get valid response for '{promptKey}' after 3 attempts. Last response: '{lastResponse}'");
            return (false, lastResponse);
        }

        /// <summary>
        /// Generate name if not provided. Tries name_from_description_and_level, then name_from_level, then name
        /// </summary>
        public async Task<string> GenerateNameAsync(
            string baseUrl,
            string model,
            string description,
            int level,
            List<string> imagePaths)
        {
            if (!string.IsNullOrWhiteSpace(description))
            {
                // Try generating from description + level
                var replacements = new Dictionary<string, string>
                {
                    { "description", description },
                    { "level", level.ToString() }
                };

                var (success, name) = await AskLlmAsync(baseUrl, model, "name_from_description_and_level", replacements, imagePaths);
                if (success && !string.IsNullOrWhiteSpace(name))
                    return name;

                // Fallback to just description
                replacements = new Dictionary<string, string>();
                (success, name) = await AskLlmAsync(baseUrl, model, "name", replacements, imagePaths);
                if (success && !string.IsNullOrWhiteSpace(name))
                    return name;
            }

            // If no description, generate from level alone
            var levelReplacements = new Dictionary<string, string>
            {
                { "level", level.ToString() }
            };

            var (levelSuccess, levelName) = await AskLlmAsync(baseUrl, model, "name_from_level", levelReplacements, imagePaths);
            return (levelSuccess && !string.IsNullOrWhiteSpace(levelName)) ? levelName : "NPC";
        }

        /// <summary>
        /// Generate description if not provided. Uses description_from_name_and_level
        /// </summary>
        public async Task<string> GenerateDescriptionAsync(
            string baseUrl,
            string model,
            string name,
            int level,
            List<string> imagePaths)
        {
            var replacements = new Dictionary<string, string>
            {
                { "name", name },
                { "level", level.ToString() }
            };

            var (success, description) = await AskLlmAsync(baseUrl, model, "description_from_name_and_level", replacements, imagePaths);
            return (success && !string.IsNullOrWhiteSpace(description)) ? description : string.Empty;
        }

        /// <summary>
        /// Validate a response against constraints and return normalized response
        /// </summary>
        private (bool isValid, string normalizedResponse) ValidateResponse(string response, string constraints)
        {
            var allowed = constraints.Trim();
            var optionsStart = allowed.IndexOf(":");

            List<string> options = new();
            if (optionsStart >= 0)
            {
                var after = allowed.Substring(optionsStart + 1);
                // Split by commas and newlines
                var parts = after.Split(new[] { ',', '\n' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (var p in parts)
                {
                    var t = p.Replace("or", "", StringComparison.OrdinalIgnoreCase).Trim();
                    if (!string.IsNullOrEmpty(t))
                        options.Add(t.Trim().Trim('.'));
                }
            }

            Console.WriteLine($"Parsed allowed options: {string.Join(", ", options)}");

            if (options.Count > 0)
            {
                // Check exact match
                if (options.Any(o => string.Equals(o, response, StringComparison.OrdinalIgnoreCase)))
                {
                    return (true, response);
                }

                // Try first word match
                var firstWord = response.Split(new[] { ' ', '\t', '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries).FirstOrDefault() ?? string.Empty;
                if (options.Any(o => string.Equals(o, firstWord, StringComparison.OrdinalIgnoreCase)))
                {
                    return (true, firstWord);
                }

                return (false, response);
            }

            // No options parsed, accept any non-empty response
            return (!string.IsNullOrWhiteSpace(response), response);
        }
    }
}