ANTOOZA-BACKEND/Infrastructure/StockData/SeibroDividendSyncService.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 1 ★P0) — 기본 06:40 KST(IssuerSync 06:30 다음 슬롯), `Seibro:DividendSync` 게이트.
/// 세 단계가 하나의 기업(Corp) 카테고리 예산(SeibroQuota, Seibro:CorpBudget)을 공유한다.
///
/// a) DividendSchedule 날짜 스윕: getDivSchedulInfo(BEGIN_STD_DT=day, EXPRY 생략 → 그날만, custno 미지정 → 전체 회사).
///    3년 창을 최신일→과거로 훑으며 미적재일만 수집한다.
///    ⚠️ 날짜 스윕에 KrxBackfill(영업일·휴장 스킵)을 쓰지 않는다 — 배당 권리기준일 상당수가 분기말/연말(0331·0630·0930·1231)이며
///    이 날짜가 토·일(예: 20161231 토, 20180331 토, 20180630 토)인 경우가 실제 샘플에 존재한다. 영업일만 훑으면 이런 기준일을 통째로 놓친다.
///    → 주말·휴장 포함 전 캘린더일을 훑는다(3년 ≈ 1,095콜, Corp 예산 40,000 내 충분).
/// b) Dividend rolling: 대상 = DividendSchedule 에 등장한 DISTINCT IssucoCustno 중 Dividend 미수집(우선)·stale 순.
///    getDivInfo(ISSUCO_CUSTNO, BEGIN_STD_DT=3년전, EXPRY_STD_DT=오늘) 1콜 → 여러 배당 반환 → Dividend upsert(Isin+RgtStdDt).
///    getDivInfo 응답엔 ISSUCO_CUSTNO 가 없으므로(샘플 확인) Isin 으로만 upsert 한다.
/// c) RightsBaseDate rolling: 대상 = Stock.IssucoCustno non-null 중 RightsBaseDate 미수집(우선)·stale 순.
///    getStddtInfo(ISSUCO_CUSTNO, BEGIN_STD_DT=3년전, EXPRY_STD_DT=오늘) → RightsBaseDate upsert.
///
/// 실패/0행 = 정상 빈결과(다음 실행 재시도). HTTP·파싱 오류 = 경고 + false(RetryDelay 후 재시도).
/// quota 소진 = 정상 종료(true) — 일일 예산은 KST 자정 롤오버로만 회복. ApiKey 미설정 시 로그만 남기고 skip.
/// </summary>
internal sealed class SeibroDividendSyncService(
    IServiceScopeFactory scopeFactory,
    IHttpClientFactory httpClientFactory,
    SeibroQuota quota,
    IOptions<AppSettings> settings,
    ILogger<SeibroDividendSyncService> logger
) : DailyScheduledService(logger)
{
    // 마커 job 키 (리뷰 결함 #1) — 정상 0행/조용한 날 재조회·starvation 해소
    private const string ScheduleJobKey = "div-schedule";   // date-sweep (SweptDate)
    private const string DivInfoJobKey = "div-info";         // rolling (FetchMarker)
    private const string RightsJobKey = "rights-basedate";   // rolling (FetchMarker)

    protected override string JobName => "SeibroDividendSync";

    protected override TimeOnly TargetTime => ParseTime(settings.Value.Seibro.DividendSyncTime, new TimeOnly(6, 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.SeibroDividend, ct))
        {
            return true;
        }
        cfg = cfg with { ApiKey = await collectorSettings.GetKeyAsync(CollectorKey.Seibro, ct) ?? cfg.ApiKey };
        var db = scope.ServiceProvider.GetRequiredService<IAppDbContext>();
        if (string.IsNullOrWhiteSpace(cfg.ApiKey))
        {
            Logger.LogWarning("[{Job}] Seibro:ApiKey 미설정 — 수집 skip", JobName);
            return true;
        }

        var client = httpClientFactory.CreateClient(SeibroHttp.ClientName);

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

        try
        {
            if (!await SweepSchedulesAsync(db, client, cfg, startDate, todayKst, ct))
            {
                return true; // quota 소진 — 오늘은 더 진행 불가 (정상 종료)
            }

            if (!await RollDividendsAsync(db, client, cfg, startDate, todayKst, ct))
            {
                return true;
            }

            await RollRightsBaseDatesAsync(db, client, cfg, startDate, todayKst, 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) getDivSchedulInfo 날짜 스윕 (전 캘린더일, 최신일→과거) — 미적재일만 수집. quota 소진 시 false.</summary>
    private async Task<bool> SweepSchedulesAsync(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 조회완료 마커 존재 → 스킵 (0행 배당일도 마커로 재조회 회피, 리뷰 결함 #1)
            if (await db.DividendSchedule.AsNoTracking().AnyAsync(c => c.RgtStdDt == day, ct) || await SeibroMarkers.IsSweptAsync(db, ScheduleJobKey, day, null, ct))
            {
                continue;
            }

            if (!quota.TryConsume(SeibroCategory.Corp, 1, cfg.CorpBudget))
            {
                Logger.LogWarning("[{Job}] 기업 카테고리 일일 예산({Budget}) 소진 — getDivSchedulInfo {Day} 부터 중단", JobName, cfg.CorpBudget, day);
                return false;
            }

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

            first = false;

            try
            {
                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getDivSchedulInfo", [new("BEGIN_STD_DT", day.ToString("yyyyMMdd"))], Logger, ct);
                var rows = SeibroDivSchedulParser.Parse(SeibroXml.Parse(xml));
                var (inserted, updated) = await SeibroDividendImport.UpsertSchedulesAsync(db, rows, ct);
                await SeibroMarkers.MarkSweptAsync(db, ScheduleJobKey, day, null, ct); // 0행 포함 조회완료 기록

                Logger.LogInformation("[{Job}] getDivSchedulInfo {Day} rows={Rows} — inserted={Inserted}, updated={Updated}", JobName, day, rows.Count, inserted, updated);
                fetched++;
            }
            catch (Exception ex) when (ex is not OperationCanceledException)
            {
                // soft-error 응답 등 단일 날짜 실패는 미마킹 후 skip → 다음 실행 재시도 (run 전체 중단 방지)
                Logger.LogWarning(ex, "[{Job}] getDivSchedulInfo {Day} 실패 — skip(다음 실행 재시도)", JobName, day);
            }
        }

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

    /// <summary>b) getDivInfo rolling — DividendSchedule 에 등장한 회사번호 중 미수집·stale 우선. quota 잔여분 내. 예산 소진 시 false.</summary>
    private async Task<bool> RollDividendsAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, DateOnly startDate, DateOnly today, CancellationToken ct)
    {
        var scheduleCustnos = await db.DividendSchedule.AsNoTracking().Select(c => c.IssucoCustno).Distinct().ToListAsync(ct);

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

        // 회사번호 → 조회 시도(0행 포함) 마커 시각 (미조회면 null → 최우선). 무배당 회사도 Dividend 행이 안 남아 매 실행 재조회되던 결함(#1) 해소.
        var markers = await SeibroMarkers.LoadFetchMarkersAsync(db, DivInfoJobKey, ct);
        var targets = scheduleCustnos.Select(custno => (Key: custno, LastUpdatedAt: markers.TryGetValue(custno.ToString(), out var last) ? (DateTime?)last : null)).ToList();

        var maxPerRun = quota.Remaining(SeibroCategory.Corp, cfg.CorpBudget);
        var beginStr = startDate.ToString("yyyyMMdd");
        var expiryStr = today.ToString("yyyyMMdd");
        var quotaExhausted = false;

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

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getDivInfo", [new("ISSUCO_CUSTNO", custno.ToString()), new("BEGIN_STD_DT", beginStr), new("EXPRY_STD_DT", expiryStr)], Logger, token);
                var rows = SeibroDivInfoParser.Parse(SeibroXml.Parse(xml));
                var (inserted, updated) = await SeibroDividendImport.UpsertDividendsAsync(db, rows, token);
                await SeibroMarkers.TouchFetchMarkerAsync(db, DivInfoJobKey, custno.ToString(), token); // 0행(무배당) 포함 조회시각 스탬핑

                Logger.LogInformation("[{Job}] getDivInfo ISSUCO_CUSTNO={Custno} rows={Rows} — inserted={Inserted}, updated={Updated}", JobName, custno, rows.Count, inserted, updated);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

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

    /// <summary>c) getStddtInfo rolling — Stock.IssucoCustno non-null 중 미수집·stale 우선. quota 잔여분 내.</summary>
    private async Task RollRightsBaseDatesAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, DateOnly startDate, DateOnly today, CancellationToken ct)
    {
        var custnos = await db.Stock.AsNoTracking().Where(c => c.IssucoCustno != null).Select(c => c.IssucoCustno!.Value).Distinct().ToListAsync(ct);

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

        // 조회 시도(0행 포함) 마커 기준 정렬 — 권리 없는 회사도 재조회 회피(#1)
        var markers = await SeibroMarkers.LoadFetchMarkersAsync(db, RightsJobKey, ct);
        var targets = custnos.Select(custno => (Key: custno, LastUpdatedAt: markers.TryGetValue(custno.ToString(), out var last) ? (DateTime?)last : null)).ToList();

        var maxPerRun = quota.Remaining(SeibroCategory.Corp, cfg.CorpBudget);
        var beginStr = startDate.ToString("yyyyMMdd");
        var expiryStr = today.ToString("yyyyMMdd");

        var processed = await SeibroRollingSweep.RunAsync(
            targets: targets,
            fetchAndUpsert: async (custno, token) => {
                if (!quota.TryConsume(SeibroCategory.Corp, 1, cfg.CorpBudget))
                {
                    return;
                }

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getStddtInfo", [new("ISSUCO_CUSTNO", custno.ToString()), new("BEGIN_STD_DT", beginStr), new("EXPRY_STD_DT", expiryStr)], Logger, token);
                var rows = SeibroStddtParser.Parse(SeibroXml.Parse(xml));
                var (inserted, updated) = await SeibroDividendImport.UpsertRightsBaseDatesAsync(db, rows, token);
                await SeibroMarkers.TouchFetchMarkerAsync(db, RightsJobKey, custno.ToString(), token);

                Logger.LogInformation("[{Job}] getStddtInfo ISSUCO_CUSTNO={Custno} rows={Rows} — inserted={Inserted}, updated={Updated}", JobName, custno, rows.Count, inserted, updated);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

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