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"];

    // 마커 job 키 (리뷰 결함 #1) — 정상 0행/조용한 날 재조회·starvation 해소
    private const string IssuanceJobKey = "bond-issuance";      // date-sweep (SweptDate)
    private const string EarlyRedJobKey = "bond-earlyred";      // date-sweep (SweptDate)
    private const string ShortTermJobKey = "bond-shortterm";    // date-sweep (SweptDate, Discriminator=tpcd)
    private const string BondStatJobKey = "bond-stat";           // rolling (FetchMarker, key=ISIN)
    private const string IntPayJobKey = "bond-intpay";           // rolling (FetchMarker, key=ISIN)
    private const string CdJobKey = "bond-cd";                   // rolling (FetchMarker, key=ISIN)
    private const string CpJobKey = "bond-cp";                   // rolling (FetchMarker, key=ISIN)
    private const string EstbJobKey = "bond-estb";              // rolling (FetchMarker, key=ISIN)

    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;

        using var scope = scopeFactory.CreateScope();
        var collectorSettings = scope.ServiceProvider.GetRequiredService<ICollectorSettingsProvider>();
        if (!await collectorSettings.IsEnabledAsync(CollectorFlag.SeibroBond, ct))
        {
            return true;
        }
        cfg = cfg with { ApiKey = await collectorSettings.GetKeyAsync(CollectorKey.Seibro, ct) ?? cfg.ApiKey };
        if (string.IsNullOrWhiteSpace(cfg.ApiKey))
        {
            Logger.LogWarning("[{Job}] Seibro:ApiKey 미설정 — 수집 skip", JobName);
            return true;
        }

        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);

        // 단계별 독립 실행 — 한 단계의 SEIBro 오류가 다른 단계를 막지 않도록 개별 try/catch.
        // 반환 false = 예산 소진(전체 중단). 파싱/HTTP 오류 = 해당 단계만 skip(마커 미기록 → 다음 실행 재시도).
        async Task<bool> Phase(string name, Func<CancellationToken, Task<bool>> body)
        {
            try
            {
                return await body(ct);
            }
            catch (Exception ex) when (ex is HttpRequestException or System.Xml.XmlException or FormatException)
            {
                Logger.LogWarning(ex, "[{Job}] {Phase} SEIBro 오류 — 단계 skip(다음 실행 재시도)", JobName, name);
                return true;
            }
        }

        // a) 채권 발행 → b) 채권 마스터 → c) 이자지급 → d) 조기상환 → e) 단기금융 발행 → f) 단기금융 마스터
        if (!await Phase("채권발행", t => SweepBondIssuancesAsync(db, client, cfg, startDate, todayKst, t))) { return true; }
        if (!await Phase("채권마스터", t => RollBondMastersAsync(db, client, cfg, t))) { return true; }
        if (!await Phase("이자지급", t => RollInterestPaymentsAsync(db, client, cfg, t))) { return true; }
        if (!await Phase("조기상환", t => SweepEarlyRedemptionsAsync(db, client, cfg, startDate, todayKst, t))) { return true; }
        if (!await Phase("단기금융발행", t => SweepShortTermIssuancesAsync(db, client, cfg, startDate, todayKst, t))) { return true; }

        // f) CD/CP/전단채 마스터 rolling (void 반환) — 개별 try/catch
        await Phase("단기금융마스터", async t => { await RollShortTermMastersAsync(db, client, cfg, t); return true; });

        return true;
    }

    /// <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();

            // 데이터 존재 OR 조회완료 마커 → 스킵 (발행 없는 날도 재조회 회피, 리뷰 결함 #1)
            if (await db.BondIssuance.AsNoTracking().AnyAsync(c => c.IssuDt == day, ct) || await SeibroMarkers.IsSweptAsync(db, IssuanceJobKey, day, null, ct))
            {
                continue;
            }

            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);
            await SeibroMarkers.MarkSweptAsync(db, IssuanceJobKey, day, null, ct); // 0행 포함 조회완료 기록

            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;
        }

        // 조회 시도(0행 포함) 마커 기준 정렬 — 정보 없는 ISIN 도 재조회 회피(#1)
        var markers = await SeibroMarkers.LoadFetchMarkersAsync(db, BondStatJobKey, ct);
        var targets = universe.Select(isin => (Key: isin, LastUpdatedAt: markers.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);
                await SeibroMarkers.TouchFetchMarkerAsync(db, BondStatJobKey, isin, 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;
        }

        // 조회 시도(0행 포함) 마커 기준 정렬 — getIntPayInfo 실샘플 result=0 이라 스냅샷이 안 남아 매 실행 재조회되던 결함(#1 대표 케이스) 해소
        var markers = await SeibroMarkers.LoadFetchMarkersAsync(db, IntPayJobKey, ct);
        var targets = masterIsins.Select(isin => (Key: isin, LastUpdatedAt: markers.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);
                await SeibroMarkers.TouchFetchMarkerAsync(db, IntPayJobKey, isin, 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();

            // 데이터 존재 OR 조회완료 마커 → 스킵 (조기상환 없는 날도 재조회 회피, 리뷰 결함 #1)
            if (await db.BondEarlyRedemption.AsNoTracking().AnyAsync(c => c.ErlyRedDt == day, ct) || await SeibroMarkers.IsSweptAsync(db, EarlyRedJobKey, day, null, ct))
            {
                continue;
            }

            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);
            await SeibroMarkers.MarkSweptAsync(db, EarlyRedJobKey, day, null, ct); // 0행 포함 조회완료 기록

            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();

                // 데이터 존재 OR 조회완료 마커(축=tpcd) → 스킵 (발행 없는 (일,구분)도 재조회 회피, 리뷰 결함 #1)
                if (await db.ShortTermIssuance.AsNoTracking().AnyAsync(c => c.IssuDt == day && c.SecnTpcd == tpcd, ct) || await SeibroMarkers.IsSweptAsync(db, ShortTermJobKey, day, tpcd, ct))
                {
                    continue;
                }

                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);
                await SeibroMarkers.MarkSweptAsync(db, ShortTermJobKey, day, tpcd, ct); // 0행 포함 조회완료 기록

                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 요청값 스탬핑).
    /// ⚠️ 리뷰 결함 #1: getCD/CP/ESTBInfo 실샘플 result=0 → 마스터가 안 남아 같은 최근 ISIN 이 매 실행 재조회(starvation).
    /// 조회 시도(0행 포함) 마커로 이미 시도한 ISIN 을 후보에서 제외 → 한 번씩만 시도하고 유니버스가 순환 소진된다.
    /// </summary>
    private async Task RollShortTermMastersAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        await RollShortTermMasterAsync(db, client, cfg, "13", CdJobKey, "getCDInfo", MasterHas.Cd, "CD", ct);
        await RollShortTermMasterAsync(db, client, cfg, "12", CpJobKey, "getCPInfo", MasterHas.Cp, "CP", ct);
        await RollShortTermMasterAsync(db, client, cfg, "14", EstbJobKey, "getESTBInfo", MasterHas.Estb, "전단채", ct);
    }

    private enum MasterHas { Cd, Cp, Estb }

    /// <summary>
    /// 단기금융 마스터 rolling 공용 — SECN_TPCD 별 대상. "마스터 없음 AND 조회 시도 마커 없음" 후보를 IssuDt desc 로 컷,
    /// 조회 시도(0행 포함) 후 마커 Touch. → 0행 ISIN 이 재조회되지 않고 후순위로 밀려 나머지가 진행(#1).
    /// </summary>
    private async Task RollShortTermMasterAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, string secnTpcd, string jobKey, string operation, MasterHas masterHas, string label, CancellationToken ct)
    {
        var maxPerRun = quota.Remaining(SeibroCategory.Bond, cfg.BondBudget);
        if (maxPerRun <= 0)
        {
            return;
        }

        var checkedIsins = (await db.SeibroFetchMarker.AsNoTracking().Where(c => c.JobKey == jobKey).Select(c => c.EntityKey).ToListAsync(ct)).ToHashSet(StringComparer.Ordinal);

        // 마스터 미수집 + 최근 발행 우선. 이미 조회 시도한(마커 있는) ISIN 은 in-memory 로 제외 후 maxPerRun 컷.
        var query = db.ShortTermIssuance.AsNoTracking().Where(c => c.SecnTpcd == secnTpcd);
        query = masterHas switch
        {
            MasterHas.Cd => query.Where(c => !db.CdMaster.Any(m => m.Isin == c.Isin)),
            MasterHas.Cp => query.Where(c => !db.CpMaster.Any(m => m.Isin == c.Isin)),
            _ => query.Where(c => !db.EstbMaster.Any(m => m.Isin == c.Isin))
        };

        var ordered = await query.OrderByDescending(c => c.IssuDt).Select(c => c.Isin).ToListAsync(ct);
        var candidates = ordered.Where(c => !checkedIsins.Contains(c)).Distinct().Take(maxPerRun).ToList();

        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, operation, [new("ISIN", isin)], Logger, token);
                var ok = masterHas switch
                {
                    MasterHas.Cd => await SeibroBondImport.UpsertCdMasterAsync(db, isin, SeibroCDParser.Parse(SeibroXml.Parse(xml)), token),
                    MasterHas.Cp => await SeibroBondImport.UpsertCpMasterAsync(db, isin, SeibroCPParser.Parse(SeibroXml.Parse(xml)), token),
                    _ => await SeibroBondImport.UpsertEstbMasterAsync(db, isin, SeibroESTBParser.Parse(SeibroXml.Parse(xml)), token)
                };
                await SeibroMarkers.TouchFetchMarkerAsync(db, jobKey, isin, token); // 0행 포함 조회 시도 기록 → 재조회 회피

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

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