import { createHash } from "node:crypto";
import { readFile } from "node:fs/promises";
import dotenv from "dotenv";
import postgres from "postgres";
import {
  buildVip98kModelPresets,
  fetchVip98kModelPresets,
  type Vip98kCatalogModel,
  type Vip98kModelPreset,
} from "../lib/ai/vip98k-models";

dotenv.config({ path: ".env.local" });
dotenv.config();

const KEEP_PROVIDER_TYPES = new Set([
  "vip98k",
  "fal-image",
  "fal-video",
  "tripo-3d",
]);
const REQUIRED_CAPABILITY_MODELS = [
  "nano-banana-2",
  "remove-background",
  "enhance",
  "image-expansion",
  "world-generation",
  "tencent/hunyuan3d-pro/text-to-3d",
  "tencent/hunyuan3d-pro/image-to-3d",
] as const;

type ProviderRow = {
  id: string;
  name: string;
  type: string;
  baseUrl: string;
  apiKey: string;
  isEnabled: boolean;
};

type ModelRow = {
  id: string;
  providerId: string;
  modelId: string;
  displayName: string;
  supportsVision: boolean;
  supportsImageGen: boolean;
  capabilities: unknown;
  imageGenConfig: unknown;
};

function hasFlag(name: string) {
  return process.argv.includes(name);
}

function getArgValue(name: string) {
  const prefix = `${name}=`;
  return process.argv.find((item) => item.startsWith(prefix))?.slice(prefix.length) || "";
}

function stableHash(value: unknown) {
  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
}

function sortById<T extends { id: string }>(rows: T[]) {
  return [...rows].sort((left, right) => left.id.localeCompare(right.id));
}

function isExplicitlyUnavailable(model: Vip98kCatalogModel) {
  return ["disabled", "unavailable", "offline", "removed"].includes(
    String(model.status || "").trim().toLowerCase(),
  );
}

async function loadPresets(apiKey: string): Promise<Vip98kModelPreset[]> {
  const catalogPath = getArgValue("--catalog") || process.env.VIP98K_CATALOG_FILE || "";
  if (catalogPath) {
    const payload = JSON.parse(await readFile(catalogPath, "utf8")) as {
      data?: { models?: Vip98kCatalogModel[] } | Vip98kCatalogModel[];
      models?: Vip98kCatalogModel[];
    };
    const dataModels = Array.isArray(payload.data) ? payload.data : payload.data?.models;
    const models = (dataModels || payload.models || []).filter(
      (model) => !isExplicitlyUnavailable(model),
    );
    if (models.length === 0) throw new Error("VIP98K catalog file contains no models");
    return buildVip98kModelPresets(models);
  }
  return fetchVip98kModelPresets({
    baseURL: process.env.VIP98K_BASE_URL || "https://api.vip98k.com",
    apiKey,
  });
}

function classifyOldModel(model: ModelRow, providerType: string) {
  const serialized = JSON.stringify({
    capabilities: model.capabilities,
    imageGenConfig: model.imageGenConfig,
  }).toLowerCase();
  if (providerType.includes("video") || serialized.includes("video")) return "video";
  if (
    providerType.includes("3d") ||
    serialized.includes("model-3d") ||
    serialized.includes("text-to-3d") ||
    serialized.includes("image-to-3d")
  ) {
    return "model-3d";
  }
  if (providerType.includes("world") || serialized.includes("world-generation")) return "world";
  if (model.supportsImageGen || providerType.includes("image")) return "image";
  return "chat";
}

function chooseTargetModelId(kind: string, presets: Vip98kModelPreset[]) {
  const preferred: Record<string, string[]> = {
    chat: ["gpt-5.4-mini", "gpt-5.4", "claude-sonnet-4-6"],
    image: ["nano-banana-2", "nano-banana-pro", "gpt-image-2-vip"],
    video: ["google/veo-3.1-fast", "google/veo-3.1", "veo-3.1-fast"],
    world: ["world-generation"],
    "model-3d": [
      "tencent/hunyuan3d-pro/image-to-3d",
      "tencent/hunyuan3d-pro/text-to-3d",
    ],
  };
  const candidates = preferred[kind] || preferred.chat;
  const selected = candidates.find((modelId) => presets.some((preset) => preset.modelId === modelId));
  if (selected) return selected;
  const fallbackType = kind === "model-3d" ? "model_3d" : kind === "chat" ? "model" : kind;
  return presets.find((preset) => preset.type === fallbackType)?.modelId || "";
}

function rewriteSettingValue(params: {
  value: unknown;
  oldProviders: Map<string, ProviderRow>;
  oldModels: Map<string, ModelRow>;
  targetProviderId: string;
  targetModelByKind: Record<string, { id: string; modelId: string }>;
  key?: string;
}): unknown {
  const { value, oldProviders, oldModels, targetProviderId, targetModelByKind } = params;
  if (Array.isArray(value)) {
    return value.map((item) => rewriteSettingValue({ ...params, value: item }));
  }
  if (value && typeof value === "object") {
    return Object.fromEntries(
      Object.entries(value as Record<string, unknown>).map(([key, nested]) => [
        key,
        rewriteSettingValue({ ...params, value: nested, key }),
      ]),
    );
  }
  if (typeof value !== "string") return value;

  const oldProvider = oldProviders.get(value);
  if (oldProvider) {
    if (/type/i.test(params.key || "")) return "vip98k";
    if (/name/i.test(params.key || "")) return "VIP98K";
    return targetProviderId;
  }
  const oldModel = oldModels.get(value);
  if (oldModel) {
    const provider = oldProviders.get(oldModel.providerId);
    const kind = classifyOldModel(oldModel, provider?.type || "");
    // A value found in oldModels is a database UUID, regardless of the JSON key name.
    return targetModelByKind[kind]?.id || targetModelByKind.chat.id;
  }
  if (/providerType/i.test(params.key || "")) {
    const oldTypes = new Set(Array.from(oldProviders.values()).map((provider) => provider.type));
    if (oldTypes.has(value)) return "vip98k";
  }
  for (const [kind, target] of Object.entries(targetModelByKind)) {
    const oldRuntimeModel = Array.from(oldModels.values()).find((model) => {
      const provider = oldProviders.get(model.providerId);
      return (
        model.modelId === value && classifyOldModel(model, provider?.type || "") === kind
      );
    });
    if (oldRuntimeModel) return target.modelId;
  }
  return value;
}

function summarizePresets(presets: Vip98kModelPreset[]) {
  return presets.reduce<Record<string, number>>((summary, preset) => {
    const type = String(preset.type || "model");
    summary[type] = (summary[type] || 0) + 1;
    return summary;
  }, {});
}

async function main() {
  const apply = hasFlag("--apply");
  const stage = hasFlag("--stage");
  if (apply && stage) throw new Error("Use either --stage or --apply, not both");
  const databaseUrl = process.env.POSTGRES_URL || "";
  const apiKey = process.env.VIP98K_API_KEY || "";
  if (!databaseUrl) throw new Error("POSTGRES_URL is required");
  if (!apiKey) throw new Error("VIP98K_API_KEY is required and must not be passed on the command line");

  const presets = await loadPresets(apiKey);
  const modelIds = new Set(presets.map((preset) => preset.modelId));
  const missingRequired = REQUIRED_CAPABILITY_MODELS.filter((modelId) => !modelIds.has(modelId));
  const hasVideo = presets.some((preset) => preset.type === "video");
  const hasChat = presets.some((preset) => preset.type === "model");
  if (missingRequired.length > 0 || !hasVideo || !hasChat) {
    throw new Error(
      `VIP98K capability coverage incomplete: ${[
        ...missingRequired,
        ...(!hasVideo ? ["video"] : []),
        ...(!hasChat ? ["multimodal/chat"] : []),
      ].join(", ")}`,
    );
  }

  const sql = postgres(databaseUrl, { prepare: false, max: 1 });
  try {
    const providers = await sql<ProviderRow[]>`select * from "AiProvider" order by "createdAt"`;
    const models = await sql<ModelRow[]>`select * from "AiModel" order by "createdAt"`;
    const falProviders = providers.filter((provider) =>
      ["fal-image", "fal-video"].includes(provider.type),
    );
    const falProviderIds = new Set(falProviders.map((provider) => provider.id));
    const falFingerprintBefore = stableHash({
      providers: sortById(falProviders),
      models: sortById(models.filter((model) => falProviderIds.has(model.providerId))),
    });
    const removableProviders = providers.filter(
      (provider) => !KEEP_PROVIDER_TYPES.has(provider.type),
    );

    console.log(
      JSON.stringify(
        {
          mode: apply ? "apply" : stage ? "stage" : "dry-run",
          vip98kModels: presets.length,
          vip98kByType: summarizePresets(presets),
          falProvidersProtected: falProviders.length,
          falModelsProtected: models.filter((model) => falProviderIds.has(model.providerId)).length,
          providersToRemove: removableProviders.length,
          modelsToRemove: models.filter((model) =>
            removableProviders.some((provider) => provider.id === model.providerId),
          ).length,
        },
        null,
        2,
      ),
    );

    if (!apply && !stage) {
      console.log(
        "Dry run complete. Re-run with --stage to add VIP98K without deleting existing providers.",
      );
      return;
    }

    await sql.begin(async (tx) => {
      const existingVipProviders = providers.filter((provider) => provider.type === "vip98k");
      let targetProviderId = existingVipProviders[0]?.id || "";
      if (targetProviderId) {
        await tx`
          update "AiProvider"
          set name = 'VIP98K', "baseUrl" = 'https://api.vip98k.com', "apiKey" = ${apiKey},
              "isEnabled" = true, "updatedAt" = now()
          where id = ${targetProviderId}::uuid
        `;
      } else {
        const [created] = await tx<{ id: string }[]>`
          insert into "AiProvider" (name, type, "baseUrl", "apiKey", "isEnabled")
          values ('VIP98K', 'vip98k', 'https://api.vip98k.com', ${apiKey}, true)
          returning id
        `;
        targetProviderId = created?.id || "";
      }
      if (!targetProviderId) throw new Error("Failed to create VIP98K provider");

      const modelDbIds = new Map<string, string>();
      for (const preset of presets) {
        const existing = await tx<{ id: string }[]>`
          select id from "AiModel"
          where "providerId" = ${targetProviderId}::uuid and "modelId" = ${preset.modelId}
          order by "createdAt" limit 1
        `;
        const values = {
          description: preset.description,
          capabilities: JSON.stringify(preset.capabilities),
          defaultParams: JSON.stringify(preset.defaultParams),
          imageGenConfig: preset.imageGenConfig ? JSON.stringify(preset.imageGenConfig) : null,
        };
        if (existing[0]) {
          await tx`
            update "AiModel" set
              "displayName" = ${preset.displayName}, description = ${values.description},
              "supportsVision" = ${preset.supportsVision}, "supportsImageGen" = ${preset.supportsImageGen},
              "isEnabled" = true, "isHidden" = ${preset.isHidden}, "sortOrder" = ${preset.sortOrder},
              capabilities = ${values.capabilities}::jsonb, "defaultParams" = ${values.defaultParams}::jsonb,
              "imageGenConfig" = ${values.imageGenConfig}::jsonb, "updatedAt" = now()
            where id = ${existing[0].id}::uuid
          `;
          modelDbIds.set(preset.modelId, existing[0].id);
        } else {
          const [created] = await tx<{ id: string }[]>`
            insert into "AiModel" (
              "providerId", "modelId", "displayName", description, "supportsVision",
              "supportsImageGen", "isEnabled", "isHidden", "sortOrder", capabilities,
              "defaultParams", "imageGenConfig", "isDefault", "isDefaultTextEditModel"
            ) values (
              ${targetProviderId}::uuid, ${preset.modelId}, ${preset.displayName}, ${values.description},
              ${preset.supportsVision}, ${preset.supportsImageGen}, true, ${preset.isHidden},
              ${preset.sortOrder}, ${values.capabilities}::jsonb, ${values.defaultParams}::jsonb,
              ${values.imageGenConfig}::jsonb, false, false
            ) returning id
          `;
          if (!created) throw new Error(`Failed to create VIP98K model ${preset.modelId}`);
          modelDbIds.set(preset.modelId, created.id);
        }
      }

      const targetModelByKind = Object.fromEntries(
        ["chat", "image", "video", "world", "model-3d"].map((kind) => {
          const modelId = chooseTargetModelId(kind, presets);
          const id = modelDbIds.get(modelId) || "";
          if (!id) throw new Error(`No VIP98K target model for ${kind}`);
          return [kind, { id, modelId }];
        }),
      ) as Record<string, { id: string; modelId: string }>;

      if (stage) return;

      await tx`
        update "AiModel" set "isDefault" = false, "isDefaultTextEditModel" = false
        where "providerId" = ${targetProviderId}::uuid
      `;
      await tx`
        update "AiModel" set "isDefault" = true
        where id = ${targetModelByKind.chat.id}::uuid
      `;
      await tx`
        update "AiModel" set "isDefaultTextEditModel" = true,
          "fallbackModelId1" = 'nano-banana-pro', "fallbackModelId2" = 'gpt-image-2-vip'
        where id = ${targetModelByKind.image.id}::uuid
      `;

      const duplicateVipProviders = existingVipProviders.slice(1);
      const replaceableProviders = [...removableProviders, ...duplicateVipProviders];
      const oldProviderMap = new Map(
        replaceableProviders.map((provider) => [provider.id, provider]),
      );
      const oldModels = models.filter((model) => oldProviderMap.has(model.providerId));
      const oldModelMap = new Map(oldModels.map((model) => [model.id, model]));

      if (oldModelMap.size > 0) {
        for (const presetType of ["image", "video", "text"] as const) {
          const target = presetType === "video"
            ? targetModelByKind.video
            : presetType === "image"
              ? targetModelByKind.image
              : targetModelByKind.chat;
          await tx`
            update "AgentPreset" set "defaultModelId" = ${target.id}::uuid, "updatedAt" = now()
            where type = ${presetType}
              and "defaultModelId" = any(${Array.from(oldModelMap.keys())}::uuid[])
          `;
        }
      }

      const settings = await tx<{ id: string; key: string; value: unknown }[]>`
        select id, key, value from "SystemSettings"
      `;
      for (const setting of settings) {
        let nextValue = rewriteSettingValue({
          value: setting.value,
          oldProviders: oldProviderMap,
          oldModels: oldModelMap,
          targetProviderId,
          targetModelByKind,
        });
        if (setting.key === "rmbg_api_config") nextValue = { provider: "vip98k" };
        if (setting.key === "enhance_api_config") {
          nextValue = { provider: "vip98k", type: "clean", scaleFactor: 4 };
        }
        if (setting.key === "extend_api_config") {
          nextValue = { provider: "vip98k", xScale: 1.5, yScale: 1.5 };
        }
        if (setting.key === "worldlabs_key_pool_config") {
          nextValue = { baseUrl: "https://api.vip98k.com", providers: [] };
        }
        if (JSON.stringify(nextValue) !== JSON.stringify(setting.value)) {
          await tx`
            update "SystemSettings" set value = ${JSON.stringify(nextValue)}::jsonb, "updatedAt" = now()
            where id = ${setting.id}::uuid
          `;
        }
      }

      const removableProviderIds = removableProviders.map((provider) => provider.id);
      const duplicateVipProviderIds = duplicateVipProviders.map((provider) => provider.id);
      const deleteIds = [...removableProviderIds, ...duplicateVipProviderIds];
      if (deleteIds.length > 0) {
        await tx`delete from "AiProvider" where id = any(${deleteIds}::uuid[])`;
      }
    });

    const remainingProviders = await sql<ProviderRow[]>`select * from "AiProvider" order by "createdAt"`;
    const remainingModels = await sql<ModelRow[]>`select * from "AiModel" order by "createdAt"`;
    const remainingFalProviders = remainingProviders.filter((provider) =>
      ["fal-image", "fal-video"].includes(provider.type),
    );
    const remainingFalIds = new Set(remainingFalProviders.map((provider) => provider.id));
    const falFingerprintAfter = stableHash({
      providers: sortById(remainingFalProviders),
      models: sortById(
        remainingModels.filter((model) => remainingFalIds.has(model.providerId)),
      ),
    });
    if (falFingerprintAfter !== falFingerprintBefore) {
      throw new Error("FAL provider/model fingerprint changed; restore the verified database backup");
    }
    const invalidTypes = remainingProviders.filter(
      (provider) => !KEEP_PROVIDER_TYPES.has(provider.type),
    );
    if (apply && invalidTypes.length > 0) {
      throw new Error(`Unexpected provider types remain: ${invalidTypes.map((item) => item.type).join(", ")}`);
    }
    console.log(
      JSON.stringify(
        {
          success: true,
          mode: apply ? "apply" : "stage",
          providerTypes: Array.from(new Set(remainingProviders.map((provider) => provider.type))).sort(),
          vip98kModels: remainingModels.filter((model) =>
            remainingProviders.some(
              (provider) => provider.id === model.providerId && provider.type === "vip98k",
            ),
          ).length,
          falFingerprintUnchanged: true,
        },
        null,
        2,
      ),
    );
  } finally {
    await sql.end();
  }
}

main().catch((error) => {
  console.error(error instanceof Error ? error.message : error);
  process.exit(1);
});