import http from "node:http"
import { readFile, mkdir, writeFile, rm } from "node:fs/promises"
import { createReadStream, existsSync } from "node:fs"
import { extname, join, normalize } from "node:path"
import { execFile } from "node:child_process"
import { randomUUID } from "node:crypto"
import { promisify } from "node:util"
import mysql from "mysql2/promise"

const execFileAsync = promisify(execFile)

const DB = {
  host: process.env.DB_HOST || "127.0.0.1",
  port: Number(process.env.DB_PORT || 3306),
  user: process.env.DB_USER || "photoprism",
  password: process.env.DB_PASSWORD || "",
  database: process.env.DB_NAME || "photoprism",
  connectionLimit: 4,
}

const PORT = Number(process.env.PORT || 3100)
const PUBLIC = join(process.cwd(), "public")
const MIN_PATH = 3

const STAGING_ROOT = process.env.STAGING_ROOT || join(process.cwd(), "staging")
const PHOTOPRISM_BIN = process.env.PHOTOPRISM_BIN || "photoprism"
const PHOTOPRISM_USER = process.env.PHOTOPRISM_USER || "photoprism"
const PHOTOPRISM_HOME = process.env.PHOTOPRISM_HOME || "/srv/photoprism"
const ORIGINALS_PATH = process.env.PHOTOPRISM_ORIGINALS_PATH || "/srv/photoprism/originals"
const STORAGE_PATH = process.env.PHOTOPRISM_STORAGE_PATH || "/srv/photoprism/storage"
const MAX_UPLOAD_BYTES = Number(process.env.MAX_UPLOAD_BYTES || 1024 * 1024 * 1024)
const MAX_UPLOAD_FILES = Number(process.env.MAX_UPLOAD_FILES || 100)
const IMPORT_TIMEOUT_MS = Number(process.env.IMPORT_TIMEOUT_MS || 30 * 60 * 1000)

const pool = mysql.createPool(DB)

const THUMB_SIZE = "1280x1024_fit"
const BIG_SIZE = "1920x1200_fit"
const thumb = (hash, size = THUMB_SIZE) => {
  if (!hash) return null
  const s = hash.toString()
  return `/thumbs/${s[0]}/${s[1]}/${s[2]}/${s}_${size}.jpg`
}

let state = null

async function load() {
  const [photos] = await pool.query(
    `SELECT p.id, p.photo_title, p.photo_year, p.photo_month, p.photo_day,
            f.file_hash, f.file_width, f.file_height
       FROM photos p
       JOIN files f ON f.photo_id = p.id AND f.file_primary = 1 AND f.file_missing = 0
      WHERE p.deleted_at IS NULL
      ORDER BY p.taken_at_local, p.id`
  )

  const byId = new Map()
  const photoOrder = []
  for (const p of photos) {
    byId.set(p.id, {
      id: p.id,
      thumb: thumb(p.file_hash),
      full: thumb(p.file_hash, BIG_SIZE),
      title: p.photo_title || "",
      date: p.photo_year
        ? `${p.photo_year}-${String(p.photo_month || 1).padStart(2, "0")}-${String(p.photo_day || 1).padStart(2, "0")}`
        : "",
      w: p.file_width || 0,
      h: p.file_height || 0,
    })
    photoOrder.push(p.id)
  }
  const rank = new Map(photoOrder.map((id, i) => [id, i]))

  const paths = new Map()
  const photoPaths = new Map()

  function addRows(rows, type, label) {
    const grouped = new Map()
    for (const r of rows) {
      if (!byId.has(r.pid)) continue
      if (!grouped.has(r.k)) grouped.set(r.k, { key: `${type}:${r.k}`, type, label, name: r.name, ids: [] })
      grouped.get(r.k).ids.push(r.pid)
    }
    for (const g of grouped.values()) {
      g.ids.sort((a, b) => rank.get(a) - rank.get(b))
      g.count = g.ids.length
      paths.set(g.key, g)
      for (const pid of g.ids) {
        if (!photoPaths.has(pid)) photoPaths.set(pid, [])
        photoPaths.get(pid).push(g)
      }
    }
  }

  const [lab] = await pool.query(
    `SELECT pl.label_id AS k, l.label_name AS name, pl.photo_id AS pid
       FROM photos_labels pl JOIN labels l ON l.id = pl.label_id`)
  addRows(lab, "label", "Labels")

  const [kw] = await pool.query(
    `SELECT pk.keyword_id AS k, kw.keyword AS name, pk.photo_id AS pid
       FROM photos_keywords pk JOIN keywords kw ON kw.id = pk.keyword_id`)
  addRows(kw, "keyword", "Keywords")

  const [cam] = await pool.query(
    `SELECT p.camera_id AS k, CONCAT(c.camera_make, ' ', c.camera_model) AS name, p.id AS pid
       FROM photos p JOIN cameras c ON c.id = p.camera_id
      WHERE p.camera_id <> 1 AND p.camera_id IS NOT NULL`)
  addRows(cam, "camera", "Cameras")

  const [len] = await pool.query(
    `SELECT p.lens_id AS k, l.lens_model AS name, p.id AS pid
       FROM photos p JOIN lenses l ON l.id = p.lens_id
      WHERE p.lens_id <> 1 AND p.lens_id IS NOT NULL`)
  addRows(len, "lens", "Lenses")

  const facets = []
  for (const type of ["label", "keyword", "camera", "lens"]) {
    const list = Array.from(paths.values())
      .filter((g) => g.type === type && g.count >= MIN_PATH)
      .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name))
    for (const g of list) facets.push({ type: g.type, label: g.label, name: g.name, count: g.count, ids: g.ids })
  }

  const library = { key: "library:all", type: "library", label: "Library", name: "library", ids: photoOrder, count: photoOrder.length }
  const DIRS = ["N", "E", "S", "W"]
  const exits = new Map()
  for (const pid of photoOrder) {
    const own = (photoPaths.get(pid) || [])
      .filter((p) => p.count >= 2)
      .sort((a, b) => b.count - a.count || a.name.localeCompare(b.name) || a.type.localeCompare(b.type))
    const chosen = own.slice(0, 4)
    while (chosen.length < 4) chosen.push(library)
    const used = new Map()
    const usedNext = new Set()
    const list = []
    for (let i = 0; i < 4; i++) {
      const p = chosen[i]
      const step = used.get(p.key) || 0
      used.set(p.key, step + 1)
      const idx = p.ids.indexOf(pid)
      const cyc = p.ids
      const start = (idx + 1 + step) % cyc.length
      const walk = []
      for (let k = 0; k < 60 && walk.length < cyc.length; k++) walk.push(cyc[(start + k) % cyc.length])
      let nextId = cyc[start]
      for (const wid of walk) {
        if (wid !== pid && !usedNext.has(wid)) { nextId = wid; break }
      }
      usedNext.add(nextId)
      const wi = walk.indexOf(nextId)
      const rot = wi > 0 ? walk.slice(wi).concat(walk.slice(0, wi)) : walk
      const li = library.ids.indexOf(pid)
      const ext = rot.slice()
      for (let k = 1; ext.length < 60 && k < library.ids.length; k++) {
        const wid = library.ids[(li + k) % library.ids.length]
        if (wid !== pid && !ext.includes(wid)) ext.push(wid)
      }
      list.push({
        dir: DIRS[i],
        path: { type: p.type, name: p.name, count: p.count },
        nextId,
        walk: ext,
      })
    }
    exits.set(pid, list)
  }

  return { builtAt: new Date().toISOString(), total: photoOrder.length, photos: Object.fromEntries(byId), facets, photoOrder, byId, exits }
}

async function refresh() {
  try {
    state = await load()
  } catch (err) {
    console.error("pathways: refresh failed:", err.message)
  }
}

const MIME = { ".html": "text/html; charset=utf-8", ".css": "text/css", ".js": "text/javascript", ".svg": "image/svg+xml", ".ico": "image/x-icon" }

function serveFile(res, path) {
  if (!existsSync(path)) {
    res.writeHead(404).end("not found")
    return
  }
  const type = MIME[extname(path)] || "application/octet-stream"
  const cache = path.endsWith(".html") ? "no-cache" : "max-age=300"
  res.writeHead(200, { "Content-Type": type, "Cache-Control": cache })
  createReadStream(path).pipe(res)
}

function json(res, code, data) {
  res.writeHead(code, { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store" })
  res.end(JSON.stringify(data))
}

const PNG_MAGIC = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])

const SIGNATURES = [
  { ext: "jpg", accepts: /\.jpe?g$/i, test: (b) => b.length > 3 && b[0] === 0xff && b[1] === 0xd8 && b[2] === 0xff },
  { ext: "png", accepts: /\.png$/i, test: (b) => b.length > 8 && b.subarray(0, 8).equals(PNG_MAGIC) },
  {
    ext: "webp",
    accepts: /\.webp$/i,
    test: (b) => b.length > 12 && b.subarray(0, 4).toString("latin1") === "RIFF" && b.subarray(8, 12).toString("latin1") === "WEBP",
  },
]

function sniff(buf) {
  return SIGNATURES.find((s) => s.test(buf)) || null
}

function readBody(req, limit) {
  return new Promise((resolve, reject) => {
    const chunks = []
    let size = 0
    req.on("data", (c) => {
      size += c.length
      if (size > limit) {
        const err = new Error("payload too large")
        err.code = "TOO_LARGE"
        reject(err)
        req.destroy()
        return
      }
      chunks.push(c)
    })
    req.on("end", () => resolve(Buffer.concat(chunks)))
    req.on("error", reject)
  })
}

function parseMultipart(buf, boundary) {
  const parts = []
  const delim = Buffer.from(`--${boundary}`)
  const sep = Buffer.from("\r\n\r\n")
  let pos = buf.indexOf(delim)
  if (pos < 0) return parts
  pos += delim.length
  while (pos < buf.length) {
    if (buf[pos] === 0x2d && buf[pos + 1] === 0x2d) break
    if (buf[pos] === 0x0d && buf[pos + 1] === 0x0a) pos += 2
    const headEnd = buf.indexOf(sep, pos)
    if (headEnd < 0) break
    const headers = buf.subarray(pos, headEnd).toString("utf8")
    const bodyStart = headEnd + sep.length
    const next = buf.indexOf(delim, bodyStart)
    if (next < 0) break
    let bodyEnd = next
    if (buf[bodyEnd - 2] === 0x0d && buf[bodyEnd - 1] === 0x0a) bodyEnd -= 2
    parts.push({ headers, body: buf.subarray(bodyStart, bodyEnd) })
    pos = next + delim.length
  }
  return parts
}

function fileNameOf(headers) {
  const m = /filename\*?=(?:UTF-8''([^\r\n;]+)|"([^"]*)"|([^\r\n;]+))/i.exec(headers)
  if (!m) return null
  const raw = m[1] ? decodeURIComponent(m[1]) : (m[2] ?? m[3] ?? "")
  return raw.trim()
}

function safeName(raw, sig, taken) {
  const base = (raw.split(/[\\/]/).pop() || "").replace(/[^A-Za-z0-9._-]/g, "_").replace(/^\.+/, "").slice(0, 120)
  let name = base || "upload"
  if (!sig.accepts.test(name)) name += `.${sig.ext}`
  let out = name
  let n = 1
  while (taken.has(out)) {
    const dot = name.lastIndexOf(".")
    out = `${name.slice(0, dot)}-${n}${name.slice(dot)}`
    n++
  }
  taken.add(out)
  return out
}

function photoprismCopy(dir) {
  const env = {
    PHOTOPRISM_DATABASE_DRIVER: "mysql",
    PHOTOPRISM_DATABASE_SERVER: `${DB.host}:${DB.port}`,
    PHOTOPRISM_DATABASE_NAME: DB.database,
    PHOTOPRISM_DATABASE_USER: DB.user,
    PHOTOPRISM_DATABASE_PASSWORD: DB.password,
    PHOTOPRISM_ORIGINALS_PATH: ORIGINALS_PATH,
    PHOTOPRISM_STORAGE_PATH: STORAGE_PATH,
    PHOTOPRISM_READONLY: "false",
    PHOTOPRISM_DISABLE_TENSORFLOW: "true",
    PHOTOPRISM_DISABLE_CLASSIFICATION: "true",
    PHOTOPRISM_DISABLE_FACES: "true",
    PHOTOPRISM_LOG_LEVEL: "info",
  }
  const assignments = Object.entries(env).map(([k, v]) => `${k}=${v}`)
  const args = ["-n", "-u", PHOTOPRISM_USER, "env", ...assignments, PHOTOPRISM_BIN, "cp", dir]
  return execFileAsync("sudo", args, { cwd: PHOTOPRISM_HOME, timeout: IMPORT_TIMEOUT_MS, maxBuffer: 16 * 1024 * 1024 })
}

async function handleImport(req, res) {
  if (req.method !== "POST") return json(res, 405, { error: "method not allowed" })

  const ctype = req.headers["content-type"] || ""
  const bm = /boundary=(?:"([^"]+)"|([^;]+))/i.exec(ctype)
  if (!/^multipart\/form-data/i.test(ctype) || !bm) {
    return json(res, 400, { error: "expected multipart/form-data" })
  }

  let body
  try {
    body = await readBody(req, MAX_UPLOAD_BYTES)
  } catch (err) {
    if (err.code === "TOO_LARGE") return json(res, 413, { error: `upload exceeds ${MAX_UPLOAD_BYTES} bytes` })
    return json(res, 400, { error: "could not read upload" })
  }

  const taken = new Set()
  const files = []
  for (const part of parseMultipart(body, (bm[1] || bm[2]).trim())) {
    const raw = fileNameOf(part.headers)
    if (!raw || part.body.length === 0) continue
    const sig = sniff(part.body)
    if (!sig) return json(res, 415, { error: `unsupported file type: ${raw}` })
    if (files.length >= MAX_UPLOAD_FILES) return json(res, 413, { error: `too many files (max ${MAX_UPLOAD_FILES})` })
    files.push({ name: safeName(raw, sig, taken), data: part.body })
  }
  if (files.length === 0) return json(res, 400, { error: "no image files in request" })

  const batch = randomUUID()
  const dir = join(STAGING_ROOT, batch)
  try {
    await mkdir(dir, { recursive: true })
    for (const f of files) await writeFile(join(dir, f.name), f.data)
  } catch (err) {
    console.error("pathways: staging failed:", err.message)
    return json(res, 500, { error: "could not stage upload" })
  }

  try {
    const { stdout, stderr } = await photoprismCopy(dir)
    console.log(`pathways: imported ${files.length} file(s) via batch ${batch}`)
    if (stderr) console.error(`pathways: photoprism cp stderr: ${stderr.slice(-2000)}`)
    else if (stdout) console.log(`pathways: photoprism cp: ${stdout.slice(-2000)}`)
  } catch (err) {
    const detail = (err.stderr || err.stdout || err.message || "").slice(-2000)
    console.error(`pathways: import failed (batch ${batch} kept at ${dir}):`, detail)
    return json(res, 500, { error: "photoprism import failed", batch, detail })
  }

  await refresh()
  await rm(dir, { recursive: true, force: true }).catch(() => {})
  return json(res, 200, { ok: true, imported: files.length, batch })
}

const server = http.createServer(async (req, res) => {
  const url = new URL(req.url, `http://${req.headers.host || "localhost"}`)
  const path = url.pathname

  try {
    if (path === "/api/paths") {
      if (!state) await refresh()
      return json(res, 200, { builtAt: state.builtAt, photos: state.photos, facets: state.facets })
    }
    if (path === "/api/random") {
      if (!state) await refresh()
      const id = state.photoOrder[Math.floor(Math.random() * state.photoOrder.length)]
      return json(res, 200, { photo: state.byId.get(id) })
    }
    const exitMatch = path.match(/^\/api\/exits\/(\d+)$/)
    if (exitMatch) {
      if (!state) await refresh()
      const id = Number(exitMatch[1])
      const e = state.exits.get(id)
      if (!e) return json(res, 404, { error: "not found" })
      const photos = {}
      for (const x of e) for (const wid of x.walk) {
        const ph = state.byId.get(wid)
        if (ph) photos[wid] = ph
      }
      return json(res, 200, {
        photo: state.byId.get(id),
        exits: e.map((x) => ({ dir: x.dir, path: x.path, next: state.byId.get(x.nextId), walk: x.walk })),
        photos,
      })
    }
    if (path === "/api/import") return await handleImport(req, res)
    if (path === "/api/health") return json(res, 200, { ok: true })

    if (path === "/" || path === "") {
      return serveFile(res, join(PUBLIC, "index.html"))
    }
    const safe = normalize(path).replace(/^(\.\.[/\\])+/, "")
    const file = join(PUBLIC, safe)
    if (file.startsWith(PUBLIC)) return serveFile(res, file)

    res.writeHead(404).end("not found")
  } catch (err) {
    console.error("pathways:", err)
    json(res, 500, { error: "internal error" })
  }
})

server.requestTimeout = 0
server.headersTimeout = 65_000
server.keepAliveTimeout = 65_000

server.listen(PORT, "127.0.0.1", () => {
  console.log(`pathways listening on 127.0.0.1:${PORT}`)
  mkdir(STAGING_ROOT, { recursive: true }).catch((err) => console.error("pathways: staging dir:", err.message))
  refresh()
})
setInterval(refresh, 30 * 60 * 1000).unref()