using System.Globalization;
using System.Text.RegularExpressions;
using Oms.Application.Dtos.Orders;
using Oms.Domain.ChannelsAggregate.Entities;

namespace Oms.Application.Shared;

/// <summary>
/// 地理分区规则（价格/黑名单/偏远共用）。
/// </summary>
public sealed class GeoRule
{
    public int Ordinal { get; init; }

    public object? Tag { get; init; }

    public string CountryCode { get; init; } = string.Empty;

    /// <summary>zip / state / city / country</summary>
    public string MatchDim { get; init; } = string.Empty;

    /// <summary>prefix / exact / range / all</summary>
    public string MatchMode { get; init; } = string.Empty;

    public int PrefixLen { get; init; }

    public string MatchTextStd { get; init; } = string.Empty;

    public string ZipStartStd { get; init; } = string.Empty;

    public string ZipEndStd { get; init; } = string.Empty;

    public string MatchStateStd { get; init; } = string.Empty;
}

/// <summary>
/// 地址清洗、规则编译、单套分区匹配。价格/黑名单/偏远分区共用。
/// </summary>
public static class GeoPartitionMatcher
{
    public const string DimZip = "zip";
    public const string DimState = "state";
    public const string DimCity = "city";
    public const string DimCountry = "country";

    public const string ModePrefix = "prefix";
    public const string ModeExact = "exact";
    public const string ModeRange = "range";
    public const string ModeAll = "all";

    private static readonly Regex PostcodeRangePattern = new(
        @"^[\[(]\s*([^,)\]]*)\s*,\s*([^,)\]]*)\s*[\])]$",
        RegexOptions.Compiled | RegexOptions.CultureInvariant);

    public static string NormalizeCountry(string? value) =>
        string.IsNullOrWhiteSpace(value) ? string.Empty : value.Trim().ToUpperInvariant();

    public static string NormalizeZip(string? value)
    {
        if (string.IsNullOrWhiteSpace(value))
        {
            return string.Empty;
        }

        var chars = value.Where(ch => !char.IsWhiteSpace(ch) && ch != '-').ToArray();
        return chars.Length == 0 ? string.Empty : new string(chars).ToUpperInvariant();
    }

    /// <summary>
    /// 规范化后的邮编比较：纯数字按等长补零；相同字母前缀+数字后缀按数值；其余按 Ordinal。
    /// </summary>
    public static int CompareNormalizedZip(string? left, string? right)
    {
        var a = left ?? string.Empty;
        var b = right ?? string.Empty;
        if (a.Length == 0 && b.Length == 0)
        {
            return 0;
        }

        if (IsDigits(a) && IsDigits(b))
        {
            var width = Math.Max(a.Length, b.Length);
            return string.CompareOrdinal(a.PadLeft(width, '0'), b.PadLeft(width, '0'));
        }

        if (TrySplitLetterPrefixNumber(a, out var prefixA, out var numberA, out var restA)
            && TrySplitLetterPrefixNumber(b, out var prefixB, out var numberB, out var restB)
            && string.Equals(prefixA, prefixB, StringComparison.Ordinal))
        {
            var numberCmp = numberA.CompareTo(numberB);
            return numberCmp != 0 ? numberCmp : string.CompareOrdinal(restA, restB);
        }

        return string.CompareOrdinal(a, b);
    }

    private static bool IsDigits(string value) =>
        value.Length > 0 && value.All(char.IsAsciiDigit);

    private static bool TrySplitLetterPrefixNumber(
        string zip,
        out string prefix,
        out int number,
        out string rest)
    {
        prefix = string.Empty;
        number = 0;
        rest = string.Empty;
        if (zip.Length == 0 || !char.IsAsciiLetter(zip[0]))
        {
            return false;
        }

        var i = 0;
        while (i < zip.Length && char.IsAsciiLetter(zip[i]))
        {
            i++;
        }

        if (i >= zip.Length || !char.IsAsciiDigit(zip[i]))
        {
            return false;
        }

        prefix = zip[..i];
        var digitStart = i;
        while (i < zip.Length && char.IsAsciiDigit(zip[i]))
        {
            i++;
        }

        if (!int.TryParse(zip[digitStart..i], NumberStyles.None, CultureInfo.InvariantCulture, out number))
        {
            return false;
        }

        rest = zip[i..];
        return true;
    }

    public static string NormalizeRegion(string? value) =>
        string.IsNullOrWhiteSpace(value) ? string.Empty : value.Trim().ToUpperInvariant();

    /// <summary>
    /// 执行单套地理分区匹配。调用方需传入已排序规则：zip > state > city > country，同维度 prefixLen 降序。
    /// </summary>
    public static GeoRule? MatchSinglePartition(
        string countryCode,
        string zipStd,
        string stateStd,
        string cityStd,
        IReadOnlyList<GeoRule> ruleList)
    {
        var country = NormalizeCountry(countryCode);
        zipStd ??= string.Empty;
        stateStd ??= string.Empty;
        cityStd ??= string.Empty;
        if (ruleList == null || ruleList.Count == 0 || string.IsNullOrEmpty(country))
        {
            return null;
        }

        foreach (var rule in ruleList)
        {
            if (!string.Equals(rule.CountryCode, country, StringComparison.OrdinalIgnoreCase))
            {
                continue;
            }

            if (rule.MatchDim == DimZip)
            {
                if (string.IsNullOrEmpty(zipStd))
                {
                    continue;
                }

                var hit = false;
                if (rule.MatchMode == ModePrefix)
                {
                    if (rule.PrefixLen > 0 && zipStd.Length >= rule.PrefixLen)
                    {
                        var userPrefix = zipStd[..rule.PrefixLen];
                        hit = userPrefix == rule.MatchTextStd;
                    }
                }
                else if (rule.MatchMode == ModeExact)
                {
                    hit = zipStd == rule.MatchTextStd;
                }
                else if (rule.MatchMode == ModeRange)
                {
                    hit = CompareNormalizedZip(zipStd, rule.ZipStartStd) >= 0
                          && CompareNormalizedZip(zipStd, rule.ZipEndStd) <= 0;
                }

                if (hit)
                {
                    return rule;
                }
            }
            else if (rule.MatchDim == DimState)
            {
                if (!string.IsNullOrEmpty(zipStd))
                {
                    continue;
                }

                if (rule.MatchMode == ModeExact && stateStd == rule.MatchTextStd && !string.IsNullOrEmpty(stateStd))
                {
                    return rule;
                }
            }
            else if (rule.MatchDim == DimCity)
            {
                if (!string.IsNullOrEmpty(zipStd))
                {
                    continue;
                }

                if (rule.MatchMode == ModeExact
                    && rule.MatchStateStd == stateStd
                    && rule.MatchTextStd == cityStd
                    && !string.IsNullOrEmpty(stateStd)
                    && !string.IsNullOrEmpty(cityStd))
                {
                    return rule;
                }
            }
            else if (rule.MatchDim == DimCountry)
            {
                return rule;
            }
        }

        return null;
    }

    public static IReadOnlyList<GeoRule> SortRules(IEnumerable<GeoRule> rules) =>
        rules
            .OrderBy(DimRank)
            .ThenByDescending(r => r.PrefixLen)
            .ThenByDescending(RangeSpecificity)
            .ThenBy(r => r.Ordinal)
            .ToList();

    public static GeoRule? Compile(KpiAreaInfo entity, int ordinal = 0, bool attachTag = true)
    {
        if (entity == null)
        {
            return null;
        }

        return Compile(
            entity.CountryCode,
            entity.Province,
            entity.City,
            entity.LeftPostcode,
            entity.RightPostcode,
            null,
            entity.MatchDim,
            entity.MatchMode,
            entity.PrefixLen,
            ordinal,
            attachTag ? entity : null);
    }

    public static GeoRule? Compile(KpiAreaSnapshotRuleDto rule, int ordinal = 0, bool attachTag = true)
    {
        if (rule == null)
        {
            return null;
        }

        var range = KpiAreaSnapshotMapper.ResolvePostcodeRange(rule);
        return Compile(
            rule.CountryCode,
            rule.Province,
            rule.City,
            rule.LeftPostcode,
            rule.RightPostcode,
            range,
            rule.MatchDim,
            rule.MatchMode,
            rule.PrefixLen,
            ordinal,
            attachTag ? rule : null);
    }

    public static KpiAreaSnapshotRuleDto? MatchSnapshot(
        IEnumerable<KpiAreaSnapshotRuleDto>? infos,
        string countryCode,
        string? province,
        string? city,
        string? zipCode)
    {
        var hit = Match(CompileList(infos, Compile), countryCode, province, city, zipCode);
        return hit?.Tag as KpiAreaSnapshotRuleDto;
    }

    public static KpiAreaInfo? MatchEntity(
        IEnumerable<KpiAreaInfo>? infos,
        string countryCode,
        string? province,
        string? city,
        string? zipCode)
    {
        var hit = Match(CompileList(infos, Compile), countryCode, province, city, zipCode);
        return hit?.Tag as KpiAreaInfo;
    }

    public static bool IsHit(
        IEnumerable<KpiAreaInfo>? infos,
        string countryCode,
        string? province,
        string? city,
        string? zipCode) =>
        MatchEntity(infos, countryCode, province, city, zipCode) != null;

    public static bool IsHit(
        IEnumerable<KpiAreaSnapshotRuleDto>? infos,
        string countryCode,
        string? province,
        string? city,
        string? zipCode) =>
        MatchSnapshot(infos, countryCode, province, city, zipCode) != null;

    public static GeoRule? Match(
        IReadOnlyList<GeoRule> compiled,
        string countryCode,
        string? province,
        string? city,
        string? zipCode)
    {
        var sorted = SortRules(compiled);
        return MatchSinglePartition(
            NormalizeCountry(countryCode),
            NormalizeZip(zipCode),
            NormalizeRegion(province),
            NormalizeRegion(city),
            sorted);
    }

    /// <summary>
    /// 清洗并收口为一维规则，写入 MatchDim / MatchMode / PrefixLen。
    /// 显式维度优先；未传则按字段推断。
    /// </summary>
    public static void PrepareEntity(KpiAreaInfo entity)
    {
        ArgumentNullException.ThrowIfNull(entity);
        entity.CountryCode = string.IsNullOrWhiteSpace(entity.CountryCode) ? null : entity.CountryCode.Trim();
        entity.CountryName = string.IsNullOrWhiteSpace(entity.CountryName) ? null : entity.CountryName.Trim();
        entity.Province = EmptyToNull(entity.Province);
        entity.City = EmptyToNull(entity.City);
        entity.LeftPostcode = EmptyToNull(entity.LeftPostcode);
        entity.RightPostcode = EmptyToNull(entity.RightPostcode);

        if (string.IsNullOrWhiteSpace(entity.CountryCode))
        {
            throw new InvalidOperationException("国家代码不能为空");
        }

        var dim = NormalizeDim(entity.MatchDim);
        var mode = NormalizeMode(entity.MatchMode);
        if (string.IsNullOrEmpty(dim))
        {
            dim = InferDim(entity.LeftPostcode, entity.RightPostcode, entity.Province, entity.City);
        }

        switch (dim)
        {
            case DimZip:
                ApplyZipFields(entity, mode);
                break;
            case DimState:
                if (string.IsNullOrWhiteSpace(entity.Province))
                {
                    throw new InvalidOperationException("州/省匹配必须填写州/省");
                }

                entity.City = null;
                entity.LeftPostcode = null;
                entity.RightPostcode = null;
                entity.MatchDim = DimState;
                entity.MatchMode = ModeExact;
                entity.PrefixLen = 0;
                break;
            case DimCity:
                if (string.IsNullOrWhiteSpace(entity.Province) || string.IsNullOrWhiteSpace(entity.City))
                {
                    throw new InvalidOperationException("城市匹配必须同时填写州/省");
                }

                entity.LeftPostcode = null;
                entity.RightPostcode = null;
                entity.MatchDim = DimCity;
                entity.MatchMode = ModeExact;
                entity.PrefixLen = 0;
                break;
            default:
                entity.Province = null;
                entity.City = null;
                entity.LeftPostcode = null;
                entity.RightPostcode = null;
                entity.MatchDim = DimCountry;
                entity.MatchMode = ModeAll;
                entity.PrefixLen = 0;
                break;
        }
    }

    /// <summary>
    /// 同一分区内判定完全相同规则的指纹（不比较 AreaId）。
    /// 须在 PrepareEntity 之后调用。
    /// </summary>
    public static string BuildDuplicateKey(KpiAreaInfo entity)
    {
        ArgumentNullException.ThrowIfNull(entity);
        var dim = NormalizeDim(entity.MatchDim) ?? DimCountry;
        var mode = NormalizeMode(entity.MatchMode) ?? ModeAll;
        var country = NormKey(entity.CountryCode);

        return dim switch
        {
            DimState => $"{DimState}|{country}|{NormKey(entity.Province)}",
            DimCity => $"{DimCity}|{country}|{NormKey(entity.Province)}|{NormKey(entity.City)}",
            DimZip when mode == ModePrefix =>
                $"{DimZip}|{ModePrefix}|{country}|{NormKey(entity.LeftPostcode)}|{entity.PrefixLen}",
            DimZip when mode == ModeExact =>
                $"{DimZip}|{ModeExact}|{country}|{NormKey(entity.LeftPostcode)}",
            DimZip =>
                $"{DimZip}|{ModeRange}|{country}|{NormKey(entity.LeftPostcode)}|{NormKey(entity.RightPostcode)}",
            _ => $"{DimCountry}|{country}"
        };
    }

    private static string NormKey(string? value) => (value ?? string.Empty).Trim().ToUpperInvariant();

    public static (string MatchDim, string MatchMode, int PrefixLen) Describe(KpiAreaInfo? entity)
    {
        if (entity == null)
        {
            return (DimCountry, ModeAll, 0);
        }

        if (!string.IsNullOrWhiteSpace(entity.MatchDim))
        {
            return (
                NormalizeDim(entity.MatchDim) ?? DimCountry,
                NormalizeMode(entity.MatchMode) ?? ModeAll,
                entity.PrefixLen);
        }

        var rule = Compile(entity, attachTag: false);
        if (rule == null)
        {
            return (DimCountry, ModeAll, 0);
        }

        return (rule.MatchDim, rule.MatchMode, rule.PrefixLen);
    }

    private static GeoRule? Compile(
        string? countryCode,
        string? province,
        string? city,
        string? leftPostcode,
        string? rightPostcode,
        string? postcodeRange,
        string? matchDim,
        string? matchMode,
        int prefixLenHint,
        int ordinal,
        object? tag)
    {
        var country = NormalizeCountry(countryCode);
        if (string.IsNullOrEmpty(country))
        {
            return null;
        }

        var dim = NormalizeDim(matchDim);
        if (string.IsNullOrEmpty(dim))
        {
            dim = InferDim(leftPostcode, rightPostcode, province, city, postcodeRange);
        }

        var encoded = TryParseEncodedRange(postcodeRange);
        var zipLeft = NormalizeZip(leftPostcode);
        var zipRight = NormalizeZip(rightPostcode);
        var zipMode = NormalizeMode(matchMode) ?? encoded?.Mode;
        var zipText = encoded?.Text ?? string.Empty;
        var zipStart = encoded?.Start ?? string.Empty;
        var zipEnd = encoded?.End ?? string.Empty;
        var prefixLen = prefixLenHint > 0 ? prefixLenHint : encoded?.PrefixLen ?? 0;

        if (zipMode is not (ModePrefix or ModeExact or ModeRange))
        {
            zipMode = encoded?.Mode;
        }

        if (zipMode == null)
        {
            if (zipLeft.Length > 0 && zipRight.Length == 0)
            {
                zipMode = ModePrefix;
                zipText = zipLeft;
                prefixLen = zipLeft.Length;
            }
            else if (zipLeft.Length > 0 && zipLeft == zipRight)
            {
                zipMode = ModeExact;
                zipText = zipLeft;
                prefixLen = zipLeft.Length;
            }
            else if (zipLeft.Length > 0 && zipRight.Length > 0)
            {
                zipMode = ModeRange;
                zipStart = zipLeft;
                zipEnd = zipRight;
                prefixLen = Math.Min(zipLeft.Length, zipRight.Length);
            }
        }
        else if (dim == DimZip)
        {
            if (zipMode == ModePrefix)
            {
                zipText = zipLeft.Length > 0 ? zipLeft : zipText;
                prefixLen = prefixLen > 0 ? prefixLen : zipText.Length;
            }
            else if (zipMode == ModeExact)
            {
                zipText = zipLeft.Length > 0 ? zipLeft : zipText;
                prefixLen = zipText.Length;
            }
            else if (zipMode == ModeRange)
            {
                zipStart = zipLeft.Length > 0 ? zipLeft : zipStart;
                zipEnd = zipRight.Length > 0 ? zipRight : zipEnd;
                prefixLen = Math.Min(
                    zipStart.Length == 0 ? prefixLen : zipStart.Length,
                    zipEnd.Length == 0 ? prefixLen : zipEnd.Length);
            }
        }

        if (dim == DimZip)
        {
            if (zipMode == null)
            {
                return null;
            }

            return new GeoRule
            {
                Ordinal = ordinal,
                Tag = tag,
                CountryCode = country,
                MatchDim = DimZip,
                MatchMode = zipMode,
                PrefixLen = prefixLen,
                MatchTextStd = zipText,
                ZipStartStd = zipStart,
                ZipEndStd = zipEnd
            };
        }

        var state = NormalizeRegion(province);
        var cityStd = NormalizeRegion(city);
        if (dim == DimCity)
        {
            if (string.IsNullOrEmpty(state) || string.IsNullOrEmpty(cityStd))
            {
                return null;
            }

            return new GeoRule
            {
                Ordinal = ordinal,
                Tag = tag,
                CountryCode = country,
                MatchDim = DimCity,
                MatchMode = ModeExact,
                MatchTextStd = cityStd,
                MatchStateStd = state
            };
        }

        if (dim == DimState)
        {
            if (string.IsNullOrEmpty(state))
            {
                return null;
            }

            return new GeoRule
            {
                Ordinal = ordinal,
                Tag = tag,
                CountryCode = country,
                MatchDim = DimState,
                MatchMode = ModeExact,
                MatchTextStd = state
            };
        }

        return new GeoRule
        {
            Ordinal = ordinal,
            Tag = tag,
            CountryCode = country,
            MatchDim = DimCountry,
            MatchMode = ModeAll
        };
    }

    private static void ApplyZipFields(KpiAreaInfo entity, string? requestedMode)
    {
        entity.Province = null;
        entity.City = null;
        var zipLeft = NormalizeZip(entity.LeftPostcode);
        var zipRight = NormalizeZip(entity.RightPostcode);
        if (zipLeft.Length == 0 && zipRight.Length > 0)
        {
            zipLeft = zipRight;
            zipRight = string.Empty;
        }

        if (zipLeft.Length == 0)
        {
            throw new InvalidOperationException("邮编匹配必须填写起始邮编");
        }

        var mode = requestedMode;
        if (mode is not (ModePrefix or ModeExact or ModeRange))
        {
            if (zipRight.Length == 0)
            {
                mode = ModePrefix;
            }
            else if (zipLeft == zipRight)
            {
                mode = ModeExact;
            }
            else
            {
                mode = ModeRange;
            }
        }

        if (mode == ModePrefix)
        {
            entity.LeftPostcode = zipLeft;
            entity.RightPostcode = null;
            entity.PrefixLen = zipLeft.Length;
        }
        else if (mode == ModeExact)
        {
            entity.LeftPostcode = zipLeft;
            entity.RightPostcode = zipLeft;
            entity.PrefixLen = zipLeft.Length;
        }
        else
        {
            if (zipRight.Length == 0)
            {
                throw new InvalidOperationException("邮编区间必须填写截止邮编");
            }

            if (CompareNormalizedZip(zipLeft, zipRight) > 0)
            {
                throw new InvalidOperationException("起始邮编不能大于截止邮编");
            }

            entity.LeftPostcode = zipLeft;
            entity.RightPostcode = zipRight;
            entity.PrefixLen = Math.Min(zipLeft.Length, zipRight.Length);
        }

        entity.MatchDim = DimZip;
        entity.MatchMode = mode;
    }

    private static string InferDim(
        string? leftPostcode,
        string? rightPostcode,
        string? province,
        string? city,
        string? postcodeRange = null)
    {
        if (!string.IsNullOrWhiteSpace(postcodeRange)
            || !string.IsNullOrWhiteSpace(leftPostcode)
            || !string.IsNullOrWhiteSpace(rightPostcode))
        {
            return DimZip;
        }

        if (!string.IsNullOrWhiteSpace(city))
        {
            return DimCity;
        }

        if (!string.IsNullOrWhiteSpace(province))
        {
            return DimState;
        }

        return DimCountry;
    }

    private static string? NormalizeDim(string? value)
    {
        var raw = value?.Trim().ToLowerInvariant();
        return raw switch
        {
            DimZip or "postcode" or "postal" or "邮编" => DimZip,
            DimState or "province" or "州" or "州/省" or "省" => DimState,
            DimCity or "城市" => DimCity,
            DimCountry or "国家" or "仅国家" => DimCountry,
            _ => null
        };
    }

    private static string? NormalizeMode(string? value)
    {
        var raw = value?.Trim().ToLowerInvariant();
        return raw switch
        {
            ModePrefix or "前缀" => ModePrefix,
            ModeExact or "精确" or "exactmatch" => ModeExact,
            ModeRange or "区间" => ModeRange,
            ModeAll or "全部" => ModeAll,
            _ => null
        };
    }

    private static EncodedZip? TryParseEncodedRange(string? postcodeRange)
    {
        if (string.IsNullOrWhiteSpace(postcodeRange))
        {
            return null;
        }

        var raw = postcodeRange.Trim();
        if (raw.StartsWith("prefix:", StringComparison.OrdinalIgnoreCase))
        {
            var text = NormalizeZip(raw["prefix:".Length..]);
            if (text.Length == 0)
            {
                return null;
            }

            return new EncodedZip(ModePrefix, text, string.Empty, string.Empty, text.Length);
        }

        if (raw.StartsWith("exact:", StringComparison.OrdinalIgnoreCase))
        {
            var text = NormalizeZip(raw["exact:".Length..]);
            if (text.Length == 0)
            {
                return null;
            }

            return new EncodedZip(ModeExact, text, string.Empty, string.Empty, text.Length);
        }

        var match = PostcodeRangePattern.Match(raw);
        if (!match.Success)
        {
            return null;
        }

        var left = NormalizeZip(match.Groups[1].Value);
        var right = NormalizeZip(match.Groups[2].Value);
        if (left.Length == 0 && right.Length == 0)
        {
            return null;
        }

        if (left.Length == 0)
        {
            left = right;
        }

        if (right.Length == 0)
        {
            return new EncodedZip(ModePrefix, left, string.Empty, string.Empty, left.Length);
        }

        if (left == right)
        {
            return new EncodedZip(ModeExact, left, string.Empty, string.Empty, left.Length);
        }

        return new EncodedZip(ModeRange, string.Empty, left, right, Math.Min(left.Length, right.Length));
    }

    private static List<GeoRule> CompileList<T>(IEnumerable<T>? sources, Func<T, int, bool, GeoRule?> compile)
    {
        var list = new List<GeoRule>();
        if (sources == null)
        {
            return list;
        }

        var ordinal = 0;
        foreach (var source in sources)
        {
            var rule = compile(source, ordinal++, true);
            if (rule != null)
            {
                list.Add(rule);
            }
        }

        return list;
    }

    private static int DimRank(GeoRule rule) =>
        rule.MatchDim switch
        {
            DimZip => 1,
            DimState => 2,
            DimCity => 3,
            DimCountry => 4,
            _ => 9
        };

    private static int RangeSpecificity(GeoRule rule)
    {
        if (rule.MatchDim != DimZip)
        {
            return 0;
        }

        if (rule.MatchMode == ModeExact)
        {
            return rule.MatchTextStd.Length * 10;
        }

        if (rule.MatchMode == ModeRange)
        {
            return Math.Min(rule.ZipStartStd.Length, rule.ZipEndStd.Length);
        }

        return 0;
    }

    private static string? EmptyToNull(string? value) =>
        string.IsNullOrWhiteSpace(value) ? null : value.Trim();

    private sealed record EncodedZip(string Mode, string Text, string Start, string End, int PrefixLen);
}