마작 역(役)은 어떻게 판별할까 — 손패 분해 알고리즘과 디텍터 설계 기록

public const int TileTypeCount = 34;

public static int[] ToCounts(IEnumerable<Tile> tiles)
{
    var counts = new int[TileTypeCount];
    foreach (var t in tiles) counts[(int)t.Type]++;
    return counts;
}

private static bool IsSuitedIndex(int index) => index < 27;

public static bool IsChiitoitsu(IReadOnlyList<Tile> tiles)
{
    if (tiles.Count != 14) return false;
    var counts = ToCounts(tiles);
    int pairs = 0;
    foreach (int c in counts)
    {
        if (c == 0) continue;
        if (c != 2) return false; // 1·3·4장이 섞이면 치또이 아님
        pairs++;
    }
    return pairs == 7;
}

public static List<ConcealedForm> StandardForms(IReadOnlyList<Tile> tiles)
{
    var forms = new List<ConcealedForm>();
    if (tiles.Count % 3 != 2) return forms; // 3k+2장이 아니면 화료형 불가

    var counts = ToCounts(tiles);

    for (int pair = 0; pair < TileTypeCount; pair++)
    {
        if (counts[pair] < 2) continue;
        counts[pair] -= 2;                       // 머리 떼기
        foreach (var melds in EnumerateMelds(counts))
            forms.Add(new ConcealedForm(melds, Tile.Of((TileType)pair)));
        counts[pair] += 2;                       // 되돌리기
    }
    return forms;
}

private static List<List<Meld>> EnumerateMelds(int[] counts)
{
    int i = 0;
    while (i < TileTypeCount && counts[i] == 0) i++;

    if (i == TileTypeCount)
        return new List<List<Meld>> { new() }; // 다 비었으면 완성 (빈 분해 1개)

    var results = new List<List<Meld>>();

    // ① 코츠 분기 — 같은 패 3장
    if (counts[i] >= 3)
    {
        counts[i] -= 3;
        foreach (var rest in EnumerateMelds(counts))
        {
            rest.Insert(0, Meld.Koutsu(Tile.Of((TileType)i)));
            results.Add(rest);
        }
        counts[i] += 3;
    }

    // ② 슌츠 분기 — i, i+1, i+2 연속 (수패·끗수 1~7·다음 두 패 존재)
    if (IsSuitedIndex(i) && (i % 9) <= 6 && counts[i + 1] > 0 && counts[i + 2] > 0)
    {
        counts[i]--; counts[i + 1]--; counts[i + 2]--;
        foreach (var rest in EnumerateMelds(counts))
        {
            rest.Insert(0, Meld.Shuntsu(Tile.Of((TileType)i)));
            results.Add(rest);
        }
        counts[i]++; counts[i + 1]++; counts[i + 2]++;
    }

    return results;
}

private static bool IsBetter(WinEvaluation candidate, WinEvaluation current)
{
    if (current == null) return true;
    if (candidate.TotalPoints != current.TotalPoints)
        return candidate.TotalPoints > current.TotalPoints; // 1순위: 총점
    if (candidate.TotalHan != current.TotalHan)
        return candidate.TotalHan > current.TotalHan;        // 2순위: 한수
    return candidate.Fu > current.Fu;                         // 3순위: 부수
}

foreach (var form in HandDecomposer.StandardForms(full))
{
    var allMelds = new List<Meld>(ctx.OpenMelds);
    allMelds.AddRange(form.Melds);

    // 머리 단기 (화료 패가 머리를 완성)
    if (form.Pair.Type == ctx.WinningTile.Type)
        result.Add(new HandDecomposition(allMelds, form.Pair, WaitType.Tanki, ...));

    // 면자 완성 (화료 패가 손패 면자 중 하나를 완성)
    for (int j = 0; j < form.Melds.Count; j++)
    {
        var meld = form.Melds[j];
        if (meld.Tiles.All(t => t.Type != ctx.WinningTile.Type)) continue;
        var wait = ComputeWait(meld, ctx.WinningTile);  // 양면/간짱/변짱/샤보 분류
        result.Add(new HandDecomposition(allMelds, form.Pair, wait, ..., winningMeldIndex: openCount + j));
    }
}

private static WaitType ComputeWait(Meld meld, Tile winningTile)
{
    if (meld.Type == MeldType.Koutsu) return WaitType.Shanpon; // 쌍 2개 중 하나
    int a = meld.Lead.Rank;   // 슌츠 최저 끗수
    int r = winningTile.Rank; // 화료 패 끗수
    if (r == a + 1) return WaitType.Kanchan;        // 1_3 → 2 (간짱)
    if (a == 1 && r == 3) return WaitType.Penchan;  // 12 → 3 (변짱)
    if (a == 7 && r == 7) return WaitType.Penchan;  // 89 → 7 (변짱)
    return WaitType.Ryanmen;                         // 양면
}

public static List<TileType> WaitingTiles(IReadOnlyList<Tile> closedHand, ...)
{
    var waits = new List<TileType>();
    for (int t = 0; t < HandDecomposer.TileTypeCount; t++)
    {
        if (counts[t] >= 4) continue; // 5번째 패는 존재 불가
        var probe = new WinContext { ClosedHand = ..., WinningTile = Tile.Of((TileType)t) };
        if (WinChecker.IsComplete(probe)) waits.Add((TileType)t);
    }
    return waits;
}

public interface IYakuDetector
{
    bool CanApply(WinContext ctx);    // 이 역을 평가할 형태인가 (빠른 거름)
    YakuResult Evaluate(WinContext ctx); // 성립하면 한수, 아니면 None
}

public sealed class PinfuDetector : IYakuDetector
{
    public bool CanApply(WinContext ctx) => ctx.IsMenzen && (ctx.BestDecomp?.IsStandard ?? false);
    public YakuResult Evaluate(WinContext ctx)
        => ScoringRules.IsPinfu(ctx.BestDecomp, ctx) ? new YakuResult("Pinfu", 1) : YakuResult.None;
}

public List<YakuResult> Evaluate(WinContext ctx)
{
    var results = _detectors
        .Where(d => d.CanApply(ctx))
        .Select(d => d.Evaluate(ctx))
        .Where(r => r.IsValid)
        .ToList();

    // 역만이 1개라도 있으면 일반 역은 모두 제거 (역만 우선)
    if (results.Any(r => r.IsYakuman))
        results = results.Where(r => r.IsYakuman).ToList();

    return results;
}

public static bool IsPinfu(HandDecomposition decomp, WinContext ctx)
{
    if (!decomp.IsStandard) return false;
    if (!ctx.IsMenzen) return false;
    if (decomp.Melds.Any(m => m.Type != MeldType.Shuntsu)) return false;   // 코츠 있으면 탈락
    if (decomp.WaitType != WaitType.Ryanmen) return false;                 // 양면 아니면 탈락
    if (decomp.Pair.IsValueTile(ctx.SeatWind, ctx.RoundWind)) return false; // 역패 머리면 탈락
    return true;
}

public static bool IsConcealedTriplet(Meld meld, HandDecomposition decomp, WinType winType)
{
    if (meld.Type != MeldType.Koutsu && meld.Type != MeldType.Kantsu) return false;
    if (!meld.IsConcealed) return false;
    if (meld.Type == MeldType.Kantsu) return true;          // 안깡은 항상 안커
    // 손안 코츠라도 론으로 완성한 면자면 안커가 아니다
    return !(winType == WinType.Ron && ReferenceEquals(meld, decomp.WinningMeld));
}

public static int IdenticalSequencePairs(HandDecomposition d)
{
    int pairs = 0;
    foreach (var g in d.Melds.Where(m => m.Type == MeldType.Shuntsu).GroupBy(m => m.Lead.Type))
        pairs += g.Count() / 2;  // 같은 시작 슌츠 2개 = 1쌍
    return pairs; // 1이면 이페코, 2면 량페코
}

private static readonly int[] BasePattern = { 0, 3, 1, 1, 1, 1, 1, 1, 1, 3 }; // rank 1~9

// 한 색만 쓰고 자패 없음 → 끗수별 카운트가 기본 패턴을 전부 만족하고, 초과분이 정확히 1장
int extra = 0;
for (int r = 1; r <= 9; r++)
{
    int diff = counts[r] - BasePattern[r];
    if (diff < 0) return YakuResult.None; // 기본 패턴 미충족
    extra += diff;
}
if (extra != 1) return YakuResult.None;

foreach (var decomp in candidates)
{
    ctx.BestDecomp = decomp;
    var yaku = _registry.Evaluate(ctx);

    // 역 없으면 이 후보는 화료 불가 → 건너뜀
    if (!yaku.Any(y => y.Name != "WinDeclarerBonus")) { sawYakuless = true; continue; }

    int fu  = FuCalculator.Calculate(decomp, ctx);
    int dora = DoraCounter.Count(ctx.AllTiles(), doraIndicators, ...);
    var score = ScoreCalculator.CalculateScore(yaku, fu, dora, ctx.IsOya);
    var eval = WinEvaluation.Win(decomp, yaku, fu, dora, score, ...);

    if (IsBetter(eval, best)) best = eval; // 한수 최대화
}

if (best == null)
    return WinEvaluation.NoWin(sawYakuless ? "역 없음 (도라만으로는 화료 불가)" : "완성형 아님");