ANTOOZA-BACKEND/Infrastructure/StockData/SeibroBondSyncService.cs

using Application.Abstractions.Data;
using Application.Helpers;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using SharedKernel;

namespace Infrastructure.StockData;

/// <summary>
/// SEIBro 채권·단기금융 수집 (Wave 4) — 기본 07:40 KST(CorpActionSync 07:20 다음 슬롯), `Seibro:BondSync` 게이트.
/// 전 단계가 채권(Bond) 예산(Seibro:BondBudget)을 공유한다.
///
/// a) BondIssuance: getBondIssuInfo 날짜 스윕(ISSU_DT, 발행일) 3년 → 발견(다수 종목/일).
/// b) BondMaster rolling: 대상 = BondIssuance.Isin ∪ 기존 KRX BondDailyTrade.Code(ISIN) 중복 제거, 미수집·stale 우선 →
///    getBondStatInfo(ISIN) → PK Isin upsert(신용등급 4사 포함).
/// c) BondInterestPayment rolling: BondMaster 있는 ISIN → getIntPayInfo(ISIN) → PK Isin 스냅샷 갱신.
/// d) BondEarlyRedemption: getBondOptionXrcInfo 날짜 스윕(ERLY_RED_DT, 조기상환일) 3년 → 조기상환일 window delete+insert.
/// e) ShortTermIssuance: getShortmIssuInfo 날짜 스윕(ISSU_DT) × SECN_TPCD{12,13,14} 3년 → 발견(다수 종목/일).
/// f) Cd/Cp/Estb Master rolling: ShortTermIssuance 발견분 중 SECN_TPCD 별 대상(13→CdMaster/getCDInfo, 12→CpMaster/getCPInfo,
///    14→EstbMaster/getESTBInfo), **최근 발행 우선**(IssuDt desc — CP/전단채 유니버스 과대) → 각 마스터 upsert.
///
/// 실패/0행 = 정상 빈결과. HTTP·파싱 오류 = 경고 + false(RetryDelay 후 재시도). quota 소진 = 정상 종료(true). ApiKey 미설정 시 skip.
/// ⚠️ getIntPayInfo·getCDInfo 실샘플이 result="0" 이라 이자/CD 필드 매핑은 스펙 기준 — 운영 첫 수집 시 로그로 확인.
/// ⚠️ CP/전단채 유니버스 과대(일 수백 발행) → 최근발행 우선 rolling + BackfillYears 컷으로 예산 내.
/// </summary>
internal sealed class SeibroBondSyncService(
    IServiceScopeFactory scopeFactory,
    IHttpClientFactory httpClientFactory,
    SeibroQuota quota,
    IOptions<AppSettings> settings,
    ILogger<SeibroBondSyncService> logger
) : DailyScheduledService(logger)
{
    // 단기금융증권 종목구분 (SECN_TPCD) — 12어음(CP) 13CD 14전자단기사채
    private static readonly string[] ShortTermSecnTpcds = ["12", "13", "14"];

    protected override string JobName => "SeibroBondSync";

    protected override TimeOnly TargetTime => ParseTime(settings.Value.Seibro.BondSyncTime, new TimeOnly(7, 40));

    protected override int MaxRetryCount => 2;

    protected override TimeSpan RetryDelay => TimeSpan.FromHours(2);

    protected override async Task<bool> RunOnceAsync(DateOnly todayKst, CancellationToken ct)
    {
        var cfg = settings.Value.Seibro;
        if (string.IsNullOrWhiteSpace(cfg.ApiKey))
        {
            Logger.LogWarning("[{Job}] Seibro:ApiKey 미설정 — 수집 skip", JobName);
            return true;
        }

        using var scope = scopeFactory.CreateScope();
        var db = scope.ServiceProvider.GetRequiredService<IAppDbContext>();
        var client = httpClientFactory.CreateClient(SeibroHttp.ClientName);

        var years = cfg.BackfillYears > 0 ? cfg.BackfillYears : 3;
        var startDate = todayKst.AddYears(-years);

        try
        {
            // a) 채권 발행내역 날짜 스윕 (Bond) — BondMaster 발견 소스
            if (!await SweepBondIssuancesAsync(db, client, cfg, startDate, todayKst, ct))
            {
                return true;
            }

            // b) 채권 마스터 rolling per-ISIN (Bond) — BondIssuance ∪ KRX BondDailyTrade ISIN
            if (!await RollBondMastersAsync(db, client, cfg, ct))
            {
                return true;
            }

            // c) 이자지급 rolling per-ISIN (Bond) — BondMaster 있는 것
            if (!await RollInterestPaymentsAsync(db, client, cfg, ct))
            {
                return true;
            }

            // d) 조기상환 날짜 스윕 (Bond)
            if (!await SweepEarlyRedemptionsAsync(db, client, cfg, startDate, todayKst, ct))
            {
                return true;
            }

            // e) 단기금융증권 발행 날짜 스윕 × 구분{12,13,14} (Bond)
            if (!await SweepShortTermIssuancesAsync(db, client, cfg, startDate, todayKst, ct))
            {
                return true;
            }

            // f) CD/CP/전단채 마스터 rolling per-ISIN (Bond) — 최근발행 우선
            await RollShortTermMastersAsync(db, client, cfg, ct);
            return true;
        }
        catch (Exception ex) when (ex is HttpRequestException or System.Xml.XmlException or FormatException)
        {
            Logger.LogWarning(ex, "[{Job}] SEIBro 호출/파싱 실패 — run 중단, {Delay} 후 재시도 (최대 {Max}회)", JobName, RetryDelay, MaxRetryCount);
            return false;
        }
    }

    /// <summary>
    /// a) 채권 발행내역 날짜 스윕(ISSU_DT, 최신→과거) — 미적재 발행일만. 발행일당 다수 종목 upsert(UQ Isin). 예산 소진 시 false.
    /// ⚠️ 발행일은 영업일 성격이나 스펙 확정 불가라 전 캘린더일 스윕(보수적, 기존 SEIBro 배치 판단과 동일).
    /// </summary>
    private async Task<bool> SweepBondIssuancesAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, DateOnly startDate, DateOnly today, CancellationToken ct)
    {
        var fetched = 0;
        var first = true;

        for (var day = today; day >= startDate; day = day.AddDays(-1))
        {
            ct.ThrowIfCancellationRequested();

            if (await db.BondIssuance.AsNoTracking().AnyAsync(c => c.IssuDt == day, ct))
            {
                continue; // 이미 적재된 발행일 — resumable
            }

            if (!quota.TryConsume(SeibroCategory.Bond, 1, cfg.BondBudget))
            {
                Logger.LogWarning("[{Job}] 채권 예산({Budget}) 소진 — getBondIssuInfo {Day} 부터 중단", JobName, cfg.BondBudget, day);
                return false;
            }

            if (!first && cfg.DelayMs > 0)
            {
                await Task.Delay(cfg.DelayMs, ct);
            }

            first = false;

            var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getBondIssuInfo", [new("ISSU_DT", day.ToString("yyyyMMdd"))], Logger, ct);
            var rows = SeibroBondIssuParser.Parse(SeibroXml.Parse(xml));
            var (inserted, updated) = await SeibroBondImport.UpsertBondIssuancesAsync(db, rows, ct);

            Logger.LogInformation("[{Job}] getBondIssuInfo {Day} rows={Rows} — inserted={Inserted}, updated={Updated}", JobName, day, rows.Count, inserted, updated);
            fetched++;
        }

        Logger.LogInformation("[{Job}] 채권 발행 스윕 완료 — 창=[{Start}~{End}], fetch={Fetched}일", JobName, startDate, today, fetched);
        return true;
    }

    /// <summary>
    /// b) 채권 마스터 rolling — 대상 = BondIssuance.Isin ∪ 기존 KRX BondDailyTrade.Code(ISIN) 중복 제거, BondMaster 미수집·stale 우선.
    /// getBondStatInfo(ISIN) 1콜(Bond) → PK Isin upsert(신용등급 4사 포함, ISIN 요청값 스탬핑). 예산 소진 시 false.
    /// </summary>
    private async Task<bool> RollBondMastersAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        var issuedIsins = await db.BondIssuance.AsNoTracking().Select(c => c.Isin).Distinct().ToListAsync(ct);
        var krxIsins = await db.BondDailyTrade.AsNoTracking().Select(c => c.Code).Distinct().ToListAsync(ct);
        var universe = issuedIsins.Union(krxIsins, StringComparer.Ordinal).ToList();

        if (universe.Count == 0)
        {
            Logger.LogInformation("[{Job}] getBondStatInfo 대상 없음 (BondIssuance ∪ KRX BondDailyTrade 비어 있음)", JobName);
            return true;
        }

        var lastByIsin = await db.BondMaster.AsNoTracking().Select(c => new { c.Isin, c.UpdatedAt }).ToDictionaryAsync(c => c.Isin, c => c.UpdatedAt, ct);
        var targets = universe.Select(isin => (Key: isin, LastUpdatedAt: lastByIsin.TryGetValue(isin, out var last) ? (DateTime?)last : null)).ToList();

        var maxPerRun = quota.Remaining(SeibroCategory.Bond, cfg.BondBudget);
        var quotaExhausted = false;

        var processed = await SeibroRollingSweep.RunAsync(
            targets: targets,
            fetchAndUpsert: async (isin, token) => {
                if (!quota.TryConsume(SeibroCategory.Bond, 1, cfg.BondBudget))
                {
                    quotaExhausted = true;
                    return;
                }

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getBondStatInfo", [new("ISIN", isin)], Logger, token);
                var rows = SeibroBondStatParser.Parse(SeibroXml.Parse(xml));
                var ok = await SeibroBondImport.UpsertBondMasterAsync(db, isin, rows, token);

                Logger.LogInformation("[{Job}] getBondStatInfo ISIN={Isin} rows={Rows} — upsert={Ok}", JobName, isin, rows.Count, ok);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

        Logger.LogInformation("[{Job}] 채권 마스터 rolling 완료 — 유니버스={Universe}(발행={Issued}∪KRX={Krx}), 처리={Processed} (maxPerRun={Max})", JobName, universe.Count, issuedIsins.Count, krxIsins.Count, processed, maxPerRun);
        return !quotaExhausted;
    }

    /// <summary>
    /// c) 이자지급 rolling — BondMaster 있는 ISIN 중 BondInterestPayment 미수집·stale 우선.
    /// getIntPayInfo(ISIN) 1콜(Bond) → PK Isin 스냅샷 갱신(ISIN 요청값 스탬핑). 예산 소진 시 false.
    /// </summary>
    private async Task<bool> RollInterestPaymentsAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        var masterIsins = await db.BondMaster.AsNoTracking().Select(c => c.Isin).ToListAsync(ct);

        if (masterIsins.Count == 0)
        {
            Logger.LogInformation("[{Job}] getIntPayInfo 대상 없음 (BondMaster 비어 있음)", JobName);
            return true;
        }

        var lastByIsin = await db.BondInterestPayment.AsNoTracking().Select(c => new { c.Isin, c.UpdatedAt }).ToDictionaryAsync(c => c.Isin, c => c.UpdatedAt, ct);
        var targets = masterIsins.Select(isin => (Key: isin, LastUpdatedAt: lastByIsin.TryGetValue(isin, out var last) ? (DateTime?)last : null)).ToList();

        var maxPerRun = quota.Remaining(SeibroCategory.Bond, cfg.BondBudget);
        var quotaExhausted = false;

        var processed = await SeibroRollingSweep.RunAsync(
            targets: targets,
            fetchAndUpsert: async (isin, token) => {
                if (!quota.TryConsume(SeibroCategory.Bond, 1, cfg.BondBudget))
                {
                    quotaExhausted = true;
                    return;
                }

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getIntPayInfo", [new("ISIN", isin)], Logger, token);
                var rows = SeibroIntPayParser.Parse(SeibroXml.Parse(xml));
                var ok = await SeibroBondImport.UpsertInterestPaymentAsync(db, isin, rows, token);

                Logger.LogInformation("[{Job}] getIntPayInfo ISIN={Isin} rows={Rows} — upsert={Ok}", JobName, isin, rows.Count, ok);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

        Logger.LogInformation("[{Job}] 이자지급 rolling 완료 — 대상={Targets}, 처리={Processed} (maxPerRun={Max})", JobName, targets.Count, processed, maxPerRun);
        return !quotaExhausted;
    }

    /// <summary>
    /// d) 조기상환 날짜 스윕(ERLY_RED_DT, 최신→과거) — 미적재 조기상환일만. 조기상환일 window delete+insert. 예산 소진 시 false.
    /// ⚠️ 조기상환일은 영업일 성격이나 스펙 확정 불가라 전 캘린더일 스윕(보수적).
    /// </summary>
    private async Task<bool> SweepEarlyRedemptionsAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, DateOnly startDate, DateOnly today, CancellationToken ct)
    {
        var fetched = 0;
        var first = true;

        for (var day = today; day >= startDate; day = day.AddDays(-1))
        {
            ct.ThrowIfCancellationRequested();

            if (await db.BondEarlyRedemption.AsNoTracking().AnyAsync(c => c.ErlyRedDt == day, ct))
            {
                continue; // 이미 적재된 조기상환일 — resumable
            }

            if (!quota.TryConsume(SeibroCategory.Bond, 1, cfg.BondBudget))
            {
                Logger.LogWarning("[{Job}] 채권 예산({Budget}) 소진 — getBondOptionXrcInfo {Day} 부터 중단", JobName, cfg.BondBudget, day);
                return false;
            }

            if (!first && cfg.DelayMs > 0)
            {
                await Task.Delay(cfg.DelayMs, ct);
            }

            first = false;

            var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getBondOptionXrcInfo", [new("ERLY_RED_DT", day.ToString("yyyyMMdd"))], Logger, ct);
            var rows = SeibroBondOptionXrcParser.Parse(SeibroXml.Parse(xml));
            var (inserted, deleted) = await SeibroBondImport.ReplaceEarlyRedemptionWindowAsync(db, day, day, rows, ct);

            Logger.LogInformation("[{Job}] getBondOptionXrcInfo {Day} rows={Rows} — inserted={Inserted}, deleted={Deleted}", JobName, day, rows.Count, inserted, deleted);
            fetched++;
        }

        Logger.LogInformation("[{Job}] 조기상환 스윕 완료 — 창=[{Start}~{End}], fetch={Fetched}일", JobName, startDate, today, fetched);
        return true;
    }

    /// <summary>
    /// e) 단기금융증권 발행 날짜 스윕(ISSU_DT, 최신→과거) × SECN_TPCD{12,13,14} — 미적재 (발행일,구분)만.
    /// 발행일당 다수 종목 upsert(UQ Isin, SECN_TPCD·ISSU_DT 스탬핑). 예산 소진 시 false. 발견분이 (f) 마스터 rolling 대상.
    /// resumable 판정: 해당 발행일·구분으로 스탬핑된 ShortTermIssuance 존재 여부.
    /// </summary>
    private async Task<bool> SweepShortTermIssuancesAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, DateOnly startDate, DateOnly today, CancellationToken ct)
    {
        var fetched = 0;
        var first = true;

        for (var day = today; day >= startDate; day = day.AddDays(-1))
        {
            foreach (var tpcd in ShortTermSecnTpcds)
            {
                ct.ThrowIfCancellationRequested();

                if (await db.ShortTermIssuance.AsNoTracking().AnyAsync(c => c.IssuDt == day && c.SecnTpcd == tpcd, ct))
                {
                    continue; // 이미 적재된 (발행일, 구분) — resumable
                }

                if (!quota.TryConsume(SeibroCategory.Bond, 1, cfg.BondBudget))
                {
                    Logger.LogWarning("[{Job}] 채권 예산({Budget}) 소진 — getShortmIssuInfo {Day}/{Tpcd} 부터 중단", JobName, cfg.BondBudget, day, tpcd);
                    return false;
                }

                if (!first && cfg.DelayMs > 0)
                {
                    await Task.Delay(cfg.DelayMs, ct);
                }

                first = false;

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getShortmIssuInfo", [new("ISSU_DT", day.ToString("yyyyMMdd")), new("SECN_TPCD", tpcd)], Logger, ct);
                var rows = SeibroShortmIssuParser.Parse(SeibroXml.Parse(xml));
                var (inserted, updated) = await SeibroBondImport.UpsertShortTermIssuancesAsync(db, tpcd, day, rows, ct);

                Logger.LogInformation("[{Job}] getShortmIssuInfo {Day}/{Tpcd} rows={Rows} — inserted={Inserted}, updated={Updated}", JobName, day, tpcd, rows.Count, inserted, updated);
                fetched++;
            }
        }

        Logger.LogInformation("[{Job}] 단기금융 발행 스윕 완료 — 창=[{Start}~{End}], fetch={Fetched}콜", JobName, startDate, today, fetched);
        return true;
    }

    /// <summary>
    /// f) CD/CP/전단채 마스터 rolling — ShortTermIssuance 발견분 중 SECN_TPCD 별로 미수집·**최근 발행 우선**(IssuDt desc, 유니버스 과대).
    /// 13→CdMaster(getCDInfo), 12→CpMaster(getCPInfo), 14→EstbMaster(getESTBInfo). 각 마스터 PK Isin upsert(ISIN 요청값 스탬핑).
    /// 채권 예산 공유. rolling sweep 은 미수집(마스터 없음) 우선이나 유니버스가 과대해 후보를 IssuDt desc 로 컷해 넣는다.
    /// </summary>
    private async Task RollShortTermMastersAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        await RollCdAsync(db, client, cfg, ct);
        await RollCpAsync(db, client, cfg, ct);
        await RollEstbAsync(db, client, cfg, ct);
    }

    private async Task RollCdAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        var maxPerRun = quota.Remaining(SeibroCategory.Bond, cfg.BondBudget);
        if (maxPerRun <= 0)
        {
            return;
        }

        // 미수집 우선 + 최근 발행 우선(IssuDt desc) — 유니버스 과대라 후보를 maxPerRun 배수로 컷
        var candidates = await db.ShortTermIssuance.AsNoTracking()
            .Where(c => c.SecnTpcd == "13" && !db.CdMaster.Any(m => m.Isin == c.Isin))
            .OrderByDescending(c => c.IssuDt)
            .Select(c => c.Isin)
            .Take(maxPerRun)
            .ToListAsync(ct);

        var processed = await SeibroRollingSweep.RunAsync(
            targets: candidates.Select(isin => (Key: isin, LastUpdatedAt: (DateTime?)null)).ToList(),
            fetchAndUpsert: async (isin, token) => {
                if (!quota.TryConsume(SeibroCategory.Bond, 1, cfg.BondBudget))
                {
                    return;
                }

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getCDInfo", [new("ISIN", isin)], Logger, token);
                var rows = SeibroCDParser.Parse(SeibroXml.Parse(xml));
                var ok = await SeibroBondImport.UpsertCdMasterAsync(db, isin, rows, token);

                Logger.LogInformation("[{Job}] getCDInfo ISIN={Isin} rows={Rows} — upsert={Ok}", JobName, isin, rows.Count, ok);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

        Logger.LogInformation("[{Job}] CD 마스터 rolling 완료 — 후보={Cands}, 처리={Processed} (maxPerRun={Max})", JobName, candidates.Count, processed, maxPerRun);
    }

    private async Task RollCpAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        var maxPerRun = quota.Remaining(SeibroCategory.Bond, cfg.BondBudget);
        if (maxPerRun <= 0)
        {
            return;
        }

        var candidates = await db.ShortTermIssuance.AsNoTracking()
            .Where(c => c.SecnTpcd == "12" && !db.CpMaster.Any(m => m.Isin == c.Isin))
            .OrderByDescending(c => c.IssuDt)
            .Select(c => c.Isin)
            .Take(maxPerRun)
            .ToListAsync(ct);

        var processed = await SeibroRollingSweep.RunAsync(
            targets: candidates.Select(isin => (Key: isin, LastUpdatedAt: (DateTime?)null)).ToList(),
            fetchAndUpsert: async (isin, token) => {
                if (!quota.TryConsume(SeibroCategory.Bond, 1, cfg.BondBudget))
                {
                    return;
                }

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getCPInfo", [new("ISIN", isin)], Logger, token);
                var rows = SeibroCPParser.Parse(SeibroXml.Parse(xml));
                var ok = await SeibroBondImport.UpsertCpMasterAsync(db, isin, rows, token);

                Logger.LogInformation("[{Job}] getCPInfo ISIN={Isin} rows={Rows} — upsert={Ok}", JobName, isin, rows.Count, ok);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

        Logger.LogInformation("[{Job}] CP 마스터 rolling 완료 — 후보={Cands}, 처리={Processed} (maxPerRun={Max})", JobName, candidates.Count, processed, maxPerRun);
    }

    private async Task RollEstbAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        var maxPerRun = quota.Remaining(SeibroCategory.Bond, cfg.BondBudget);
        if (maxPerRun <= 0)
        {
            return;
        }

        var candidates = await db.ShortTermIssuance.AsNoTracking()
            .Where(c => c.SecnTpcd == "14" && !db.EstbMaster.Any(m => m.Isin == c.Isin))
            .OrderByDescending(c => c.IssuDt)
            .Select(c => c.Isin)
            .Take(maxPerRun)
            .ToListAsync(ct);

        var processed = await SeibroRollingSweep.RunAsync(
            targets: candidates.Select(isin => (Key: isin, LastUpdatedAt: (DateTime?)null)).ToList(),
            fetchAndUpsert: async (isin, token) => {
                if (!quota.TryConsume(SeibroCategory.Bond, 1, cfg.BondBudget))
                {
                    return;
                }

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getESTBInfo", [new("ISIN", isin)], Logger, token);
                var rows = SeibroESTBParser.Parse(SeibroXml.Parse(xml));
                var ok = await SeibroBondImport.UpsertEstbMasterAsync(db, isin, rows, token);

                Logger.LogInformation("[{Job}] getESTBInfo ISIN={Isin} rows={Rows} — upsert={Ok}", JobName, isin, rows.Count, ok);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

        Logger.LogInformation("[{Job}] 전단채 마스터 rolling 완료 — 후보={Cands}, 처리={Processed} (maxPerRun={Max})", JobName, candidates.Count, processed, maxPerRun);
    }
}