ANTOOZA-BACKEND/Infrastructure/StockData/KrxDerivativeSyncService.cs

using Application.Abstractions.Data;
using Application.Helpers;
using Domain.Entities.Stocks;
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>
/// 파생상품(선물 3 + 옵션 3) 일별매매 수집 (KRX OpenAPI drv) — fut/eqsfu/eqkfu_bydd_trd + opt/eqsop/eqkop_bydd_trd.
/// 기본 19:00 KST 실행(장 마감 15:30 이후 확정, 채권 수집 18:40 이 3ep×백필로 5분 슬롯을 넘을 수 있어 여유). 공용 KrxBackfill 로 최근 BackfillYears(기본 3)년치를
/// endDate(직전 영업일)부터 과거로 훑으며 미적재일만 채운다. quota 보호를 위해 1회 실행당 BackfillMaxPerRun(기본 60)일까지만 fetch.
/// 각 날짜는 선물 3개 + 옵션 3개 엔드포인트를 모두 수집해 FuturesDailyTrade / OptionsDailyTrade 두 테이블에 각각 upsert
/// (선물 UQ = FuturesKind+IsuCode+TradeDate+Session, 옵션 UQ = OptionsKind+IsuCode+TradeDate+Session).
/// 일반선물/일반옵션은 동일 ISU_CD 로 정규·야간 세션 행이 각각 오므로 Session 을 upsert 키에 포함해 둘 다 저장한다.
/// existsForDate 는 6개 상품군(FuturesKind 3 + OptionsKind 3)이 유형별 데이터 시작일 기준으로 전부 적재됐을 때만 skip
/// (일부 상품군만 성공한 부분 적재 날짜는 재수집 — 영구 결손 방지). ApiKey 미설정 시 로그만 남기고 skip.
/// </summary>
internal sealed class KrxDerivativeSyncService(
    IServiceScopeFactory scopeFactory,
    IHttpClientFactory httpClientFactory,
    IOptions<AppSettings> settings,
    ILogger<KrxDerivativeSyncService> logger
) : DailyScheduledService(logger)
{
    // (상품군, 엔드포인트 경로) — 선물: 일반/주식유가/주식코스닥
    private static readonly (FuturesKind Kind, string Path)[] FuturesEndpoints =
    [
        (FuturesKind.General, "/svc/apis/drv/fut_bydd_trd"),
        (FuturesKind.StockKospi, "/svc/apis/drv/eqsfu_stk_bydd_trd"),
        (FuturesKind.StockKosdaq, "/svc/apis/drv/eqkfu_ksq_bydd_trd")
    ];

    // (상품군, 엔드포인트 경로) — 옵션: 일반/주식유가/주식코스닥
    private static readonly (OptionsKind Kind, string Path)[] OptionsEndpoints =
    [
        (OptionsKind.General, "/svc/apis/drv/opt_bydd_trd"),
        (OptionsKind.StockKospi, "/svc/apis/drv/eqsop_bydd_trd"),
        (OptionsKind.StockKosdaq, "/svc/apis/drv/eqkop_bydd_trd")
    ];

    // 상품군별 데이터 시작일 (docs/KRX/readme.md) — 시작일 이전 날짜는 해당 상품군 미존재가 정상이라 완전성 판정에서 제외
    private static readonly (FuturesKind Kind, DateOnly DataStartDate)[] FuturesKindStartDates =
    [
        (FuturesKind.General, new DateOnly(2010, 1, 4)),
        (FuturesKind.StockKospi, new DateOnly(2010, 1, 4)),
        (FuturesKind.StockKosdaq, new DateOnly(2015, 8, 3))
    ];

    private static readonly (OptionsKind Kind, DateOnly DataStartDate)[] OptionsKindStartDates =
    [
        (OptionsKind.General, new DateOnly(2010, 1, 4)),
        (OptionsKind.StockKospi, new DateOnly(2010, 1, 4)),
        (OptionsKind.StockKosdaq, new DateOnly(2017, 6, 26))
    ];

    protected override string JobName => "KrxDerivativeSync";

    protected override TimeOnly TargetTime => ParseTime(settings.Value.KRXCoKr.DerivativeSyncTime, new TimeOnly(19, 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.KRXCoKr;

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

        var db = scope.ServiceProvider.GetRequiredService<IAppDbContext>();
        var client = httpClientFactory.CreateClient(KrxCoKrHttp.ClientName);

        var endDate = await MarketCalendar.GetPreviousBusinessDayAsync(db, todayKst.AddDays(1), ct);
        var years = cfg.BackfillYears > 0 ? cfg.BackfillYears : 3;
        var startDate = todayKst.AddYears(-years);

        // 백필 창 전체의 휴장일을 한 번에 로드 (KrxBackfill 은 주말은 자동 제외, 휴장일만 필요)
        var holidays = (await db.MarketHoliday.AsNoTracking()
            .Where(c => c.Date >= startDate && c.Date <= endDate)
            .Select(c => c.Date)
            .ToListAsync(ct)).ToHashSet();

        var maxPerRun = cfg.BackfillMaxPerRun > 0 ? cfg.BackfillMaxPerRun : 60;

        // 상품군(6종)별 완전성 판정 — 일부 엔드포인트만 성공한 부분 적재 날짜는 skip 하지 않고 재수집한다
        async Task<bool> ExistsForDateAsync(DateOnly day, CancellationToken token)
        {
            var futuresKinds = await db.FuturesDailyTrade.AsNoTracking().Where(c => c.TradeDate == day).Select(c => c.FuturesKind).Distinct().ToListAsync(token);
            if (!BackfillCompleteness.IsComplete(futuresKinds, FuturesKindStartDates, day))
            {
                return false;
            }

            var optionsKinds = await db.OptionsDailyTrade.AsNoTracking().Where(c => c.TradeDate == day).Select(c => c.OptionsKind).Distinct().ToListAsync(token);
            return BackfillCompleteness.IsComplete(optionsKinds, OptionsKindStartDates, day);
        }

        var fetched = await KrxBackfill.RunAsync(
            existsForDate: ExistsForDateAsync,
            fetchAndUpsertForDate: (day, token) => FetchAndUpsertAsync(db, client, cfg.BaseUrl, cfg.ApiKey, day, token),
            startDate: startDate,
            endDate: endDate,
            holidays: holidays,
            maxPerRun: maxPerRun,
            delayMs: 300,
            ct: ct);

        Logger.LogInformation("[{Job}] 완료 — 창=[{Start}~{End}], 이번 실행 fetch={Fetched}일 (maxPerRun={Max})",
            JobName, startDate, endDate, fetched, maxPerRun);

        // 최신 영업일(endDate) 데이터가 이번 실행에서도 미적재면 false → 베이스가 RetryDelay 후 재시도 (KRX T+0 마감 데이터 미반영 대비)
        if (!await ExistsForDateAsync(endDate, ct))
        {
            Logger.LogWarning("[{Job}] 최신 영업일 {End} 데이터 미적재 — {Delay} 후 재시도 (최대 {Max}회)", JobName, endDate, RetryDelay, MaxRetryCount);
            return false;
        }

        return true;
    }

    /// <summary>한 날짜에 대해 선물 3개 + 옵션 3개 엔드포인트를 모두 수집하고 두 테이블에 각각 upsert.</summary>
    private async Task FetchAndUpsertAsync(IAppDbContext db, HttpClient client, string baseUrl, string apiKey, DateOnly day, CancellationToken ct)
    {
        await FetchAndUpsertFuturesAsync(db, client, baseUrl, apiKey, day, ct);
        await FetchAndUpsertOptionsAsync(db, client, baseUrl, apiKey, day, ct);
    }

    private async Task FetchAndUpsertFuturesAsync(IAppDbContext db, HttpClient client, string baseUrl, string apiKey, DateOnly day, CancellationToken ct)
    {
        var rows = new List<KrxFuturesParser.FuturesRow>();

        foreach (var (kind, path) in FuturesEndpoints)
        {
            var url = $"{baseUrl.TrimEnd('/')}{path}?basDd={day:yyyyMMdd}";
            var json = await KrxCoKrHttp.GetStringWithRetryAsync(client, url, apiKey, Logger, ct);
            var parsed = KrxFuturesParser.ParseDaily(json, kind);

            Logger.LogInformation("[{Job}] 선물 {Kind} basDd={Day} rows={Rows}", JobName, kind, day, parsed.Count);
            rows.AddRange(parsed);
        }

        if (rows.Count == 0)
        {
            Logger.LogInformation("[{Job}] basDd={Day} 선물 미반영 (0건)", JobName, day);
            return;
        }

        var existing = await db.FuturesDailyTrade.Where(c => c.TradeDate == day).ToListAsync(ct);
        var existingByKey = existing.ToDictionary(c => (c.FuturesKind, c.IsuCode, c.Session));
        var inserted = 0;
        var updated = 0;

        foreach (var row in rows)
        {
            if (existingByKey.TryGetValue((row.FuturesKind, row.IsuCode, row.Session), out var trade))
            {
                trade.Update(row.IsuName, row.Close, row.Open, row.High, row.Low, row.ChangeAmount, row.SpotPrice, row.SettlePrice, row.Volume, row.TradeValue, row.OpenInterest, row.ProductName, row.MarketName);
                updated++;
            }
            else
            {
                var created = FuturesDailyTrade.Create(row.FuturesKind, row.IsuCode, row.IsuName, row.TradeDate, row.Session, row.Close, row.Open, row.High, row.Low, row.ChangeAmount, row.SpotPrice, row.SettlePrice, row.Volume, row.TradeValue, row.OpenInterest, row.ProductName, row.MarketName);
                await db.FuturesDailyTrade.AddAsync(created, ct);
                existingByKey[(row.FuturesKind, row.IsuCode, row.Session)] = created;
                inserted++;
            }
        }

        await db.SaveChangesAsync(ct);

        Logger.LogInformation("[{Job}] basDd={Day} 선물 적재 — rows={Rows}, inserted={Inserted}, updated={Updated}",
            JobName, day, rows.Count, inserted, updated);
    }

    private async Task FetchAndUpsertOptionsAsync(IAppDbContext db, HttpClient client, string baseUrl, string apiKey, DateOnly day, CancellationToken ct)
    {
        var rows = new List<KrxOptionsParser.OptionsRow>();

        foreach (var (kind, path) in OptionsEndpoints)
        {
            var url = $"{baseUrl.TrimEnd('/')}{path}?basDd={day:yyyyMMdd}";
            var json = await KrxCoKrHttp.GetStringWithRetryAsync(client, url, apiKey, Logger, ct);
            var parsed = KrxOptionsParser.ParseDaily(json, kind);

            Logger.LogInformation("[{Job}] 옵션 {Kind} basDd={Day} rows={Rows}", JobName, kind, day, parsed.Count);
            rows.AddRange(parsed);
        }

        if (rows.Count == 0)
        {
            Logger.LogInformation("[{Job}] basDd={Day} 옵션 미반영 (0건)", JobName, day);
            return;
        }

        var existing = await db.OptionsDailyTrade.Where(c => c.TradeDate == day).ToListAsync(ct);
        var existingByKey = existing.ToDictionary(c => (c.OptionsKind, c.IsuCode, c.Session));
        var inserted = 0;
        var updated = 0;

        foreach (var row in rows)
        {
            if (existingByKey.TryGetValue((row.OptionsKind, row.IsuCode, row.Session), out var trade))
            {
                trade.Update(row.IsuName, row.RightType, row.StrikePrice, row.Close, row.Open, row.High, row.Low, row.ChangeAmount, row.ImpliedVolatility, row.NextDayBasePrice, row.Volume, row.TradeValue, row.OpenInterest, row.ProductName);
                updated++;
            }
            else
            {
                var created = OptionsDailyTrade.Create(row.OptionsKind, row.IsuCode, row.IsuName, row.TradeDate, row.Session, row.RightType, row.StrikePrice, row.Close, row.Open, row.High, row.Low, row.ChangeAmount, row.ImpliedVolatility, row.NextDayBasePrice, row.Volume, row.TradeValue, row.OpenInterest, row.ProductName);
                await db.OptionsDailyTrade.AddAsync(created, ct);
                existingByKey[(row.OptionsKind, row.IsuCode, row.Session)] = created;
                inserted++;
            }
        }

        await db.SaveChangesAsync(ct);

        Logger.LogInformation("[{Job}] basDd={Day} 옵션 적재 — rows={Rows}, inserted={Inserted}, updated={Updated}",
            JobName, day, rows.Count, inserted, updated);
    }
}