ANTOOZA-BACKEND/Infrastructure/StockData/SeibroCorpActionSyncService.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 3) — 기본 07:20 KST(SupplySync 07:00 다음 슬롯), `Seibro:CorpActionSync` 게이트.
/// 총회·상호변경·대금·단주 4단계는 기업(Corp) 예산(Seibro:CorpBudget), CB/BW 행사 2단계는 주식(Stock) 예산(Seibro:StockBudget)을 공유한다.
///
/// a) 총회 이벤트 구동: RightsBaseDate(Wave 1 적재)의 RGT_RACD∈{001,002,003,009} 인 (회사번호, 기준일) →
///    getGmeetInfo + getGmeetMeasureInfo(Corp). rolling(미수집 (회사,기준일) 우선).
/// b) 상호변경 이벤트 구동: RightsBaseDate RGT_RACD=204 인 (회사번호, 기준일) → getFmnmAltInfo(Corp) rolling.
/// c) PaymentSchedule: getCostPaySchedul 날짜 스윕(TH1_PAY_TERM_BEGIN_DT) × PAY_COST_TPCD{1,3}(Corp) — 지급일+구분 window delete+insert.
/// d) OddLotPayment: PaymentSchedule 중 PayCostTpcd=3(단주) 인 (회사번호, 지급일) → getOddLotInfo(Corp) rolling.
/// e) ConvertibleExercise: getXrcStkOptionXrcInfo 날짜 스윕(RGT_STD_DT=권리행사일)(Stock) — 권리행사일 window delete+insert.
///    반환된 BOND_ISIN 이 (f)의 발견 소스.
/// f) ConvertibleBondTarget: (e)에서 발견된 DISTINCT BondIsin → getXrcStkStatInfo(BOND_ISIN)(Stock) rolling.
///    (Wave 4 BondIssuance 는 아직 없으니 (e) 결과만 시드 — 발견 소스 단일.)
///
/// 실패/0행 = 정상 빈결과. HTTP·파싱 오류 = 경고 + false(RetryDelay 후 재시도). quota 소진 = 정상 종료(true). ApiKey 미설정 시 skip.
/// ⚠️ getXrcStk* 실샘플이 result="0" 이라 CB/BW 필드 매핑은 스펙 기준 — 운영 첫 수집 시 로그로 확인.
/// </summary>
internal sealed class SeibroCorpActionSyncService(
    IServiceScopeFactory scopeFactory,
    IHttpClientFactory httpClientFactory,
    SeibroQuota quota,
    IOptions<AppSettings> settings,
    ILogger<SeibroCorpActionSyncService> logger
) : DailyScheduledService(logger)
{
    // 총회계열 권리사유코드 (RGT_RACD) — getGmeetInfo/getGmeetMeasureInfo 트리거
    private static readonly string[] MeetingRacds = ["001", "002", "003", "009"];

    // 상호변경 권리사유코드 (RGT_RACD) — getFmnmAltInfo 트리거
    private const string NameChangeRacd = "204";

    // 대금지급구분 (PAY_COST_TPCD) — 1배당금 3단주대금
    private static readonly string[] PayCostTpcds = ["1", "3"];

    private const string OddLotPayCostTpcd = "3";

    protected override string JobName => "SeibroCorpActionSync";

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

    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) 총회 이벤트 구동 (Corp)
            if (!await RollMeetingsAsync(db, client, cfg, ct))
            {
                return true;
            }

            // b) 상호변경 이벤트 구동 (Corp)
            if (!await RollNameChangesAsync(db, client, cfg, ct))
            {
                return true;
            }

            // c) 대금지급일정 날짜 스윕 × 구분{1,3} (Corp)
            if (!await SweepPaymentSchedulesAsync(db, client, cfg, startDate, todayKst, ct))
            {
                return true;
            }

            // d) 단주대금 이벤트 구동 (Corp)
            if (!await RollOddLotsAsync(db, client, cfg, ct))
            {
                return true;
            }

            // e) CB/BW 행사 날짜 스윕 (Stock) — (f)의 발견 소스
            if (!await SweepExercisesAsync(db, client, cfg, startDate, todayKst, ct))
            {
                return true;
            }

            // f) CB/BW 행사대상 rolling per-채권ISIN (Stock)
            await RollBondTargetsAsync(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) 총회 이벤트 구동 — RightsBaseDate RGT_RACD∈{001,002,003,009} 의 (회사번호, 기준일) 중 GeneralMeeting 미수집·stale 우선.
    /// (회사, 기준일) 당 getGmeetInfo + getGmeetMeasureInfo 2콜(각각 Corp 예산 소비). 예산 소진 시 false.
    /// </summary>
    private async Task<bool> RollMeetingsAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        var triggers = await db.RightsBaseDate.AsNoTracking()
            .Where(c => MeetingRacds.Contains(c.RgtRacd))
            .Select(c => new { c.IssucoCustno, c.RgtStdDt })
            .Distinct()
            .ToListAsync(ct);

        if (triggers.Count == 0)
        {
            Logger.LogInformation("[{Job}] 총회 트리거 없음 (RightsBaseDate 총회계열 미적재)", JobName);
            return true;
        }

        var lastByKey = await db.GeneralMeeting.AsNoTracking()
            .GroupBy(c => new { c.IssucoCustno, c.RgtStdDt })
            .Select(g => new { g.Key.IssucoCustno, g.Key.RgtStdDt, Last = g.Max(c => c.UpdatedAt) })
            .ToListAsync(ct);
        var lastLookup = lastByKey.ToDictionary(c => (c.IssucoCustno, c.RgtStdDt), c => c.Last);

        var targets = triggers.Select(t => (
            Key: (t.IssucoCustno, t.RgtStdDt),
            LastUpdatedAt: lastLookup.TryGetValue((t.IssucoCustno, t.RgtStdDt), out var last) ? (DateTime?)last : null
        )).ToList();

        // getGmeetInfo + getGmeetMeasureInfo = 2콜/트리거 → maxPerRun 은 잔여예산/2 로 산정(각 콜이 개별 TryConsume).
        var maxPerRun = quota.Remaining(SeibroCategory.Corp, cfg.CorpBudget) / 2;
        var quotaExhausted = false;

        var processed = await SeibroRollingSweep.RunAsync(
            targets: targets,
            fetchAndUpsert: async (key, token) => {
                var (custno, stdDt) = key;
                var stdDtStr = stdDt.ToString("yyyyMMdd");

                if (!quota.TryConsume(SeibroCategory.Corp, 1, cfg.CorpBudget))
                {
                    quotaExhausted = true;
                    return;
                }

                var gmeetXml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getGmeetInfo", [new("ISSUCO_CUSTNO", custno.ToString()), new("RGT_STD_DT", stdDtStr)], Logger, token);
                var gmeetRows = SeibroGmeetParser.Parse(SeibroXml.Parse(gmeetXml));
                var (gi, gu) = await SeibroCorpActionImport.UpsertGeneralMeetingsAsync(db, gmeetRows, token);

                if (!quota.TryConsume(SeibroCategory.Corp, 1, cfg.CorpBudget))
                {
                    quotaExhausted = true;
                    return;
                }

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

                var measureXml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getGmeetMeasureInfo", [new("ISSUCO_CUSTNO", custno.ToString()), new("RGT_STD_DT", stdDtStr)], Logger, token);
                var measureRows = SeibroGmeetMeasureParser.Parse(SeibroXml.Parse(measureXml));
                var (mi, mu) = await SeibroCorpActionImport.UpsertMeetingAgendasAsync(db, measureRows, token);

                Logger.LogInformation("[{Job}] 총회 ISSUCO_CUSTNO={Custno} RGT_STD_DT={Std} — 총회 ins={Gi}/upd={Gu}, 안건 ins={Mi}/upd={Mu}", JobName, custno, stdDtStr, gi, gu, mi, mu);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

        Logger.LogInformation("[{Job}] 총회 rolling 완료 — 트리거={Triggers}, 처리={Processed} (maxPerRun={Max})", JobName, targets.Count, processed, maxPerRun);
        return !quotaExhausted;
    }

    /// <summary>
    /// b) 상호변경 이벤트 구동 — RightsBaseDate RGT_RACD=204 의 (회사번호, 기준일) 중 CorpNameChange 미수집·stale 우선.
    /// getFmnmAltInfo(ISSUCO_CUSTNO, RGT_STD_DT) 1콜(Corp). 예산 소진 시 false.
    /// </summary>
    private async Task<bool> RollNameChangesAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        var triggers = await db.RightsBaseDate.AsNoTracking()
            .Where(c => c.RgtRacd == NameChangeRacd)
            .Select(c => new { c.IssucoCustno, c.RgtStdDt })
            .Distinct()
            .ToListAsync(ct);

        if (triggers.Count == 0)
        {
            Logger.LogInformation("[{Job}] 상호변경 트리거 없음 (RightsBaseDate RGT_RACD=204 미적재)", JobName);
            return true;
        }

        var lastByKey = await db.CorpNameChange.AsNoTracking()
            .GroupBy(c => new { c.IssucoCustno, c.RgtStdDt })
            .Select(g => new { g.Key.IssucoCustno, g.Key.RgtStdDt, Last = g.Max(c => c.UpdatedAt) })
            .ToListAsync(ct);
        var lastLookup = lastByKey.ToDictionary(c => (c.IssucoCustno, c.RgtStdDt), c => c.Last);

        var targets = triggers.Select(t => (
            Key: (t.IssucoCustno, t.RgtStdDt),
            LastUpdatedAt: lastLookup.TryGetValue((t.IssucoCustno, t.RgtStdDt), out var last) ? (DateTime?)last : null
        )).ToList();

        var maxPerRun = quota.Remaining(SeibroCategory.Corp, cfg.CorpBudget);
        var quotaExhausted = false;

        var processed = await SeibroRollingSweep.RunAsync(
            targets: targets,
            fetchAndUpsert: async (key, token) => {
                var (custno, stdDt) = key;

                if (!quota.TryConsume(SeibroCategory.Corp, 1, cfg.CorpBudget))
                {
                    quotaExhausted = true;
                    return;
                }

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getFmnmAltInfo", [new("ISSUCO_CUSTNO", custno.ToString()), new("RGT_STD_DT", stdDt.ToString("yyyyMMdd"))], Logger, token);
                var rows = SeibroFmnmAltParser.Parse(SeibroXml.Parse(xml));
                var (inserted, updated) = await SeibroCorpActionImport.UpsertNameChangesAsync(db, rows, token);

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

        Logger.LogInformation("[{Job}] 상호변경 rolling 완료 — 트리거={Triggers}, 처리={Processed} (maxPerRun={Max})", JobName, targets.Count, processed, maxPerRun);
        return !quotaExhausted;
    }

    /// <summary>
    /// c) 대금지급일정 날짜 스윕(전 캘린더일, 최신→과거) × 구분{1,3} — 지급일+구분 window delete+insert. 미적재 (일,구분)만.
    /// ⚠️ 대금지급일은 배당·단주 지급일이라 주말/휴장 가능성 있어(SeibroDividendSync 판단 동일) 전 캘린더일 스윕. 예산 소진 시 false.
    /// </summary>
    private async Task<bool> SweepPaymentSchedulesAsync(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 PayCostTpcds)
            {
                ct.ThrowIfCancellationRequested();

                if (await db.PaymentSchedule.AsNoTracking().AnyAsync(c => c.Th1PayTermBeginDt == day && c.PayCostTpcd == tpcd, ct))
                {
                    continue; // 이미 적재된 (지급일, 구분) — resumable
                }

                if (!quota.TryConsume(SeibroCategory.Corp, 1, cfg.CorpBudget))
                {
                    Logger.LogWarning("[{Job}] 기업 예산({Budget}) 소진 — getCostPaySchedul {Day}/{Tpcd} 부터 중단", JobName, cfg.CorpBudget, 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, "getCostPaySchedul", [new("TH1_PAY_TERM_BEGIN_DT", day.ToString("yyyyMMdd")), new("PAY_COST_TPCD", tpcd)], Logger, ct);
                var rows = SeibroCostPaySchedulParser.Parse(SeibroXml.Parse(xml));
                var (inserted, deleted) = await SeibroCorpActionImport.ReplacePaymentScheduleWindowAsync(db, day, tpcd, rows, ct);

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

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

    /// <summary>
    /// d) 단주대금 이벤트 구동 — PaymentSchedule 중 PAY_COST_TPCD=3(단주) 의 (회사번호, 지급일) 중 OddLotPayment 미수집·stale 우선.
    /// getOddLotInfo(ISSUCO_CUSTNO, TH1_PAY_TERM_BEGIN_DT) 1콜(Corp). 예산 소진 시 false.
    /// </summary>
    private async Task<bool> RollOddLotsAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        var triggers = await db.PaymentSchedule.AsNoTracking()
            .Where(c => c.PayCostTpcd == OddLotPayCostTpcd)
            .Select(c => new { c.IssucoCustno, c.Th1PayTermBeginDt })
            .Distinct()
            .ToListAsync(ct);

        if (triggers.Count == 0)
        {
            Logger.LogInformation("[{Job}] 단주대금 트리거 없음 (PaymentSchedule 단주(구분3) 미적재)", JobName);
            return true;
        }

        var lastByKey = await db.OddLotPayment.AsNoTracking()
            .GroupBy(c => new { c.IssucoCustno, c.PayDate })
            .Select(g => new { g.Key.IssucoCustno, g.Key.PayDate, Last = g.Max(c => c.UpdatedAt) })
            .ToListAsync(ct);
        var lastLookup = lastByKey.ToDictionary(c => (c.IssucoCustno, c.PayDate), c => c.Last);

        var targets = triggers.Select(t => (
            Key: (t.IssucoCustno, PayDate: t.Th1PayTermBeginDt),
            LastUpdatedAt: lastLookup.TryGetValue((t.IssucoCustno, t.Th1PayTermBeginDt), out var last) ? (DateTime?)last : null
        )).ToList();

        var maxPerRun = quota.Remaining(SeibroCategory.Corp, cfg.CorpBudget);
        var quotaExhausted = false;

        var processed = await SeibroRollingSweep.RunAsync(
            targets: targets,
            fetchAndUpsert: async (key, token) => {
                var (custno, payDate) = key;

                if (!quota.TryConsume(SeibroCategory.Corp, 1, cfg.CorpBudget))
                {
                    quotaExhausted = true;
                    return;
                }

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getOddLotInfo", [new("ISSUCO_CUSTNO", custno.ToString()), new("TH1_PAY_TERM_BEGIN_DT", payDate.ToString("yyyyMMdd"))], Logger, token);
                var rows = SeibroOddLotParser.Parse(SeibroXml.Parse(xml));
                var (inserted, updated) = await SeibroCorpActionImport.UpsertOddLotsAsync(db, custno, payDate, rows, token);

                Logger.LogInformation("[{Job}] 단주대금 ISSUCO_CUSTNO={Custno} 지급일={Pay} rows={Rows} — inserted={Inserted}, updated={Updated}", JobName, custno, payDate, rows.Count, inserted, updated);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

        Logger.LogInformation("[{Job}] 단주대금 rolling 완료 — 트리거={Triggers}, 처리={Processed} (maxPerRun={Max})", JobName, targets.Count, processed, maxPerRun);
        return !quotaExhausted;
    }

    /// <summary>
    /// e) CB/BW 행사 날짜 스윕(전 캘린더일, 최신→과거) — 권리행사일 window delete+insert. 미적재일만. Stock 예산. 예산 소진 시 false.
    /// ⚠️ 권리행사일(RGT_STD_DT)은 영업일 성격이나 스펙상 확정 불가라 전 캘린더일 스윕(보수적). 반환 BOND_ISIN 이 (f) 발견 소스.
    /// </summary>
    private async Task<bool> SweepExercisesAsync(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.ConvertibleExercise.AsNoTracking().AnyAsync(c => c.RgtStdDt == day, ct))
            {
                continue; // 이미 적재된 권리행사일 — resumable
            }

            if (!quota.TryConsume(SeibroCategory.Stock, 1, cfg.StockBudget))
            {
                Logger.LogWarning("[{Job}] 주식 예산({Budget}) 소진 — getXrcStkOptionXrcInfo {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, "getXrcStkOptionXrcInfo", [new("RGT_STD_DT", day.ToString("yyyyMMdd"))], Logger, ct);
            var rows = SeibroXrcStkOptionXrcParser.Parse(SeibroXml.Parse(xml));
            var (inserted, deleted) = await SeibroCorpActionImport.ReplaceExerciseWindowAsync(db, day, day, rows, ct);

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

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

    /// <summary>
    /// f) CB/BW 행사대상 rolling per-채권ISIN — (e) ConvertibleExercise 에서 발견된 DISTINCT BondIsin 중 ConvertibleBondTarget 미수집·stale 우선.
    /// getXrcStkStatInfo(BOND_ISIN) 1콜(Stock). Wave 4 BondIssuance 미도입이라 발견 소스는 (e) 결과뿐.
    /// </summary>
    private async Task RollBondTargetsAsync(IAppDbContext db, HttpClient client, AppSettings.SeibroSection cfg, CancellationToken ct)
    {
        var bondIsins = await db.ConvertibleExercise.AsNoTracking().Select(c => c.BondIsin).Distinct().ToListAsync(ct);

        if (bondIsins.Count == 0)
        {
            Logger.LogInformation("[{Job}] getXrcStkStatInfo 대상 없음 (ConvertibleExercise 비어 있음 — 발견 소스 없음)", JobName);
            return;
        }

        var lastByBond = await db.ConvertibleBondTarget.AsNoTracking().GroupBy(c => c.BondIsin).Select(g => new { BondIsin = g.Key, Last = g.Max(c => c.UpdatedAt) }).ToDictionaryAsync(c => c.BondIsin, c => c.Last, ct);

        var targets = bondIsins.Select(isin => (Key: isin, LastUpdatedAt: lastByBond.TryGetValue(isin, out var last) ? (DateTime?)last : null)).ToList();
        var maxPerRun = quota.Remaining(SeibroCategory.Stock, cfg.StockBudget);

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

                var xml = await SeibroHttp.GetStringWithRetryAsync(client, cfg.BaseUrl, cfg.ApiKey, "getXrcStkStatInfo", [new("BOND_ISIN", bondIsin)], Logger, token);
                var rows = SeibroXrcStkStatParser.Parse(SeibroXml.Parse(xml));
                var (inserted, updated) = await SeibroCorpActionImport.UpsertBondTargetsAsync(db, rows, token);

                Logger.LogInformation("[{Job}] getXrcStkStatInfo BOND_ISIN={Bond} rows={Rows} — inserted={Inserted}, updated={Updated}", JobName, bondIsin, rows.Count, inserted, updated);
            },
            maxPerRun: maxPerRun,
            delayMs: cfg.DelayMs,
            ct: ct);

        Logger.LogInformation("[{Job}] getXrcStkStatInfo rolling 완료 — 대상채권={Targets}, 처리={Processed} (maxPerRun={Max})", JobName, targets.Count, processed, maxPerRun);
    }
}