import type { MarketSnapshot, Period } from "./types.js";
import { resolveSymbol } from "./symbols.js";

export const INPUT_SCHEMAS = {
  runners: {
    period: { type: "string", enum: ["daily", "weekly", "monthly"] },
    market: { type: "string", enum: ["perp", "spot"], default: "perp" },
    direction: { type: "string", enum: ["up", "down"], default: "up" },
    limit: { type: "integer", min: 1, max: 50, default: 10 },
    minVolumeUsd: { type: "number", min: 0, default: 100000 },
  },
  signal: {
    symbol: { type: "string", required: true },
    period: {
      type: "string",
      enum: ["daily", "weekly", "monthly"],
      default: "weekly",
    },
  },
  preipo: {
    symbol: { type: "string", required: false },
  },
} as const;

export interface RunnerInput {
  period: Period;
  market: "perp" | "spot";
  direction: "up" | "down";
  limit: number;
  minVolumeUsd: number;
}

export interface SignalInput {
  symbol: string;
  period: Period;
}

type Validation<T> =
  | { ok: true; value: T }
  | { ok: false; error: string }
  | { ok: false; missing: string[]; required: unknown };

function recordBody(value: unknown): Record<string, unknown> {
  if (!value || typeof value !== "object" || Array.isArray(value)) return {};
  return value as Record<string, unknown>;
}

function unknownKeys(
  body: Record<string, unknown>,
  accepted: string[],
): string | null {
  const unknown = Object.keys(body).find((key) => !accepted.includes(key));
  return unknown ? `unknown field: ${unknown}` : null;
}

function periodValue(value: unknown): value is Period {
  return value === "daily" || value === "weekly" || value === "monthly";
}

export function validateRunnersInput(input: unknown): Validation<RunnerInput> {
  const body = recordBody(input);
  if (body.period === undefined) {
    return {
      ok: false,
      missing: ["period"],
      required: INPUT_SCHEMAS.runners,
    };
  }
  const extra = unknownKeys(body, [
    "period",
    "market",
    "direction",
    "limit",
    "minVolumeUsd",
  ]);
  if (extra) return { ok: false, error: extra };
  if (!periodValue(body.period)) {
    return { ok: false, error: "period must be daily, weekly, or monthly" };
  }
  const market = body.market ?? "perp";
  if (market !== "perp" && market !== "spot") {
    return { ok: false, error: "market must be perp or spot" };
  }
  const direction = body.direction ?? "up";
  if (direction !== "up" && direction !== "down") {
    return { ok: false, error: "direction must be up or down" };
  }
  const limit = body.limit ?? 10;
  if (
    typeof limit !== "number" ||
    !Number.isInteger(limit) ||
    limit < 1 ||
    limit > 50
  ) {
    return { ok: false, error: "limit must be an integer from 1 to 50" };
  }
  const minVolumeUsd = body.minVolumeUsd ?? 100_000;
  if (
    typeof minVolumeUsd !== "number" ||
    !Number.isFinite(minVolumeUsd) ||
    minVolumeUsd < 0
  ) {
    return { ok: false, error: "minVolumeUsd must be a non-negative number" };
  }
  return {
    ok: true,
    value: { period: body.period, market, direction, limit, minVolumeUsd },
  };
}

export function validateSignalInput(
  input: unknown,
  snapshot?: MarketSnapshot,
): Validation<SignalInput> {
  const body = recordBody(input);
  if (body.symbol === undefined) {
    return {
      ok: false,
      missing: ["symbol"],
      required: INPUT_SCHEMAS.signal,
    };
  }
  const extra = unknownKeys(body, ["symbol", "period"]);
  if (extra) return { ok: false, error: extra };
  if (typeof body.symbol !== "string" || !body.symbol.trim()) {
    return { ok: false, error: "symbol must be a non-empty string" };
  }
  const period = body.period ?? "weekly";
  if (!periodValue(period)) {
    return { ok: false, error: "period must be daily, weekly, or monthly" };
  }
  if (snapshot && !resolveSymbol(body.symbol, snapshot)) {
    return {
      ok: false,
      error: `unknown symbol: ${body.symbol}`,
    };
  }
  return { ok: true, value: { symbol: body.symbol, period } };
}

export function validatePreIpoInput(
  input: unknown,
  snapshot?: MarketSnapshot,
): Validation<{ symbol?: string }> {
  const body = recordBody(input);
  const extra = unknownKeys(body, ["symbol"]);
  if (extra) return { ok: false, error: extra };
  if (body.symbol === undefined) return { ok: true, value: {} };
  if (typeof body.symbol !== "string" || !body.symbol.trim()) {
    return { ok: false, error: "symbol must be a non-empty string" };
  }
  if (snapshot) {
    const resolved = resolveSymbol(body.symbol, snapshot);
    if (!resolved || resolved.market !== "perp" || !resolved.instrument.preIpo) {
      return {
        ok: false,
        error: `symbol is not a pre-IPO contract: ${body.symbol}`,
      };
    }
  }
  return { ok: true, value: { symbol: body.symbol } };
}