import AdmZip from "adm-zip"
import { randomUUID } from "node:crypto"
import { promises as fs } from "node:fs"
import path from "node:path"
import { PrototypeSummary } from "@/lib/prototype"

interface PrototypeRecord {
  id: string
  name: string
  description: string
  entryFile: string
  createdAt: string
}

const DATA_ROOT = path.join(process.cwd(), "data", "prototypes")
const INDEX_FILE = path.join(DATA_ROOT, "index.json")

const MAX_UPLOAD_BYTES = 200 * 1024 * 1024
const MAX_FILES = 20_000
const MAX_UNCOMPRESSED_BYTES = 600 * 1024 * 1024

let writeQueue: Promise<void> = Promise.resolve()

function queueWrite<T>(work: () => Promise<T>): Promise<T> {
  const next = writeQueue.then(work, work)
  writeQueue = next.then(
    () => undefined,
    () => undefined
  )
  return next
}

async function ensureDataRoot() {
  await fs.mkdir(DATA_ROOT, { recursive: true })
}

async function readIndex(): Promise<PrototypeRecord[]> {
  await ensureDataRoot()

  try {
    const raw = await fs.readFile(INDEX_FILE, "utf-8")
    const parsed = JSON.parse(raw)
    if (!Array.isArray(parsed)) {
      return []
    }

    return parsed.filter((item): item is PrototypeRecord => {
      return (
        typeof item?.id === "string" &&
        typeof item?.name === "string" &&
        typeof item?.description === "string" &&
        typeof item?.entryFile === "string" &&
        typeof item?.createdAt === "string"
      )
    })
  } catch (error) {
    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
      return []
    }

    throw error
  }
}

async function writeIndex(records: PrototypeRecord[]) {
  await ensureDataRoot()
  const tempFile = `${INDEX_FILE}.tmp-${Date.now()}-${Math.random().toString(16).slice(2)}`
  await fs.writeFile(tempFile, JSON.stringify(records, null, 2), "utf-8")
  await fs.rename(tempFile, INDEX_FILE)
}

function toSummary(record: PrototypeRecord): PrototypeSummary {
  return {
    ...record,
    viewUrl: `/api/prototypes/${encodeURIComponent(record.id)}/${encodePathSegments(record.entryFile)}`,
  }
}

function generateId() {
  return `proto-${Date.now()}-${randomUUID().slice(0, 8)}`
}

function isPathInside(rootDir: string, candidatePath: string) {
  const root = path.resolve(rootDir)
  const candidate = path.resolve(candidatePath)
  return candidate === root || candidate.startsWith(`${root}${path.sep}`)
}

function sanitizeZipEntry(entryName: string) {
  const normalized = entryName.replace(/\\/g, "/")
  const cleaned = path.posix.normalize(normalized)

  if (!cleaned || cleaned === ".") {
    return null
  }

  if (
    cleaned.startsWith("../") ||
    cleaned === ".." ||
    cleaned.startsWith("/") ||
    /^[A-Za-z]:/.test(cleaned)
  ) {
    throw new Error(`ZIP 中包含非法路径：${entryName}`)
  }

  return cleaned
}

function detectMimeType(filePath: string) {
  const ext = path.extname(filePath).toLowerCase()

  switch (ext) {
    case ".html":
    case ".htm":
      return "text/html; charset=utf-8"
    case ".css":
      return "text/css; charset=utf-8"
    case ".js":
      return "application/javascript; charset=utf-8"
    case ".json":
      return "application/json; charset=utf-8"
    case ".svg":
      return "image/svg+xml"
    case ".png":
      return "image/png"
    case ".jpg":
    case ".jpeg":
      return "image/jpeg"
    case ".gif":
      return "image/gif"
    case ".webp":
      return "image/webp"
    case ".ico":
      return "image/x-icon"
    case ".woff":
      return "font/woff"
    case ".woff2":
      return "font/woff2"
    case ".ttf":
      return "font/ttf"
    default:
      return "application/octet-stream"
  }
}

function encodePathSegments(relativePath: string) {
  return relativePath
    .split("/")
    .map((segment) => encodeURIComponent(segment))
    .join("/")
}

export async function listPrototypes(): Promise<PrototypeSummary[]> {
  const records = await readIndex()
  return records
    .slice()
    .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
    .map(toSummary)
}

export async function findPrototypeById(id: string): Promise<PrototypeSummary | null> {
  const records = await readIndex()
  const found = records.find((item) => item.id === id)
  return found ? toSummary(found) : null
}

export async function createPrototypeFromZip(input: {
  name: string
  description?: string
  zipFileName: string
  zipBuffer: Buffer
}): Promise<PrototypeSummary> {
  return queueWrite(async () => {
    const name = input.name.trim()
    if (!name) {
      throw new Error("原型名称不能为空")
    }

    if (!input.zipFileName.toLowerCase().endsWith(".zip")) {
      throw new Error("仅支持上传 ZIP 文件")
    }

    if (input.zipBuffer.byteLength > MAX_UPLOAD_BYTES) {
      throw new Error("上传文件过大，请控制在 200MB 以内")
    }

    const zip = new AdmZip(input.zipBuffer)
    const entries = zip.getEntries()

    if (!entries.length) {
      throw new Error("ZIP 文件为空")
    }

    if (entries.length > MAX_FILES) {
      throw new Error(`ZIP 文件数量过多（>${MAX_FILES}）`)
    }

    await ensureDataRoot()

    const id = generateId()
    const tempDir = path.join(DATA_ROOT, `.tmp-${id}`)
    const finalDir = path.join(DATA_ROOT, id)

    const extractedFiles: string[] = []
    let totalUncompressed = 0

    await fs.mkdir(tempDir, { recursive: true })

    try {
      for (const entry of entries) {
        const safePath = sanitizeZipEntry(entry.entryName)
        if (!safePath) {
          continue
        }

        const target = path.join(tempDir, ...safePath.split("/"))
        if (!isPathInside(tempDir, target)) {
          throw new Error(`ZIP 中包含非法路径：${entry.entryName}`)
        }

        if (entry.isDirectory) {
          await fs.mkdir(target, { recursive: true })
          continue
        }

        totalUncompressed += entry.header.size
        if (totalUncompressed > MAX_UNCOMPRESSED_BYTES) {
          throw new Error("解压后文件总体积过大")
        }

        await fs.mkdir(path.dirname(target), { recursive: true })
        await fs.writeFile(target, entry.getData())
        extractedFiles.push(safePath)
      }

      const startCandidates = extractedFiles
        .filter(
          (item) =>
            item.toLowerCase().endsWith("/start.html") || item.toLowerCase() === "start.html"
        )
        .sort((a, b) => a.length - b.length)

      if (!startCandidates.length) {
        throw new Error("ZIP 中未找到 start.html")
      }

      const entryFile = startCandidates[0]

      await fs.rm(finalDir, { recursive: true, force: true })
      await fs.rename(tempDir, finalDir)

      const records = await readIndex()
      const record: PrototypeRecord = {
        id,
        name,
        description: input.description?.trim() ?? "",
        createdAt: new Date().toISOString(),
        entryFile,
      }

      records.push(record)
      await writeIndex(records)

      return toSummary(record)
    } catch (error) {
      await fs.rm(tempDir, { recursive: true, force: true })
      throw error
    }
  })
}

export async function deletePrototype(id: string): Promise<boolean> {
  return queueWrite(async () => {
    const records = await readIndex()
    const target = records.find((item) => item.id === id)
    if (!target) {
      return false
    }

    const remained = records.filter((item) => item.id !== id)
    await writeIndex(remained)

    const targetDir = path.join(DATA_ROOT, id)
    if (isPathInside(DATA_ROOT, targetDir)) {
      await fs.rm(targetDir, { recursive: true, force: true })
    }

    return true
  })
}

export async function readPrototypeFile(id: string, relativePath?: string) {
  const records = await readIndex()
  const target = records.find((item) => item.id === id)

  if (!target) {
    return null
  }

  const requested = relativePath?.trim() ? relativePath : target.entryFile
  const normalized = sanitizeZipEntry(requested)

  if (!normalized) {
    return null
  }

  const filePath = path.join(DATA_ROOT, id, ...normalized.split("/"))

  if (!isPathInside(path.join(DATA_ROOT, id), filePath)) {
    return null
  }

  try {
    const stat = await fs.stat(filePath)
    if (!stat.isFile()) {
      return null
    }

    const content = await fs.readFile(filePath)

    return {
      content,
      mimeType: detectMimeType(filePath),
      size: stat.size,
      lastModified: stat.mtime.toUTCString(),
    }
  } catch (error) {
    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
      return null
    }

    throw error
  }
}