import { existsSync, promises as fs } from 'node:fs'
import path from 'node:path'
import { getNitroFilesRoot } from '@/lib/services/furni-asset-dirs'
import type { HabboItFurniEntry } from '@/lib/services/habbo-furnidata-cache'
import { siteSettings } from '@/lib/services/site-settings'
import type { FurniMetadata } from '@/lib/services/swf-to-nitro'

const LOCK_STALE_MS = 60_000

/**
 * Resolve the FurnitureData file path from the admin setting
 * `furni_data_url` (e.g. `/nitro-assets/config/FurnitureData.json5`) mapped
 * under the public/ directory. Falls back to the json5 path if the setting
 * is unset.
 */
export async function getFurnitureDataPath(): Promise<string> {
  const url = (await siteSettings.get('furni_data_url', '/nitro-assets/config/FurnitureData.json5')) ?? '/nitro-assets/config/FurnitureData.json5'
  if (path.isAbsolute(url) && !url.startsWith('/')) return url
  const relative = url.replace(/^\/+/, '')
  // The `relative` segment is admin-configurable so its concrete value is
  // unknown at build time; without the hint Turbopack traces the entire
  // public/ tree (~400k files) into the route's NFT.
  return path.join(/*turbopackIgnore: true*/ process.cwd(), 'public', relative)
}

async function getFurnitureDataWritePaths(): Promise<string[]> {
  const primary = await getFurnitureDataPath()
  const configuredMirror = (await siteSettings.get('furni_data_mirror_path', '')) ?? ''
  const nitroFilesRoot = await getNitroFilesRoot()
  const mirror = configuredMirror.trim()
    ? configuredMirror
    : nitroFilesRoot
      ? path.join(
          /*turbopackIgnore: true*/ nitroFilesRoot,
          'nitro-assets/gamedata/FurnitureData.json',
        )
      : ''

  const paths = [primary, mirror].filter(Boolean).map((p) => path.normalize(p))
  const seen = new Set<string>()
  return paths.filter((p) => {
    const key = process.platform === 'win32' ? p.toLowerCase() : p
    if (seen.has(key)) return false
    seen.add(key)
    return true
  })
}

async function getFurnitureDataReadPath(): Promise<string> {
  const paths = await getFurnitureDataWritePaths()
  const existing = paths.find((p) => existsSync(/*turbopackIgnore: true*/ p))
  return existing ?? paths[0]
}

// ── FurnitureData.json lock + helpers ────────────────────────────────

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

async function acquireDiskLock(lockPath: string): Promise<void> {
  const deadline = Date.now() + 30_000
  while (true) {
    try {
      const fh = await fs.open(lockPath, 'wx')
      await fh.writeFile(String(process.pid))
      await fh.close()
      return
    } catch (err) {
      const e = err as NodeJS.ErrnoException
      if (e.code !== 'EEXIST') throw err
      try {
        const stat = await fs.stat(lockPath)
        if (Date.now() - stat.mtimeMs > LOCK_STALE_MS) {
          await fs.unlink(lockPath).catch(() => {})
          continue
        }
      } catch {
        /* lock vanished between checks */
      }
      if (Date.now() > deadline) throw new Error('FurnitureData lock timeout')
      await new Promise((r) => setTimeout(r, 100))
    }
  }
}

export async function withFurniDataLock<T>(fn: () => Promise<T>): Promise<T> {
  let release: () => void
  const acquired = new Promise<void>((r) => {
    release = r
  })
  const prev = furniDataLock
  furniDataLock = acquired
  await prev
  const lockBase = await getFurnitureDataReadPath()
  await fs.mkdir(path.dirname(lockBase), { recursive: true })
  const lockPath = `${lockBase}.lock`
  await acquireDiskLock(lockPath)
  try {
    return await fn()
  } finally {
    await fs.unlink(lockPath).catch(() => {})
    release!()
  }
}

export async function readFurniData(): Promise<Record<string, unknown>> {
  const target = await getFurnitureDataReadPath()
  const raw = await fs.readFile(/*turbopackIgnore: true*/ target, 'utf-8')
  return JSON.parse(raw)
}

export async function writeFurniData(data: Record<string, unknown>): Promise<void> {
  const targets = await getFurnitureDataWritePaths()
  const payload = JSON.stringify(data)
  for (const target of targets) {
    await fs.mkdir(path.dirname(target), { recursive: true })
    const tmp = `${target}.tmp`
    await fs.writeFile(/*turbopackIgnore: true*/ tmp, payload, 'utf-8')
    await fs.rename(/*turbopackIgnore: true*/ tmp, target)
  }
}

export function buildFurniEntry(params: {
  id: number
  classname: string
  revision: number
  category: string
  name: string
  description: string
  spriteId: number
  dims: { x: number; y: number; z: number }
  metadata: FurniMetadata | null
  habboIt?: HabboItFurniEntry | null
}): Record<string, unknown> {
  const {
    id,
    classname,
    revision,
    category,
    name,
    description,
    spriteId,
    dims,
    metadata,
    habboIt,
  } = params

  // Merge partcolors: prefer habbo.it (has real hex colors), fallback to .nitro extraction
  const partcolors = habboIt?.partcolors?.color?.length
    ? habboIt.partcolors
    : (metadata?.partcolors ?? { color: [] })

  return {
    id,
    classname,
    revision: revision || habboIt?.revision || 0,
    category: category || habboIt?.category || 'unknown',
    defaultdir: metadata?.defaultdir ?? habboIt?.defaultdir ?? 0,
    xdim: dims.x,
    ydim: dims.y,
    partcolors,
    name,
    description: description || '',
    adurl: '',
    offerid: spriteId,
    buyout: !!habboIt?.bc,
    rentofferid: -1,
    rentbuyout: false,
    bc: habboIt?.bc ?? false,
    excludeddynamic: false,
    customparams: habboIt?.customparams ?? '',
    specialtype: metadata?.specialtype ?? habboIt?.specialtype ?? 0,
    canstandon: metadata?.canstandon ?? habboIt?.canstandon ?? false,
    cansiton: metadata?.cansiton ?? habboIt?.cansiton ?? false,
    canlayon: metadata?.canlayon ?? habboIt?.canlayon ?? false,
    furniline: habboIt?.furniline ?? '',
    environment: habboIt?.environment ?? '',
    rare: habboIt?.rare ?? false,
  }
}

function upsertEntryInSection(
  section: { furnitype: Array<Record<string, unknown>> },
  entry: Record<string, unknown>,
) {
  const classname = entry.classname as string | undefined
  if (classname) {
    const idx = section.furnitype.findIndex((e) => e.classname === classname)
    if (idx >= 0) {
      section.furnitype[idx] = entry
      return
    }
  }
  section.furnitype.push(entry)
}

export async function appendFurniEntry(
  entry: Record<string, unknown>,
  itemType: string,
): Promise<void> {
  await withFurniDataLock(async () => {
    const furniData = (await readFurniData()) as Record<
      string,
      { furnitype: Array<Record<string, unknown>> }
    >
    if (itemType === 'i') {
      if (!furniData.wallitemtypes) furniData.wallitemtypes = { furnitype: [] }
      upsertEntryInSection(furniData.wallitemtypes, entry)
    } else {
      if (!furniData.roomitemtypes) furniData.roomitemtypes = { furnitype: [] }
      upsertEntryInSection(furniData.roomitemtypes, entry)
    }
    await writeFurniData(furniData as Record<string, unknown>)
  })
}

export async function removeFurniEntry(classname: string): Promise<boolean> {
  return withFurniDataLock(async () => {
    const furniData = (await readFurniData()) as Record<
      string,
      { furnitype: Array<Record<string, unknown>> }
    >
    let removed = false

    for (const section of ['roomitemtypes', 'wallitemtypes'] as const) {
      if (furniData[section]?.furnitype) {
        const before = furniData[section].furnitype.length
        furniData[section].furnitype = furniData[section].furnitype.filter(
          (e) => e.classname !== classname,
        )
        if (furniData[section].furnitype.length < before) removed = true
      }
    }

    if (removed) {
      await writeFurniData(furniData as Record<string, unknown>)
    }
    return removed
  })
}

export async function appendFurniEntriesBatch(
  entries: Array<{ entry: Record<string, unknown>; itemType: string }>,
): Promise<void> {
  await withFurniDataLock(async () => {
    const furniData = (await readFurniData()) as Record<string, { furnitype: unknown[] }>
    for (const { entry, itemType } of entries) {
      if (itemType === 'i') {
        if (!furniData.wallitemtypes) furniData.wallitemtypes = { furnitype: [] }
        upsertEntryInSection(
          furniData.wallitemtypes as { furnitype: Array<Record<string, unknown>> },
          entry,
        )
      } else {
        if (!furniData.roomitemtypes) furniData.roomitemtypes = { furnitype: [] }
        upsertEntryInSection(
          furniData.roomitemtypes as { furnitype: Array<Record<string, unknown>> },
          entry,
        )
      }
    }
    await writeFurniData(furniData as Record<string, unknown>)
  })
}