ANTOOZA-BACKEND/Infrastructure/StockData/SeibroSupplySyncService.cs

using Application.Abstractions.Data;
using Application.Helpers;
using Domain.Entities.Stocks.ValueObject;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.Extensions.Options;
using SharedKernel;

namespace Infrastructure.StockData;

/// <summary>
/// SEIBro 수급 이벤트 수집 (Wave 2 ★P1) — 기본 07:00 KST(IssuerSync 06:30·Dividend 06:40 다음 슬롯), `Seibro:SupplySync` 게이트.
/// 다섯 단계가 하나의 주식(Stock) 카테고리 예산(SeibroQuota, Seibro:StockBudget)을 공유한다.
///
/// a) SecuritiesLending (getSlbDealingByIsin, per-ISIN×일): 당일(최신 영업일) 전 상장종목 대차를 최우선 배분(~2,700콜).
///    잔여 예산으로만 3년 백필 = 시총상위 LendingBackfillTopN + 커뮤니티 활성종목(StockBoardStats.Posts>0) 대상 과거 날짜 rolling.
/// b) LockupEvent 예수 (getSafeDpDutyDepoStatus BIZ_TPCD:1, 월 윈도우 스윕): BEGIN_DT~EXPRY_DT(≤1개월) → 예수일(SafedpDt) window delete+insert.
///    ⚠️ 범위(BEGIN_DT+EXPRY_DT)와 BIZ_TPCD 둘 다 필수 — 단일일이거나 BIZ_TPCD 누락 시 SEIBro 가 003(서버오류) 반환(2026-07-10 라이브 확인). getStkListInfo 와 동일 월 윈도우 패턴.
///    반환(BIZ_TPCD:2, OCCR_SEQ=2)은 현재 미수집 — LockupEvent UQ 에 반환일이 없어 다중 부분반환이 UQ 충돌. 저장하려면 스키마 변경(키에 반환일) 필요(후속).
/// c) StockIssuanceChange (getStkIncdecDetails, rolling per-회사번호): Stock.IssucoCustno non-null 중 미수집·stale 우선.
/// d) ListingChangeEvent (getStkListInfo, 월 윈도우 스윕): ALT_BEGIN_DT~ALT_EXPRY_DT 최대 1개월/콜 3년 → 적용일 window delete+insert.
/// e) UnlistedCirculation (getUnlistCirclInfo, 날짜 스윕): STD_DT 만 필수 = 그날 전체 비상장 유통 종목 반환(per-종목 불필요) → 전 캘린더일 스윕, StdDt 스탬핑.
///
/// 실패/0행 = 정상 빈결과. HTTP·파싱 오류 = 경고 + false(RetryDelay 후 재시도). quota 소진 = 정상 종료(true). ApiKey 미설정 시 skip.
/// ⚠️ 콜 수가 큼(대차 전종목 ~2,700/일) — 당일 대차를 최우선 배분하고, 백필류(대차 과거·보호예수·증감·유통변경·비상장)는 잔여 예산으로만 진행한다.
/// </summary>
internal sealed class SeibroSupplySyncService(
    IServiceScopeFactory scopeFactory,
    IHttpClientFactory httpClientFactory,
    SeibroQuota quota,
    IOptions<AppSettings> settings,
    ILogger<SeibroSupplySyncService> logger
) : DailyScheduledService(logger)
{
    private static readonly StockMarket[] LendingMarkets = [StockMarket.KOSPI, StockMarket.KOSDAQ, StockMarket.KONEX];

    // 마커 job 키 (리뷰 결함 #1) — 조용한 날/정상 0행 재조회·starvation 해소
    private const string LockupJobKey = "supply-lockup";       // month-window sweep, 예수(BIZ_TPCD:1)/SafedpDt 축 (SweptDate, Date=windowBegin)
    private const string ListingJobKey = "supply-listing";     // date-sweep, 월 윈도우 (SweptDate, Date=windowBegin)
    private const string UnlistedJobKey = "supply-unlisted";   // date-sweep (SweptDate)
    private const string IncdecJobKey = "stk-incdec";           // rolling (FetchMarker)

    protected override string JobName => "SeibroSupplySync";

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

    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.SeibroSupply, 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 대차/수급은 T+1 — 당일(todayKst)은 아직 미반영이라 직전 영업일을 "최신 데이터일"로 사용
        var latestBizDay = await MarketCalendar.GetPreviousBusinessDayAsync(db, todayKst, ct);

        // 단계별 독립 실행 — 한 단계의 SEIBro 오류(예: getSafeDpDutyDepoStatus 003)가 다른 단계를 막지 않도록 개별 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 => SweepTodayLendingAsync(db, client, cfg, latestBizDay, t))) { return true; }
        if (!await Phase("보호예수", t => SweepLockupAsync(db, client, cfg, startDate, latestBizDay, t))) { return true; }
        if (!await Phase("증감내역", t => RollIssuanceChangesAsync(db, client, cfg, t))) { return true; }
        if (!await Phase("유통형태변경", t => SweepListingChangesAsync(db, client, cfg, startDate, latestBizDay, t))) { return true; }
        if (!await Phase("비상장유통", t => SweepUnlistedAsync(db, client, cfg, startDate, latestBizDay, t))) { return true; }

        // f) 대차 3년 백필 (void 반환) — 개별 try/catch
        await Phase("대차백필", async t => { await BackfillLendingAsync(db, client, cfg, startDate, latestBizDay, t); return true; });

        return true;
    }

    /// <summary>a) 당일 대차 — 전 상장종목(KOSPI/KOSDAQ/KONEX, ISIN 있음) 중 당일 미적재. 예산 소진 시 false.</summary>
    private async Task<bool> SweepTodayLendingAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, DateOnly day, CancellationToken ct)
    {
        var existing = await db.SecuritiesLending.AsNoTracking().Where(c => c.StdDt == day).Select(c => c.Isin).ToListAsync(ct);
        var have = existing.ToHashSet();

        var isins = await db.Stock.AsNoTracking()
            .Where(c => c.IsActive && c.ISIN != null && LendingMarkets.Contains(c.Market))
            .OrderByDescending(c => c.MarketCap)
            .Select(c => c.ISIN!)
            .ToListAsync(ct);

        var targets = isins.Where(c => !have.Contains(c)).ToList();
        var quotaExhausted = false;
        var fetched = 0;

        foreach (var isin in targets)
        {
            ct.ThrowIfCancellationRequested();

            if (!quota.TryConsume(SeibroCategory.Stock, 1, cfg.StockBudget))
            {
                quotaExhausted = true;
                break;
            }

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

            await FetchLendingAsync(db, client, cfg, isin, day, ct);
            fetched++;
        }

        Logger.LogInformation("[{Job}] 당일 대차 스윕 — 기준일={Day}, 대상={Targets}, 수집={Fetched}", JobName, day, targets.Count, fetched);
        return !quotaExhausted;
    }

    /// <summary>대차 1콜 수집 후 upsert (Isin+StdDt 스탬핑).</summary>
    private async Task FetchLendingAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, string isin, DateOnly day, CancellationToken ct)
    {
        var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getSlbDealingByIsin", [new("ISIN", isin), new("STD_DT", day.ToString("yyyyMMdd"))], Logger, ct);
        var rows = SeibroSlbDealingParser.Parse(SeibroXml.Parse(xml));
        await SeibroSupplyImport.UpsertLendingAsync(db, isin, day, rows, ct);
    }

    /// <summary>f) 대차 3년 백필 — 시총상위 TopN + 활성종목(StockBoardStats.Posts>0). 종목별 미적재 과거 영업일 recent-first, 잔여 예산.</summary>
    private async Task BackfillLendingAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, DateOnly startDate, DateOnly latestBizDay, CancellationToken ct)
    {
        var remaining = quota.Remaining(SeibroCategory.Stock, cfg.StockBudget);
        if (remaining <= 0)
        {
            Logger.LogInformation("[{Job}] 대차 백필 skip — 당일 수집으로 주식 예산({Budget}) 소진", JobName, cfg.StockBudget);
            return;
        }

        var topN = cfg.LendingBackfillTopN > 0 ? cfg.LendingBackfillTopN : 300;

        var topIsins = await db.Stock.AsNoTracking()
            .Where(c => c.IsActive && c.ISIN != null && LendingMarkets.Contains(c.Market))
            .OrderByDescending(c => c.MarketCap)
            .Take(topN)
            .Select(c => c.ISIN!)
            .ToListAsync(ct);

        var activeCodes = await db.StockBoardStats.AsNoTracking().Where(c => c.Posts > 0).Select(c => c.StockCode).ToListAsync(ct);
        var activeIsins = await db.Stock.AsNoTracking()
            .Where(c => c.IsActive && c.ISIN != null && LendingMarkets.Contains(c.Market) && activeCodes.Contains(c.Code))
            .Select(c => c.ISIN!)
            .ToListAsync(ct);

        var universe = topIsins.Concat(activeIsins).Distinct().ToList();
        if (universe.Count == 0)
        {
            return;
        }

        // 백필 창(주말/휴장 제외)의 휴장일 로드
        var holidays = (await db.MarketHoliday.AsNoTracking().Where(c => c.Date >= startDate && c.Date <= latestBizDay).Select(c => c.Date).ToListAsync(ct)).ToHashSet();
        var fetched = 0;

        // 종목을 순회하며 각 종목의 미적재 과거일을 recent-first 로 채운다. 예산 소진 시 즉시 종료.
        foreach (var isin in universe)
        {
            ct.ThrowIfCancellationRequested();

            var have = (await db.SecuritiesLending.AsNoTracking().Where(c => c.Isin == isin && c.StdDt >= startDate && c.StdDt <= latestBizDay).Select(c => c.StdDt).ToListAsync(ct)).ToHashSet();

            for (var day = latestBizDay; day >= startDate; day = day.AddDays(-1))
            {
                if (day.DayOfWeek is DayOfWeek.Saturday or DayOfWeek.Sunday || holidays.Contains(day) || have.Contains(day))
                {
                    continue;
                }

                if (!quota.TryConsume(SeibroCategory.Stock, 1, cfg.StockBudget))
                {
                    Logger.LogInformation("[{Job}] 대차 백필 종료 — 주식 예산 소진 (백필 수집={Fetched})", JobName, fetched);
                    return;
                }

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

                await FetchLendingAsync(db, client, cfg, isin, day, ct);
                fetched++;
            }
        }

        Logger.LogInformation("[{Job}] 대차 백필 완료 — 대상종목={Universe}, 수집={Fetched}", JobName, universe.Count, fetched);
    }

    /// <summary>b) 보호예수 월 윈도우 스윕(최신→과거, 최대 1개월/콜) — 미적재 월만. BEGIN_DT~EXPRY_DT 범위 + BIZ_TPCD:1(예수) 필수(단일일·무BIZ 는 SEIBro 003). 예수일 window delete+insert. 예산 소진 시 false.</summary>
    private async Task<bool> SweepLockupAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, DateOnly startDate, DateOnly today, CancellationToken ct)
    {
        var fetched = 0;
        var first = true;

        // 월 단위 창: [monthStart, monthEnd] 최대 1개월. 최신 달부터 과거로. getSafeDpDutyDepoStatus 는 범위+BIZ_TPCD 필수(단일일/무BIZ = 003).
        var windowEnd = today;

        while (windowEnd >= startDate)
        {
            ct.ThrowIfCancellationRequested();

            var monthStart = new DateOnly(windowEnd.Year, windowEnd.Month, 1);
            var windowBegin = monthStart < startDate ? startDate : monthStart;

            // 당월(현재 진행 중 달)은 아직 예수가 추가될 수 있어 매 실행 재수집(월중 신규 누락 방지, 리뷰 finding#2). 과거 달만 데이터 존재/마커로 스킵.
            var isCurrentMonth = monthStart.Year == today.Year && monthStart.Month == today.Month;
            var alreadyDone = !isCurrentMonth
                && (await db.LockupEvent.AsNoTracking().AnyAsync(c => c.SafedpDt >= windowBegin && c.SafedpDt <= windowEnd, ct)
                    || await SeibroMarkers.IsSweptAsync(db, LockupJobKey, windowBegin, null, ct));

            if (!alreadyDone)
            {
                if (!quota.TryConsume(SeibroCategory.Stock, 1, cfg.StockBudget))
                {
                    Logger.LogWarning("[{Job}] 주식 예산({Budget}) 소진 — getSafeDpDutyDepoStatus {Begin}~{End} 부터 중단", JobName, cfg.StockBudget, windowBegin, windowEnd);
                    return false;
                }

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

                first = false;

                // getSafeDpDutyDepoStatus 는 정상 파라미터에도 간헐적 003(서버측)을 반환 — 해당 월만 skip(마커 미기록 → 다음 실행 재시도)하고
                // 나머지 과거 월은 계속 진행한다(한 달 transient 오류가 전체 백필을 막지 않도록, SeibroRollingSweep per-key 철학과 동일).
                try
                {
                    var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getSafeDpDutyDepoStatus", [new("BEGIN_DT", windowBegin.ToString("yyyyMMdd")), new("EXPRY_DT", windowEnd.ToString("yyyyMMdd")), new("BIZ_TPCD", "1")], Logger, ct);
                    var rows = SeibroLockupParser.Parse(SeibroXml.Parse(xml));
                    var (inserted, deleted) = await SeibroSupplyImport.ReplaceLockupWindowAsync(db, windowBegin, windowEnd, rows, ct);
                    await SeibroMarkers.MarkSweptAsync(db, LockupJobKey, windowBegin, null, ct); // 0행 포함 조회완료 기록

                    Logger.LogInformation("[{Job}] getSafeDpDutyDepoStatus {Begin}~{End} rows={Rows} — inserted={Inserted}, deleted={Deleted}", JobName, windowBegin, windowEnd, rows.Count, inserted, deleted);
                    fetched++;
                }
                catch (Exception ex) when (ex is HttpRequestException or System.Xml.XmlException or FormatException)
                {
                    Logger.LogWarning(ex, "[{Job}] getSafeDpDutyDepoStatus {Begin}~{End} SEIBro 오류(간헐 003 등) — 이 달만 skip(다음 실행 재시도)", JobName, windowBegin, windowEnd);
                }
            }

            windowEnd = monthStart.AddDays(-1); // 이전 달 말일
        }

        Logger.LogInformation("[{Job}] 보호예수 월 윈도우 스윕 완료 — 창=[{Start}~{End}], fetch={Fetched}월", JobName, startDate, today, fetched);
        return true;
    }

    /// <summary>c) 증감내역 rolling — Stock.IssucoCustno non-null 중 미수집·stale 우선. SHOTN_ISIN(=Code)으로 조회. 예산 소진 시 false.</summary>
    private async Task<bool> RollIssuanceChangesAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        var stocks = await db.Stock.AsNoTracking().Where(c => c.IssucoCustno != null && c.ISIN != null).Select(c => new { c.Code, c.ISIN }).ToListAsync(ct);

        if (stocks.Count == 0)
        {
            Logger.LogInformation("[{Job}] getStkIncdecDetails 대상 없음 (Stock.IssucoCustno 미스탬핑)", JobName);
            return true;
        }

        // 조회 시도(0행 포함) 마커 기준 정렬(키=단축코드) — 증감 없는 종목도 재조회 회피(#1)
        var markers = await SeibroMarkers.LoadFetchMarkersAsync(db, IncdecJobKey, ct);
        var targets = stocks.Select(s => (Key: s.Code, LastUpdatedAt: markers.TryGetValue(s.Code, out var last) ? (DateTime?)last : null)).ToList();
        var maxPerRun = quota.Remaining(SeibroCategory.Stock, cfg.StockBudget);
        var quotaExhausted = false;

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

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getStkIncdecDetails", [new("SHOTN_ISIN", code)], Logger, token);
                var rows = SeibroStkIncdecParser.Parse(SeibroXml.Parse(xml));
                var (inserted, updated) = await SeibroSupplyImport.UpsertIssuanceChangesAsync(db, rows, token);
                await SeibroMarkers.TouchFetchMarkerAsync(db, IncdecJobKey, code, token);

                Logger.LogInformation("[{Job}] getStkIncdecDetails SHOTN_ISIN={Code} rows={Rows} — inserted={Inserted}, updated={Updated}", JobName, code, rows.Count, inserted, updated);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

        Logger.LogInformation("[{Job}] getStkIncdecDetails rolling 완료 — 대상={Targets}, 호출={Processed} (maxPerRun={Max})", JobName, targets.Count, processed, maxPerRun);
        return !quotaExhausted;
    }

    /// <summary>d) 유통형태변경 월 윈도우 스윕(최신→과거, 최대 1개월/콜) — 미적재 월만. 적용일 window delete+insert. 예산 소진 시 false.</summary>
    private async Task<bool> SweepListingChangesAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, DateOnly startDate, DateOnly today, CancellationToken ct)
    {
        var fetched = 0;
        var first = true;

        // 월 단위 창: [monthStart, monthEnd] 최대 1개월. 최신 달부터 과거로.
        var windowEnd = today;

        while (windowEnd >= startDate)
        {
            ct.ThrowIfCancellationRequested();

            var monthStart = new DateOnly(windowEnd.Year, windowEnd.Month, 1);
            var windowBegin = monthStart < startDate ? startDate : monthStart;

            // 월 윈도우 시작일을 마커 Date 로 사용 — 데이터 존재 OR 조회완료 마커 → 스킵 (변경 없는 달도 재조회 회피, 리뷰 결함 #1)
            if (!await db.ListingChangeEvent.AsNoTracking().AnyAsync(c => c.ApliDt >= windowBegin && c.ApliDt <= windowEnd, ct) && !await SeibroMarkers.IsSweptAsync(db, ListingJobKey, windowBegin, null, ct))
            {
                if (!quota.TryConsume(SeibroCategory.Stock, 1, cfg.StockBudget))
                {
                    Logger.LogWarning("[{Job}] 주식 예산({Budget}) 소진 — getStkListInfo {Begin}~{End} 부터 중단", JobName, cfg.StockBudget, windowBegin, windowEnd);
                    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, "getStkListInfo", [new("ALT_BEGIN_DT", windowBegin.ToString("yyyyMMdd")), new("ALT_EXPRY_DT", windowEnd.ToString("yyyyMMdd"))], Logger, ct);
                var rows = SeibroStkListParser.Parse(SeibroXml.Parse(xml));
                var (inserted, deleted) = await SeibroSupplyImport.ReplaceListingChangeWindowAsync(db, windowBegin, windowEnd, rows, ct);
                await SeibroMarkers.MarkSweptAsync(db, ListingJobKey, windowBegin, null, ct); // 0행 포함 조회완료 기록

                Logger.LogInformation("[{Job}] getStkListInfo {Begin}~{End} rows={Rows} — inserted={Inserted}, deleted={Deleted}", JobName, windowBegin, windowEnd, rows.Count, inserted, deleted);
                fetched++;
            }

            windowEnd = monthStart.AddDays(-1); // 이전 달 말일
        }

        Logger.LogInformation("[{Job}] 유통형태변경 월 윈도우 스윕 완료 — 창=[{Start}~{End}], fetch={Fetched}월", JobName, startDate, today, fetched);
        return true;
    }

    /// <summary>e) 비상장 유통 전 캘린더일 스윕(최신→과거) — STD_DT 만으로 그날 전체 종목 반환. 미적재일만. 예산 소진 시 false.</summary>
    private async Task<bool> SweepUnlistedAsync(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.UnlistedCirculation.AsNoTracking().AnyAsync(c => c.StdDt == day, ct) || await SeibroMarkers.IsSweptAsync(db, UnlistedJobKey, day, null, ct))
            {
                continue;
            }

            if (!quota.TryConsume(SeibroCategory.Stock, 1, cfg.StockBudget))
            {
                Logger.LogWarning("[{Job}] 주식 예산({Budget}) 소진 — getUnlistCirclInfo {Day} 부터 중단", JobName, cfg.StockBudget, 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, "getUnlistCirclInfo", [new("STD_DT", day.ToString("yyyyMMdd"))], Logger, ct);
            var rows = SeibroUnlistCirclParser.Parse(SeibroXml.Parse(xml));
            var (inserted, updated) = await SeibroSupplyImport.UpsertUnlistedAsync(db, day, rows, ct);
            await SeibroMarkers.MarkSweptAsync(db, UnlistedJobKey, day, null, ct); // 0행 포함 조회완료 기록

            Logger.LogInformation("[{Job}] getUnlistCirclInfo {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;
    }
}