import { readFile } from "node:fs/promises";
import { join } from "node:path";
import * as z from "zod";

import { getDb } from "@/db/client";
import {
  catalogArtifacts,
  catalogCharacters,
  catalogWeapons,
} from "@/db/schema";
import {
  avatarIconName,
  characterDetailSchema,
  constellationSnapshot,
  nameCardImageName,
  splashImageName,
  talentSnapshot,
} from "@/lib/catalog/lunaris";
import type {
  CatalogConstellation,
  CatalogTalent,
} from "@/lib/catalog/lunaris";
import { customTravelers, isUpstreamTraveler } from "@/lib/catalog/travelers";
import { withCatalogSyncLock } from "@/lib/catalog/sync-lock";
import {
  compareLunarisVersions,
  lunarisVersionSchema,
} from "@/lib/catalog/version";
import { getMediaStorage } from "@/lib/media/storage";

const VERSION_URL = "https://api.lunaris.moe/data/version.json";
const API_ROOT = "https://api.lunaris.moe/data";

const versionSchema = z.object({
  version: lunarisVersionSchema,
  timestamp: z.number().int().optional(),
});
const currentVersionSchema = z.object({ version: lunarisVersionSchema });
const characterSchema = z.record(
  z.string(),
  z.object({
    enName: z.string(),
    CardImg: z.string(),
    element: z.string().optional(),
    qualityType: z.string().optional(),
    weaponType: z.string().optional(),
  }),
);
const weaponSchema = z.record(
  z.string(),
  z.object({
    enName: z.string(),
    weaponIcon: z.string(),
    qualityType: z.string().optional(),
    weaponType: z.string().optional(),
  }),
);
const artifactSchema = z.record(
  z.string(),
  z.object({
    enName: z.string(),
    setIcon: z.string(),
    qualityType: z.string().optional(),
  }),
);

interface SyncedCharacter {
  key: string;
  name: string;
  element: string | null;
  rarity: number | null;
  weaponType: string | null;
  imageKey: string;
  elementIconKey: string | null;
  splashImageKey: string | null;
  nameCardImageKey: string | null;
  sourceImage: string | null;
  splashSourceImage: string | null;
  nameCardSourceImage: string | null;
  localImage: string | null;
  constellations: CatalogConstellation[];
  talents: CatalogTalent[];
}

async function getJson(url: string): Promise<unknown> {
  const response = await fetch(url, {
    signal: AbortSignal.timeout(30_000),
    cache: "no-store",
  });
  if (!response.ok)
    throw new Error(`Lunaris returned ${response.status} for ${url}`);
  return response.json();
}

async function getOptionalJson(url: string): Promise<unknown | null> {
  const response = await fetch(url, {
    signal: AbortSignal.timeout(30_000),
    cache: "no-store",
  });
  if (response.status === 404) return null;
  if (!response.ok)
    throw new Error(`Lunaris returned ${response.status} for ${url}`);
  return response.json();
}

function webpName(value: string): string {
  return value.endsWith(".webp") ? value : `${value}.webp`;
}

function rarity(value: string | undefined): number | null {
  if (!value) return null;
  return (
    {
      QUALITY_WHITE: 1,
      QUALITY_GREEN: 2,
      QUALITY_BLUE: 3,
      QUALITY_PURPLE: 4,
      QUALITY_ORANGE: 5,
    }[value] ?? null
  );
}

export async function getLatestLunarisVersion(): Promise<string> {
  return versionSchema.parse(await getJson(VERSION_URL)).version;
}

async function mapConcurrent<T, R>(
  items: T[],
  task: (item: T) => Promise<R>,
): Promise<R[]> {
  const results = new Array<R>(items.length);
  let next = 0;
  async function worker() {
    while (next < items.length) {
      const index = next++;
      results[index] = await task(items[index]);
    }
  }
  await Promise.all(
    Array.from({ length: Math.min(4, items.length) }, () => worker()),
  );
  return results;
}

async function uploadAssets(
  assets: Array<{
    source?: string;
    body?: Uint8Array;
    target: string;
    type?: string;
  }>,
): Promise<Set<string>> {
  const storage = await getMediaStorage();
  let next = 0;
  const missing = new Set<string>();
  async function worker() {
    while (next < assets.length) {
      const asset = assets[next++];
      if (!(await storage.file(asset.target).exists())) {
        if (asset.body) {
          await storage.write(asset.target, asset.body, {
            type: asset.type ?? "image/webp",
            acl: "public-read",
          });
        } else {
          const response = await fetch(asset.source!, {
            signal: AbortSignal.timeout(30_000),
            cache: "no-store",
          });
          if (response.status === 404) missing.add(asset.target);
          else if (!response.ok)
            throw new Error(`Asset returned ${response.status}: ${asset.source}`);
          else
            await storage.write(asset.target, response, {
              type: asset.type ?? "image/webp",
              acl: "public-read",
            });
        }
      }
    }
  }
  await Promise.all(
    Array.from({ length: Math.min(4, assets.length) }, () => worker()),
  );
  return missing;
}

async function syncCatalogVersion(version: string): Promise<void> {
  const [charactersRaw, weaponsRaw, artifactsRaw] = await Promise.all([
      getJson(`${API_ROOT}/${version}/charlist.json`),
      getJson(`${API_ROOT}/${version}/weaponlist.json`),
      getJson(`${API_ROOT}/${version}/artifactlist.json`),
    ]);
  const characterData = characterSchema.parse(charactersRaw);
  const weaponData = weaponSchema.parse(weaponsRaw);
  const artifactData = artifactSchema.parse(artifactsRaw);

  const remoteCharacters: SyncedCharacter[] = await mapConcurrent(
      Object.entries(characterData).filter(
        ([, value]) =>
          value.enName &&
          value.enName !== "???" &&
          !isUpstreamTraveler(value.enName) &&
          value.CardImg,
      ),
      async ([key, value]) => {
        const detailRaw = await getOptionalJson(
          `${API_ROOT}/${version}/en/char/${encodeURIComponent(key)}.json`,
        );
        const detail = detailRaw
          ? characterDetailSchema.parse(detailRaw)
          : null;
        const avatarIcon = webpName(avatarIconName(value.CardImg));
        const splashImage = splashImageName(value.CardImg);
        const nameCardImage = nameCardImageName(value.CardImg);
        const element = detail?.info?.element ?? value.element ?? null;
        return {
          key,
          name: value.enName,
          element,
          rarity: rarity(value.qualityType),
          weaponType: detail?.info?.weapon ?? value.weaponType ?? null,
          imageKey: `catalog/characters/avatar/${avatarIcon}`,
          elementIconKey: element
            ? `catalog/elements/${element.toLowerCase()}.png`
            : null,
          splashImageKey: `catalog/characters/splash/${splashImage}`,
          nameCardImageKey: `catalog/characters/namecard/${nameCardImage}`,
          sourceImage: `${API_ROOT}/assets/avataricon/${encodeURIComponent(avatarIcon)}`,
          splashSourceImage: `${API_ROOT}/assets/gachaimg/${encodeURIComponent(splashImage)}`,
          nameCardSourceImage: `${API_ROOT}/assets/namecardpic/${encodeURIComponent(nameCardImage)}`,
          localImage: null,
          constellations: detail
            ? constellationSnapshot(
                detail,
                (icon) => `catalog/characters/constellations/${webpName(icon)}`,
              )
            : [],
          talents: detail
            ? talentSnapshot(
                detail,
                (icon) => `catalog/characters/talents/${webpName(icon)}`,
              )
            : [],
        };
      },
  );
    const customCharacters: SyncedCharacter[] = await mapConcurrent(
      [...customTravelers],
      async (traveler) => {
        const detail = characterDetailSchema.parse(
          await getJson(
            `${API_ROOT}/${version}/en/char/${traveler.detailKey}.json`,
          ),
        );
        return {
          key: traveler.key,
          name: traveler.name,
          element: traveler.element,
          rarity: traveler.rarity,
          weaponType: "WEAPON_SWORD_ONE_HAND",
          imageKey: `catalog/characters/avatar/${traveler.asset}`,
          elementIconKey: `catalog/elements/${traveler.element.toLowerCase()}.png`,
          splashImageKey: null,
          nameCardImageKey: null,
          sourceImage: null,
          splashSourceImage: null,
          nameCardSourceImage: null,
          localImage: traveler.asset,
          constellations: constellationSnapshot(
            detail,
            (icon) => `catalog/characters/constellations/${webpName(icon)}`,
          ),
          talents: talentSnapshot(
            detail,
            (icon) => `catalog/characters/talents/${webpName(icon)}`,
          ),
        };
      },
    );
    let characters = [...remoteCharacters, ...customCharacters];
    let weapons = Object.entries(weaponData)
      .filter(
        ([, value]) =>
          value.enName && value.enName !== "???" && value.weaponIcon,
      )
      .map(([key, value]) => ({
        key,
        name: value.enName,
        rarity: rarity(value.qualityType),
        weaponType: value.weaponType ?? null,
        imageKey: `catalog/weapons/${webpName(value.weaponIcon)}`,
        sourceImage: `${API_ROOT}/assets/weaponicon/${encodeURIComponent(webpName(value.weaponIcon))}`,
      }));
    let artifacts = Object.entries(artifactData)
      .filter(
        ([, value]) => value.enName && value.enName !== "???" && value.setIcon,
      )
      .map(([key, value]) => ({
        key,
        name: value.enName,
        rarity: rarity(value.qualityType),
        imageKey: `catalog/artifacts/${webpName(value.setIcon)}`,
        sourceImage: `${API_ROOT}/assets/artifacts/${encodeURIComponent(webpName(value.setIcon))}`,
      }));
    const uniqueAssets = new Map<
      string,
      { source?: string; body?: Uint8Array; target: string; type?: string }
    >();
    for (const character of characters) {
      uniqueAssets.set(
        character.imageKey,
        character.localImage
          ? {
              body: await readFile(
                join(process.cwd(), "lib/catalog/assets", character.localImage),
              ),
              target: character.imageKey,
            }
          : { source: character.sourceImage!, target: character.imageKey },
      );
      if (character.splashImageKey && character.splashSourceImage) {
        uniqueAssets.set(character.splashImageKey, {
          source: character.splashSourceImage,
          target: character.splashImageKey,
          type: "image/png",
        });
      }
      if (character.nameCardImageKey && character.nameCardSourceImage) {
        uniqueAssets.set(character.nameCardImageKey, {
          source: character.nameCardSourceImage,
          target: character.nameCardImageKey,
          type: "image/png",
        });
      }
    }
    for (const item of [...weapons, ...artifacts])
      uniqueAssets.set(item.imageKey, {
        source: item.sourceImage,
        target: item.imageKey,
      });
    for (const character of characters) {
      if (character.elementIconKey && character.element)
        uniqueAssets.set(character.elementIconKey, {
          source: `${API_ROOT}/assets/icons/${encodeURIComponent(character.element.toLowerCase())}.png`,
          target: character.elementIconKey,
          type: "image/png",
        });
    }
    for (const character of characters) {
      for (const constellation of character.constellations) {
        if (constellation.iconKey)
          uniqueAssets.set(constellation.iconKey, {
            source: `${API_ROOT}/assets/skills/${encodeURIComponent(constellation.iconKey.split("/").at(-1)!)}`,
            target: constellation.iconKey,
          });
      }
      for (const talent of character.talents) {
        if (talent.iconKey)
          uniqueAssets.set(talent.iconKey, {
            source: `${API_ROOT}/assets/skills/${encodeURIComponent(talent.iconKey.split("/").at(-1)!)}`,
            target: talent.iconKey,
          });
      }
    }
    const missingAssets = await uploadAssets([...uniqueAssets.values()]);
    characters = characters.filter((item) => !missingAssets.has(item.imageKey));
    characters = characters.map((item) => ({
      ...item,
      elementIconKey:
        item.elementIconKey && !missingAssets.has(item.elementIconKey)
          ? item.elementIconKey
          : null,
      splashImageKey:
        item.splashImageKey && !missingAssets.has(item.splashImageKey)
          ? item.splashImageKey
          : null,
      nameCardImageKey:
        item.nameCardImageKey && !missingAssets.has(item.nameCardImageKey)
          ? item.nameCardImageKey
          : null,
      constellations: item.constellations.map((constellation) => ({
        ...constellation,
        iconKey:
          constellation.iconKey && !missingAssets.has(constellation.iconKey)
            ? constellation.iconKey
            : null,
      })),
      talents: item.talents.map((talent) => ({
        ...talent,
        iconKey:
          talent.iconKey && !missingAssets.has(talent.iconKey)
            ? talent.iconKey
            : null,
      })),
    }));
    weapons = weapons.filter((item) => !missingAssets.has(item.imageKey));
    artifacts = artifacts.filter((item) => !missingAssets.has(item.imageKey));

    const storage = await getMediaStorage();
    await Promise.all([
      storage.write(
        "catalog/characters.json",
        JSON.stringify(
          characters.map((item) => ({
            key: item.key,
            name: item.name,
            element: item.element,
            rarity: item.rarity,
            weaponType: item.weaponType,
            imageKey: item.imageKey,
            elementIconKey: item.elementIconKey,
            splashImageKey: item.splashImageKey,
            nameCardImageKey: item.nameCardImageKey,
            constellations: item.constellations,
            talents: item.talents,
          })),
        ),
        { type: "application/json", acl: "public-read" },
      ),
      storage.write(
        "catalog/weapons.json",
        JSON.stringify(
          weapons.map((item) => ({
            key: item.key,
            name: item.name,
            rarity: item.rarity,
            weaponType: item.weaponType,
            imageKey: item.imageKey,
          })),
        ),
        { type: "application/json", acl: "public-read" },
      ),
      storage.write(
        "catalog/artifacts.json",
        JSON.stringify(
          artifacts.map((item) => ({
            key: item.key,
            name: item.name,
            rarity: item.rarity,
            imageKey: item.imageKey,
          })),
        ),
        { type: "application/json", acl: "public-read" },
      ),
    ]);

    await getDb().transaction(async (tx) => {
      await tx.delete(catalogCharacters);
      await tx.delete(catalogWeapons);
      await tx.delete(catalogArtifacts);
      if (characters.length)
        await tx
          .insert(catalogCharacters)
          .values(
            characters.map((item) => ({
              key: item.key,
              name: item.name,
              element: item.element,
              rarity: item.rarity,
              weaponType: item.weaponType,
              imageKey: item.imageKey,
              elementIconKey: item.elementIconKey,
              coopImageKey: item.splashImageKey,
              nameCardImageKey: item.nameCardImageKey,
              constellations: item.constellations,
              talents: item.talents,
            })),
          );
      if (weapons.length)
        await tx
          .insert(catalogWeapons)
          .values(
            weapons.map((item) => ({
              key: item.key,
              name: item.name,
              rarity: item.rarity,
              weaponType: item.weaponType,
              imageKey: item.imageKey,
            })),
          );
      if (artifacts.length)
        await tx
          .insert(catalogArtifacts)
          .values(
            artifacts.map((item) => ({
              key: item.key,
              name: item.name,
              rarity: item.rarity,
              imageKey: item.imageKey,
            })),
          );
    });
  await storage.write("catalog/current.json", JSON.stringify({ version }), {
    type: "application/json",
    acl: "public-read",
  });
}

export type CatalogSyncResult = "synced" | "unchanged";

export async function getCurrentCatalogVersion(): Promise<string | null> {
  const storage = await getMediaStorage();
  const current = storage.file("catalog/current.json");
  if (!(await current.exists())) return null;
  return currentVersionSchema.parse(await current.json()).version;
}

export async function processCatalogSync(
  requestedVersion?: string,
): Promise<CatalogSyncResult> {
  const version = lunarisVersionSchema.parse(
    requestedVersion ?? (await getLatestLunarisVersion()),
  );

  return withCatalogSyncLock(async () => {
    const currentVersion = await getCurrentCatalogVersion();
    if (
      currentVersion &&
      compareLunarisVersions(version, currentVersion) <= 0
    ) {
      return "unchanged";
    }
    await syncCatalogVersion(version);
    return "synced";
  });
}