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>
/// 일별 마감 시세 수집 (KRX OpenAPI) — stk_bydd_trd(KOSPI) + ksq_bydd_trd(KOSDAQ) + knx_bydd_trd(KONEX) 일별매매정보.
/// 기본 18:10 KST 실행(장 마감 15:30 이후 확정). 공용 KrxBackfill 로 최근 BackfillYears(기본 3)년치를 endDate(직전 영업일)부터
/// 과거로 훑으며 미적재일만 채운다. quota 보호를 위해 1회 실행당 BackfillMaxPerRun(기본 60)일까지만 fetch →
/// 여러 날에 걸쳐 3년치를 메우고 이후엔 최신만 유지한다. 각 날짜는 3개 시장 엔드포인트를 모두 수집해
/// StockDailyPrice upsert (StockID+TradingDate) + Stock.UpdateLastPrice denorm(최근 종가/등락률/시총) 갱신.
/// existsForDate 는 Stock.Market 조인으로 3개 시장이 전부 적재됐을 때만 skip (일부 시장만 성공한 부분 적재 날짜는 재수집 — 영구 결손 방지).
/// (denorm 은 Stock.UpdateLastPrice 가 최신일보다 과거일이면 무시하므로 과거 백필이 최신값을 덮지 않는다.)
/// 마스터 미동기화 코드는 skip (다음 마스터 동기화 후 자연 반영).
/// ApiKey 미설정 시 로그만 남기고 skip (다른 KRX 배치와 동일 정책).
/// KONEX 응답 필드셋은 KOSPI/KOSDAQ 과 동일(ISU_CD/TDD_*/ACC_*/MKTCAP/LIST_SHRS) — KrxStockParser 재사용.
/// </summary>
internal sealed class KrxDailyPriceSyncService(
    IServiceScopeFactory scopeFactory,
    IHttpClientFactory httpClientFactory,
    IOptions<AppSettings> settings,
    ILogger<KrxDailyPriceSyncService> logger
) : DailyScheduledService(logger)
{
    // (시장, 엔드포인트 경로) — KOSPI/KOSDAQ/KONEX. 세 시장 모두 StockDailyPrice 에 동일 스키마로 적재된다.
    private static readonly (StockMarket Market, string Path)[] Endpoints =
    [
        (StockMarket.KOSPI, "/svc/apis/sto/stk_bydd_trd"),
        (StockMarket.KOSDAQ, "/svc/apis/sto/ksq_bydd_trd"),
        (StockMarket.KONEX, "/svc/apis/sto/knx_bydd_trd")
    ];

    // 시장별 데이터 시작일 (docs/KRX/readme.md — KONEX 는 2013-07-01 개장)
    private static readonly (StockMarket Market, DateOnly DataStartDate)[] MarketStartDates =
    [
        (StockMarket.KOSPI, new DateOnly(2010, 1, 4)),
        (StockMarket.KOSDAQ, new DateOnly(2010, 1, 4)),
        (StockMarket.KONEX, new DateOnly(2013, 7, 1))
    ];

    protected override string JobName => "KrxDailyPriceSync";

    protected override TimeOnly TargetTime => ParseTime(settings.Value.KRXCoKr.StockSyncTime, new TimeOnly(18, 10));

    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;
        if (string.IsNullOrWhiteSpace(cfg.ApiKey))
        {
            Logger.LogWarning("[{Job}] KRXCoKr:ApiKey 미설정 — 수집 skip", JobName);
            return true;
        }

        using var scope = scopeFactory.CreateScope();
        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;

        // 시장(KOSPI/KOSDAQ/KONEX)별 완전성 판정 — StockDailyPrice 엔 시장 컬럼이 없어 Stock.Market 조인으로 판정한다
        async Task<bool> ExistsForDateAsync(DateOnly day, CancellationToken token)
        {
            var markets = await db.StockDailyPrice.AsNoTracking().Where(c => c.TradingDate == day).Join(db.Stock.AsNoTracking(), c => c.StockID, s => s.ID, (c, s) => s.Market).Distinct().ToListAsync(token);
            return BackfillCompleteness.IsComplete(markets, MarketStartDates, 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개 시장 엔드포인트를 모두 수집하고 StockDailyPrice upsert + Stock denorm 갱신.</summary>
    private async Task FetchAndUpsertAsync(IAppDbContext db, HttpClient client, string baseUrl, string apiKey, DateOnly day, CancellationToken ct)
    {
        var rows = new List<KrxStockParser.DailyPriceItem>();

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

            Logger.LogInformation("[{Job}] {Market} basDd={Day} rows={Rows}", JobName, market, day, parsed.Count);
            rows.AddRange(parsed);
        }

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

        var stockByCode = await db.Stock.ToDictionaryAsync(c => c.Code, ct);
        var existingByStockID = await db.StockDailyPrice.Where(c => c.TradingDate == day).ToDictionaryAsync(c => c.StockID, ct);
        var inserted = 0;
        var updated = 0;
        var unknown = 0;

        foreach (var row in rows)
        {
            if (!stockByCode.TryGetValue(row.Code, out var stock))
            {
                // 마스터 미동기화 종목 — 다음 마스터 동기화 후 자연 반영 (DailyPriceSyncService 와 동일 정책)
                unknown++;
                continue;
            }

            if (existingByStockID.TryGetValue(stock.ID, out var price))
            {
                price.Update(row.Open, row.High, row.Low, row.Close, row.Volume, row.TradingValue, row.ChangeAmount, row.ChangeRate, row.MarketCap, row.ListedShares);
                updated++;
            }
            else
            {
                var created = StockDailyPrice.Create(stock.ID, row.TradingDate, row.Open, row.High, row.Low, row.Close, row.Volume, row.TradingValue, row.ChangeAmount, row.ChangeRate, row.MarketCap, row.ListedShares);
                await db.StockDailyPrice.AddAsync(created, ct);
                existingByStockID[stock.ID] = created;
                inserted++;
            }

            stock.UpdateLastPrice(row.TradingDate, row.Close, row.ChangeRate, row.MarketCap);
        }

        await db.SaveChangesAsync(ct);

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