import express, {
  type Express,
  type NextFunction,
  type Request,
  type Response,
} from "express";
import {
  paymentMiddleware,
  x402ResourceServer,
} from "@okxweb3/x402-express";
import { ExactEvmScheme } from "@okxweb3/x402-evm/exact/server";
import { OKXFacilitatorClient } from "@okxweb3/x402-core";
import { buildCatalog } from "./catalog.js";
import { CHAIN_ID, PRICE_USD } from "./config.js";
import {
  buildPreIpo,
  buildPreview,
  buildRunners,
  buildSignal,
  buildUniverse,
} from "./intel/builders.js";
import {
  validatePreIpoInput,
  validateRunnersInput,
  validateSignalInput,
} from "./intel/input.js";
import type { UniverseProvider } from "./intel/types.js";
import { isNyseOpen } from "./core/rules/marketHours.js";
import { log } from "./log.js";
import type { PaymentScanState } from "./payments.js";

export interface FakeFacilitator {
  getSupported(): Promise<unknown>;
  verify(): Promise<unknown>;
  settle(): Promise<unknown>;
}

export function challengeOnlyFacilitator(network: string): FakeFacilitator {
  return {
    async getSupported() {
      return {
        kinds: [
          {
            x402Version: 2,
            scheme: "exact",
            network: network as `${string}:${string}`,
          },
        ],
        extensions: [],
        signers: {},
      };
    },
    async verify() {
      throw new Error("payments not configured");
    },
    async settle() {
      throw new Error("payments not configured");
    },
  };
}

export interface AppDeps {
  env: {
    NETWORK: string;
    PAY_TO: string;
    PUBLIC_API_BASE_URL: string;
    WEB_ORIGIN: string;
  };
  universe: UniverseProvider;
  facilitator?: { apiKey: string; secretKey: string; passphrase: string } | FakeFacilitator;
  syncFacilitatorOnStart?: boolean;
  payments?: () => PaymentScanState;
}

const startedAt = Date.now();

export function createApp(deps: AppDeps): Express {
  const app = express();
  app.set("trust proxy", true);
  app.use(express.json());
  app.use((req: Request, res: Response, next: NextFunction) => {
    res.setHeader("access-control-allow-origin", deps.env.WEB_ORIGIN);
    res.setHeader("access-control-allow-methods", "GET, POST, OPTIONS");
    res.setHeader(
      "access-control-allow-headers",
      "content-type, payment-signature, x-payment",
    );
    res.setHeader(
      "access-control-expose-headers",
      "PAYMENT-REQUIRED, PAYMENT-RESPONSE",
    );
    if (req.method === "OPTIONS") {
      res.sendStatus(204);
      return;
    }
    next();
  });
  app.use((req: Request, _res: Response, next: NextFunction) => {
    log("info", "request", { method: req.method, path: req.path });
    next();
  });

  app.get("/health", (_req, res) => {
    const market = isNyseOpen(new Date());
    const universe = deps.universe.status?.() ?? {
      ready: deps.universe.snapshot() !== null,
      perps: 0,
      spots: 0,
      preIpo: 0,
      candlesRefreshedAt: null,
      tickersRefreshedAt: null,
    };
    res.json({
      status: "ok",
      service: "UltraX",
      network: deps.env.NETWORK,
      payTo: deps.env.PAY_TO,
      paymentsConfigured: Boolean(
        deps.facilitator && "apiKey" in deps.facilitator,
      ),
      universe,
      usMarketOpen: market.open,
      uptime: Math.floor((Date.now() - startedAt) / 1000),
    });
  });

  app.get("/catalog", (_req, res) => {
    res.json(
      buildCatalog(
        deps.env.PUBLIC_API_BASE_URL,
        deps.env.NETWORK,
        deps.env.PAY_TO,
      ),
    );
  });

  app.get("/universe", (_req, res) => {
    const snapshot = deps.universe.snapshot();
    if (!snapshot) {
      res.status(503).json({ error: "universe warming up" });
      return;
    }
    res.json(buildUniverse(snapshot));
  });

  app.get("/preview", async (_req, res) => {
    const snapshot = deps.universe.snapshot();
    if (!snapshot) {
      res.status(503).json({ error: "universe warming up" });
      return;
    }
    res.json(await buildPreview(snapshot));
  });

  app.get("/payments/recent", (req, res) => {
    const requestedLimit = Number(req.query.limit ?? 20);
    const limit = Math.min(
      Number.isFinite(requestedLimit) ? Math.max(1, requestedLimit) : 20,
      50,
    );
    const snap = deps.payments?.() ?? {
      warming: false,
      scannedFrom: null,
      lastScanned: null,
      payments: [],
    };
    const recent = snap.payments.filter(
      (payment) => payment.timestamp >= Date.now() - 86_400_000,
    );
    res.json({
      payTo: deps.env.PAY_TO,
      count24h: recent.length,
      totalUsd24h:
        Math.round(
          recent.reduce((sum, payment) => sum + payment.amountUsd, 0) * 100,
        ) / 100,
      warming: snap.warming,
      scannedFrom: snap.scannedFrom,
      lastScanned: snap.lastScanned,
      payments: snap.payments.slice(0, limit),
    });
  });

  const respondValidation = (
    res: Response,
    validation:
      | { ok: true }
      | { ok: false; error: string }
      | { ok: false; missing: string[]; required: unknown },
  ) => {
    if (validation.ok) return false;
    if ("missing" in validation) {
      res.status(400).json({
        status: "input_required",
        missing: validation.missing,
        required: validation.required,
      });
      return true;
    }
    const hint = validation.error.includes("symbol")
      ? { hint: "GET /universe" }
      : {};
    res.status(400).json({ error: validation.error, ...hint });
    return true;
  };

  app.post("/runners", (req, res, next) => {
    const validation = validateRunnersInput(req.body);
    if (respondValidation(res, validation)) return;
    if (!deps.universe.snapshot()) {
      res.status(503).json({ error: "universe warming up" });
      return;
    }
    next();
  });
  app.post("/signal", (req, res, next) => {
    const snapshot = deps.universe.snapshot();
    const validation = validateSignalInput(req.body, snapshot ?? undefined);
    if (respondValidation(res, validation)) return;
    if (!snapshot) {
      res.status(503).json({ error: "universe warming up" });
      return;
    }
    next();
  });
  app.post("/preipo", (req, res, next) => {
    const snapshot = deps.universe.snapshot();
    const validation = validatePreIpoInput(req.body, snapshot ?? undefined);
    if (respondValidation(res, validation)) return;
    if (!snapshot) {
      res.status(503).json({ error: "universe warming up" });
      return;
    }
    next();
  });

  const usingRealFacilitator = Boolean(
    deps.facilitator && "apiKey" in deps.facilitator,
  );
  const facilitator = usingRealFacilitator
    ? new OKXFacilitatorClient({
        ...(deps.facilitator as {
          apiKey: string;
          secretKey: string;
          passphrase: string;
        }),
        syncSettle: true,
      })
    : ((deps.facilitator as FakeFacilitator | undefined) ??
      challengeOnlyFacilitator(deps.env.NETWORK));
  const paymentServer = new x402ResourceServer(
    facilitator as unknown as ConstructorParameters<typeof x402ResourceServer>[0],
  ).register(
    deps.env.NETWORK as `${string}:${string}`,
    new ExactEvmScheme(),
  );
  paymentServer.onAfterSettle(async (ctx) => {
    const result = ctx.result as {
      transaction?: string;
      payer?: string;
      amount?: string;
    };
    log("info", "payment settled", {
      txHash: result.transaction,
      payer: result.payer,
      amount: result.amount,
    });
  });
  if (!usingRealFacilitator) {
    log("warn", "payments cannot be verified; 402 challenges still issued", {
      job: "x402",
    });
  }
  app.use(
    paymentMiddleware(
      {
        "POST /runners": {
          accepts: [
            {
              scheme: "exact",
              network: deps.env.NETWORK as `${string}:${string}`,
              payTo: deps.env.PAY_TO as `0x${string}`,
              price: `$${PRICE_USD.runners}`,
            },
          ],
          description: "OKX stock market runners",
          mimeType: "application/json",
        },
        "POST /signal": {
          accepts: [
            {
              scheme: "exact",
              network: deps.env.NETWORK as `${string}:${string}`,
              payTo: deps.env.PAY_TO as `0x${string}`,
              price: `$${PRICE_USD.signal}`,
            },
          ],
          description: "OKX stock predictive intelligence signal",
          mimeType: "application/json",
        },
        "POST /preipo": {
          accepts: [
            {
              scheme: "exact",
              network: deps.env.NETWORK as `${string}:${string}`,
              payTo: deps.env.PAY_TO as `0x${string}`,
              price: `$${PRICE_USD.preipo}`,
            },
          ],
          description: "OKX stock pre-IPO intelligence",
          mimeType: "application/json",
        },
      },
      paymentServer,
      undefined,
      undefined,
      deps.syncFacilitatorOnStart ?? true,
    ),
  );

  app.post("/runners", (req: Request, res: Response) => {
    const validation = validateRunnersInput(req.body);
    const snapshot = deps.universe.snapshot();
    if (!validation.ok || !snapshot) {
      res.status(503).json({ error: "universe warming up" });
      return;
    }
    res.json(buildRunners(snapshot, validation.value));
  });
  app.post("/signal", async (req: Request, res: Response) => {
    const snapshot = deps.universe.snapshot();
    if (!snapshot) {
      res.status(503).json({ error: "universe warming up" });
      return;
    }
    const validation = validateSignalInput(req.body, snapshot);
    if (!validation.ok) {
      respondValidation(res, validation);
      return;
    }
    try {
      res.json(
        await buildSignal(
          snapshot,
          validation.value.symbol,
          validation.value.period,
          (instId) => deps.universe.positioning(instId),
          deps.universe.orderBook
            ? (instId) => deps.universe.orderBook!(instId)
            : undefined,
        ),
      );
    } catch (error) {
      log("error", "signal failed", { err: String(error) });
      res.status(503).json({ error: "signal unavailable" });
    }
  });
  app.post("/preipo", async (req: Request, res: Response) => {
    const snapshot = deps.universe.snapshot();
    if (!snapshot) {
      res.status(503).json({ error: "universe warming up" });
      return;
    }
    const validation = validatePreIpoInput(req.body, snapshot);
    if (!validation.ok) {
      respondValidation(res, validation);
      return;
    }
    try {
      res.json(
        await buildPreIpo(
          snapshot,
          validation.value.symbol,
          deps.universe.orderBook
            ? (instId) => deps.universe.orderBook!(instId)
            : undefined,
        ),
      );
    } catch (error) {
      log("error", "pre-IPO request failed", { err: String(error) });
      res.status(503).json({ error: "pre-IPO data unavailable" });
    }
  });

  return app;
}