import type { DebtMaturitiesPayload } from "./debt-maturities";
import type { CryptoMarketsPayload } from "./crypto-markets";
import type { CentralBankRatesPayload } from "./central-bank-rates";
import type { EstimateRevisionsPayload } from "./estimate-revisions";
import type { MoneyMarketsPayload } from "./money-markets";
import type { ShortVolumePayload, ShortVolumeScope } from "./short-volume";
import type { FuturesCurvePayload } from "./futures-curve";
import type { CotBoardPayload, CotContractPayload, CotFamily, CotClass } from "./cot";
import type { TapeSnapshot } from "./tape";
import type { ExchangeRateSnapshot } from "../types/exchange-rate";
import type { RatePathPayload } from "./rates";
import type { TickerFinancials } from "../types/financials";
import type { InstrumentSearchResult } from "../types/instrument";
import {
  normalizeSavedSearchHits,
  normalizeSavedSearchResponse,
  normalizeSearchResponse,
  normalizeTweetSearchResponse,
} from "./normalizers";
import {
  cloudCdsPath,
  cloudCongressHousePath,
  cloudEarningsCallsPath,
  cloudEarningsTranscriptPath,
  cloudJobsMoversPath,
  cloudJobsPath,
  cloudJobsPostingsPath,
  type CloudJobsPostingsParams,
  publicProxyStatementPath,
  publicFilingEventsPath,
  publicRiskReportPath,
  publicRiskReportsPath,
  publicProxyStatementsPath,
  cloudExchangeRatePath,
  cloudSec13FPath,
  cloudSecFilingContentPath,
  cloudSecFilingDocumentsPath,
  cloudSecFilingsPath,
  cloudFredSeriesPath,
  cloudShillerPath,
  cloudHistoryPath,
  cloudMarketSearchPath,
  cloudMarketSymbolPath,
  cloudNewsPath,
  cloudOptionsChainPath,
  cloudSavedSearchHitsPath,
  cloudSavedSearchPath,
  cloudSavedSearchesPath,
  cloudSearchDocumentPath,
  cloudSearchPath,
  cloudStatementsPath,
  cloudTickerTweetsPath,
  cloudTweetSearchPath,
  type CloudCdsParams,
  type CloudCongressHouseParams,
  type CloudEarningsCallsParams,
  type CloudFredSeriesParams,
  type CloudHistoryParams,
  type CloudNewsParams,
  type CloudSearchParams,
  type CloudSecFilingParams,
  type CloudSecFilingsParams,
  type CloudTickerTweetsParams,
  type CloudTweetSearchParams,
} from "./paths";
import type {
  CloudAnalystResearchPayload,
  CloudShortInterestPayload,
  CloudCdsResponse,
  CloudCompanyProfile,
  CloudCongressHousePayload,
  CloudEarningsCallListPayload,
  CloudEarningsTranscriptPayload,
  CloudJobsMoversPayload,
  CloudJobsPostingsPayload,
  CloudJobsResponse,
  CloudProxyStatementListPayload,
  CloudProxyStatementPayload,
  CloudFilingEventPayload,
  CloudRiskReportListPayload,
  CloudRiskReportPayload,
  CloudCorporateActionsPayload,
  CloudEconEventPayload,
  CloudEquityDiagnosticMode,
  CloudEquityDiagnosticResult,
  CloudFredSeriesPayload,
  CloudShillerPayload,
  CloudFundamentals,
  CloudFinancialsPayload,
  CloudHoldersPayload,
  CloudMarketBatchPayload,
  CloudMarketBatchTarget,
  CloudMarketResponse,
  CloudMarketScreenerCategory,
  CloudMarketScreenerPayload,
  CloudNewsListResponse,
  CloudNewsPayload,
  CloudSavedSearch,
  CloudSavedSearchInput,
  CloudSavedSearchListResponse,
  CloudSearchDocType,
  CloudSearchDocument,
  CloudSearchDocumentResponse,
  CloudSearchHit,
  CloudSearchResponse,
  CloudSecContentResponse,
  CloudSecDocumentsResponse,
  CloudSecFilingsResponse,
  CloudOptionsChainPayload,
  CloudPricePointPayload,
  CloudQuotePayload,
  CloudTweetSearchResponse,
  CloudWorldVenueMapPayload,
  CloudYieldPointPayload,
  ScannerFlowHistoryPage,
} from "./types";

type CloudApiRequest = <T>(path: string, options?: RequestInit) => Promise<T>;

export class CloudDataApi {
  constructor(private readonly request: CloudApiRequest) {}

  private requestMarketSymbol<T>(
    path: string,
    symbol: string,
    exchange?: string,
  ): Promise<CloudMarketResponse<T>> {
    return this.request<CloudMarketResponse<T>>(
      cloudMarketSymbolPath(path, symbol, exchange),
    );
  }

  private postMarketBatch<T>(
    path: string,
    targets: CloudMarketBatchTarget[],
    mode: "cache-first" | "refresh",
  ): Promise<CloudMarketResponse<CloudMarketBatchPayload<T>>> {
    return this.request<CloudMarketResponse<CloudMarketBatchPayload<T>>>(path, {
      method: "POST",
      body: JSON.stringify({ targets, mode }),
    });
  }

  /** EQS endpoints live in the plugin client; one prefix-scoped method keeps the shared client small. */
  equityScreener<T>(path: string, init?: RequestInit) {
    return this.request<T>(`/cloud/equity-screener/${path}`, init);
  }

  /** Stored implied volatility (HIVG, VCA, OVDV dates); one prefix-scoped method, like EQS. */
  impliedVolatility<T>(path: string, init?: RequestInit) {
    return this.request<T>(`/cloud/iv/${path}`, init);
  }

  async searchInstruments(
    query: string,
    limit = 10,
  ): Promise<InstrumentSearchResult[]> {
    const response = await this.request<
      CloudMarketResponse<InstrumentSearchResult[]>
    >(cloudMarketSearchPath(query, limit));
    return response.data ?? [];
  }

  async getCloudEstimateRevisions(symbol: string, exchange: string): Promise<EstimateRevisionsPayload> {
    return this.request<EstimateRevisionsPayload>(`/cloud/research/estimates/${encodeURIComponent(symbol)}?exchange=${encodeURIComponent(exchange)}`, { signal: AbortSignal.timeout(45_000) });
  }

  async getCloudQuote(
    symbol: string,
    exchange?: string,
  ): Promise<CloudMarketResponse<CloudQuotePayload>> {
    return this.requestMarketSymbol("/market/quote", symbol, exchange);
  }

  async getCloudQuotesBatch(
    targets: CloudMarketBatchTarget[],
    mode: "cache-first" | "refresh" = "cache-first",
  ): Promise<CloudMarketResponse<CloudMarketBatchPayload<CloudQuotePayload>>> {
    return this.postMarketBatch("/market/quotes/batch", targets, mode);
  }

  async getCloudWorldVenues(): Promise<
    CloudMarketResponse<CloudWorldVenueMapPayload>
  > {
    return this.request<CloudMarketResponse<CloudWorldVenueMapPayload>>(
      "/market/venues",
    );
  }

  async getCloudMarketScreener(
    category: CloudMarketScreenerCategory,
    count = 25,
    mode: "cache-first" | "refresh" = "cache-first",
  ): Promise<CloudMarketResponse<CloudMarketScreenerPayload>> {
    const requestedCount = Number.isFinite(count) ? Math.round(count) : 25;
    const params = new URLSearchParams({
      category,
      count: String(Math.max(1, Math.min(50, requestedCount))),
      mode,
    });
    return this.request<CloudMarketResponse<CloudMarketScreenerPayload>>(
      `/market/screener?${params.toString()}`,
    );
  }

  async getCloudOptionsChain(
    symbol: string,
    exchange?: string,
    expirationDate?: number,
  ): Promise<CloudMarketResponse<CloudOptionsChainPayload>> {
    return this.request<CloudMarketResponse<CloudOptionsChainPayload>>(
      cloudOptionsChainPath(symbol, exchange, expirationDate),
    );
  }

  async getCloudProfile(
    symbol: string,
    exchange?: string,
  ): Promise<CloudMarketResponse<CloudCompanyProfile>> {
    return this.requestMarketSymbol("/market/profile", symbol, exchange);
  }

  async getCloudFundamentals(
    symbol: string,
    exchange?: string,
  ): Promise<CloudMarketResponse<CloudFundamentals>> {
    return this.requestMarketSymbol("/market/fundamentals", symbol, exchange);
  }

  async getCloudFinancials(
    symbol: string,
    exchange?: string,
    statementHistory?: "extended",
  ): Promise<CloudMarketResponse<CloudFinancialsPayload>> {
    const path = cloudMarketSymbolPath("/market/financials", symbol, exchange);
    return this.request(statementHistory === "extended" ? `${path}&statementHistory=extended` : path);
  }

  async getCloudFinancialsBatch(
    targets: CloudMarketBatchTarget[],
    mode: "cache-first" | "refresh" = "cache-first",
  ): Promise<CloudMarketResponse<CloudMarketBatchPayload<CloudFinancialsPayload>>> {
    return this.postMarketBatch("/market/financials/batch", targets, mode);
  }

  async getCloudHolders(
    symbol: string,
    exchange?: string,
  ): Promise<CloudMarketResponse<CloudHoldersPayload>> {
    return this.requestMarketSymbol("/market/holders", symbol, exchange);
  }

  async getCloudAnalystResearch(
    symbol: string,
    exchange?: string,
  ): Promise<CloudMarketResponse<CloudAnalystResearchPayload>> {
    return this.requestMarketSymbol("/market/analyst", symbol, exchange);
  }

  async getCloudShortInterest(
    symbol: string,
    years?: number,
  ): Promise<CloudMarketResponse<CloudShortInterestPayload>> {
    const params = new URLSearchParams({ symbol: symbol.toUpperCase() });
    if (years != null) params.set("years", String(years));
    return this.request<CloudMarketResponse<CloudShortInterestPayload>>(
      `/market/short-interest?${params}`,
    );
  }

  async getCloudCorporateActions(
    symbol: string,
    exchange?: string,
  ): Promise<CloudMarketResponse<CloudCorporateActionsPayload>> {
    return this.requestMarketSymbol(
      "/market/corporate-actions",
      symbol,
      exchange,
    );
  }

  async getCloudStatements(
    symbol: string,
    exchange?: string,
    period: "annual" | "quarterly" | "both" = "both",
  ): Promise<
    CloudMarketResponse<
      Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">
    >
  > {
    return this.request<
      CloudMarketResponse<
        Pick<TickerFinancials, "annualStatements" | "quarterlyStatements">
      >
    >(cloudStatementsPath(symbol, exchange, period));
  }

  async getCloudHistory(
    symbol: string,
    exchange: string,
    params: CloudHistoryParams = {},
  ): Promise<CloudMarketResponse<CloudPricePointPayload[]>> {
    return this.request<CloudMarketResponse<CloudPricePointPayload[]>>(
      cloudHistoryPath(symbol, exchange, params),
    );
  }

  async getCloudExchangeRate(
    fromCurrency: string,
  ): Promise<CloudMarketResponse<Partial<ExchangeRateSnapshot> & { rate: number }>> {
    return this.request<CloudMarketResponse<Partial<ExchangeRateSnapshot> & { rate: number }>>(
      cloudExchangeRatePath(fromCurrency),
    );
  }

  /**
   * On-demand single-company evidence review. This is a cloud product endpoint,
   * not a market-data capability, so it is called directly instead of routed
   * through the asset-data provider.
   */
  async getCloudEquityDiagnostic(
    symbol: string,
    exchange?: string,
    mode: CloudEquityDiagnosticMode = "cache-first",
  ): Promise<CloudEquityDiagnosticResult> {
    return this.request<CloudEquityDiagnosticResult>(
      "/research/equity-diagnostic",
      {
        method: "POST",
        body: JSON.stringify({
          symbol: symbol.trim().toUpperCase(),
          ...(exchange ? { exchange } : {}),
          mode,
        }),
      },
    );
  }

  async getCloudEconomicCalendar(): Promise<CloudEconEventPayload[]> {
    return this.request<CloudEconEventPayload[]>("/cloud/econ/calendar");
  }

  async getCloudFredSeries(
    seriesId: string,
    params: CloudFredSeriesParams = {},
  ): Promise<CloudFredSeriesPayload> {
    return this.request<CloudFredSeriesPayload>(
      cloudFredSeriesPath(seriesId, params),
    );
  }

  async getCloudShiller(): Promise<CloudShillerPayload> {
    return this.request<CloudShillerPayload>(cloudShillerPath());
  }

  async getCloudCotBoard(report: CotFamily, traderClass: CotClass): Promise<CotBoardPayload> {
    return this.request<CotBoardPayload>(`/cloud/cot/board?${new URLSearchParams({ report, traderClass })}`);
  }

  async getCloudCotContract(code: string, report: CotFamily): Promise<CotContractPayload> {
    return this.request<CotContractPayload>(`/cloud/cot/contracts/${encodeURIComponent(code)}?${new URLSearchParams({ report })}`);
  }

  async getCloudTape(symbol: string, exchange: string, signal?: AbortSignal): Promise<TapeSnapshot> {
    return this.request<TapeSnapshot>(`/cloud/tape/${encodeURIComponent(symbol)}?exchange=${encodeURIComponent(exchange)}`, { signal: signal ?? AbortSignal.timeout(30_000) });
  }

  async getCloudYieldCurve(): Promise<CloudYieldPointPayload[]> {
    return this.request<CloudYieldPointPayload[]>("/cloud/econ/yield-curve");
  }

  async getCloudCryptoMarkets(): Promise<CryptoMarketsPayload> {
    return this.request<CryptoMarketsPayload>("/cloud/crypto/markets", { signal: AbortSignal.timeout(45_000) });
  }

  async getCloudCentralBankRates(): Promise<CentralBankRatesPayload> {
    return this.request<CentralBankRatesPayload>("/cloud/econ/central-bank-rates", { signal: AbortSignal.timeout(45_000) });
  }

  /** Recorded FLOW prints older than the live tape (Pro); the plugin builds `search`. */
  getScannerFlowHistory(search: string, signal?: AbortSignal) {
    return this.request<ScannerFlowHistoryPage>(`/market/scanner/flow/history?${search}`, { signal });
  }

  getMobileAlertHistory<T>(offset = 0) {
    return this.request<T>(`/mobile/alerts/history?offset=${offset}`);
  }

  async getCloudMoneyMarkets(): Promise<MoneyMarketsPayload> {
    return this.request<MoneyMarketsPayload>("/cloud/econ/money-markets", { signal: AbortSignal.timeout(45_000) });
  }

  async getCloudDebtMaturities(symbol: string): Promise<DebtMaturitiesPayload> {
    const params = new URLSearchParams({ symbol });
    return this.request<DebtMaturitiesPayload>(`/cloud/debt-maturities?${params}`, { signal: AbortSignal.timeout(45_000) });
  }

  async getCloudShortVolume(symbol: string, scope: ShortVolumeScope = "nms"): Promise<ShortVolumePayload> {
    const params = new URLSearchParams({ symbol, scope });
    return this.request<ShortVolumePayload>(`/cloud/short-volume?${params}`, { signal: AbortSignal.timeout(20_000) });
  }

  async getCloudFuturesCurve(root: string): Promise<FuturesCurvePayload> {
    return this.request<FuturesCurvePayload>(`/cloud/futures/curve/${encodeURIComponent(root)}`, { signal: AbortSignal.timeout(60_000) });
  }

  async getCloudRatePath(): Promise<RatePathPayload> {
    return this.request<RatePathPayload>("/cloud/econ/rate-path", { signal: AbortSignal.timeout(45_000) });
  }

  async getCloudCds(params: CloudCdsParams = {}): Promise<CloudCdsResponse> {
    return this.request<CloudCdsResponse>(cloudCdsPath(params));
  }

  async getCloudCongressHouse(
    params: CloudCongressHouseParams = {},
    options?: { signal?: AbortSignal },
  ): Promise<CloudCongressHousePayload> {
    return this.request<CloudCongressHousePayload>(
      cloudCongressHousePath(params),
      options,
    );
  }

  async getCloudJobs(ticker: string, name?: string | null): Promise<CloudJobsResponse> {
    return this.request<CloudJobsResponse>(cloudJobsPath(ticker, name));
  }

  async getCloudJobsPostings(
    ticker: string,
    params: CloudJobsPostingsParams = {},
  ): Promise<CloudJobsPostingsPayload> {
    return this.request<CloudJobsPostingsPayload>(cloudJobsPostingsPath(ticker, params));
  }

  async getCloudJobsMovers(limit?: number, offset?: number): Promise<CloudJobsMoversPayload> {
    return this.request<CloudJobsMoversPayload>(cloudJobsMoversPath(limit, offset));
  }

  async getCloudEarningsCalls(
    params: CloudEarningsCallsParams = {},
  ): Promise<CloudEarningsCallListPayload> {
    return this.request<CloudEarningsCallListPayload>(
      cloudEarningsCallsPath(params),
    );
  }

  async getCloudEarningsTranscript(
    id: string,
  ): Promise<CloudEarningsTranscriptPayload> {
    return this.request<CloudEarningsTranscriptPayload>(
      cloudEarningsTranscriptPath(id),
    );
  }

  async getProxyStatements(
    ticker: string,
  ): Promise<CloudProxyStatementListPayload> {
    return this.request<CloudProxyStatementListPayload>(
      publicProxyStatementsPath(ticker),
    );
  }

  async getProxyStatement(
    ticker: string,
    year: number,
  ): Promise<CloudProxyStatementPayload> {
    return this.request<CloudProxyStatementPayload>(
      publicProxyStatementPath(ticker, year),
    );
  }

  async getFilingEvents(
    ticker: string,
    limit?: number,
  ): Promise<{ ticker: string; events: CloudFilingEventPayload[] }> {
    return this.request<{ ticker: string; events: CloudFilingEventPayload[] }>(
      publicFilingEventsPath(ticker, limit),
    );
  }

  async getRiskReports(ticker: string): Promise<CloudRiskReportListPayload> {
    return this.request<CloudRiskReportListPayload>(
      publicRiskReportsPath(ticker),
    );
  }

  async getRiskReport(
    ticker: string,
    year: number,
  ): Promise<CloudRiskReportPayload> {
    return this.request<CloudRiskReportPayload>(
      publicRiskReportPath(ticker, year),
    );
  }

  async getCloudSecFilings(
    params: CloudSecFilingsParams,
  ): Promise<CloudSecFilingsResponse> {
    return this.request<CloudSecFilingsResponse>(cloudSecFilingsPath(params));
  }

  async getCloudSecFilingDocuments(
    params: CloudSecFilingParams,
  ): Promise<CloudSecDocumentsResponse> {
    return this.request<CloudSecDocumentsResponse>(
      cloudSecFilingDocumentsPath(params),
    );
  }

  async getCloudSecFilingContent(
    params: CloudSecFilingParams,
  ): Promise<CloudSecContentResponse> {
    return this.request<CloudSecContentResponse>(
      cloudSecFilingContentPath(params),
    );
  }

  async getCloudSec13F(
    path: string,
    params: Record<string, string | number | undefined> = {},
  ): Promise<unknown> {
    return this.request<unknown>(cloudSec13FPath(path, params));
  }

  /**
   * Cross-document full-text search. Pro-gated: unentitled accounts get a 402,
   * which the caller turns into the access gate rather than an empty result.
   */
  async searchCloudDocuments(
    params: CloudSearchParams,
    options?: { signal?: AbortSignal },
  ): Promise<CloudSearchResponse> {
    return normalizeSearchResponse(
      await this.request<CloudSearchResponse>(cloudSearchPath(params), {
        signal: options?.signal,
      }),
    );
  }

  async getCloudSearchDocument(
    docType: CloudSearchDocType,
    sourceId: string,
    options?: { signal?: AbortSignal },
  ): Promise<CloudSearchDocument> {
    const response = await this.request<CloudSearchDocumentResponse>(
      cloudSearchDocumentPath(docType, sourceId),
      { signal: options?.signal },
    );
    return response.document;
  }

  async getCloudSavedSearches(options?: {
    signal?: AbortSignal;
  }): Promise<CloudSavedSearch[]> {
    const response = await this.request<CloudSavedSearchListResponse>(
      cloudSavedSearchesPath(),
      {
        signal: options?.signal,
      },
    );
    return response.searches ?? [];
  }

  async createCloudSavedSearch(
    input: CloudSavedSearchInput,
  ): Promise<CloudSavedSearch> {
    return normalizeSavedSearchResponse(
      await this.request<unknown>(cloudSavedSearchesPath(), {
        method: "POST",
        body: JSON.stringify(input),
      }),
    );
  }

  async updateCloudSavedSearch(
    id: string,
    update: Partial<CloudSavedSearchInput>,
  ): Promise<CloudSavedSearch> {
    return normalizeSavedSearchResponse(
      await this.request<unknown>(cloudSavedSearchPath(id), {
        method: "PATCH",
        body: JSON.stringify(update),
      }),
    );
  }

  async deleteCloudSavedSearch(id: string): Promise<void> {
    await this.request<void>(cloudSavedSearchPath(id), { method: "DELETE" });
  }

  async getCloudSavedSearchHits(
    id: string,
    options?: { signal?: AbortSignal },
  ): Promise<CloudSearchHit[]> {
    return normalizeSavedSearchHits(
      await this.request<unknown>(cloudSavedSearchHitsPath(id), {
        signal: options?.signal,
      }),
    );
  }

  async getCloudNews(
    params: CloudNewsParams = {},
  ): Promise<CloudNewsListResponse> {
    return this.request<CloudNewsListResponse>(cloudNewsPath(params));
  }

  async getCloudNewsStory(storyId: string): Promise<CloudNewsPayload> {
    return this.request<CloudNewsPayload>(
      `/news/${encodeURIComponent(storyId)}`,
    );
  }

  async getCloudTickerTweets(
    params: CloudTickerTweetsParams,
  ): Promise<CloudTweetSearchResponse> {
    const response = await this.request<CloudTweetSearchResponse>(
      cloudTickerTweetsPath(params),
    );
    return normalizeTweetSearchResponse(response);
  }

  async searchCloudTweets(
    params: CloudTweetSearchParams,
  ): Promise<CloudTweetSearchResponse> {
    const response = await this.request<CloudTweetSearchResponse>(
      cloudTweetSearchPath(params),
    );
    return normalizeTweetSearchResponse(response);
  }
}