import { execFile } from 'node:child_process'
import { mkdtemp, open, rm } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import path from 'node:path'
import { promisify } from 'node:util'
import { decodeSegment, type DecodedSegment } from '../yenc/index.js'
import type { RarInfo } from '../rar/parse.js'
import type { BodyFetcher } from '../rar/segment_reader.js'
import {
  checkHeader,
  encodedHeaderEncrypted,
  listingStart,
  parseBsdtarListing,
  parseSevenZipStart,
  type SevenZipStart,
} from './index.js'

const run = promisify(execFile)

/** The tail read for a listing: header plus packed header; more is not a header. */
const MAX_TAIL_BYTES = 16 * 1024 * 1024

/**
 * Lists a 7z archive, also a split one (.7z.001, .002, …), from the first
 * segment of the first volume (`firstData`, decoded) and the last segment(s)
 * of the last one (CONCEPT.md D19). Those bytes are put at their place in a
 * sparse file the size of the whole archive, which bsdtar (libarchive)
 * lists: it only reads the start and the header at the end. Null when it
 * isn't a 7z start, or the tail doesn't hold the header its start points to.
 */
export async function listSevenZip(
  firstData: Buffer,
  volumeCount: number,
  lastVolume: { number: number; id: string }[],
  fetch: BodyFetcher,
  warn: (message: string) => void = () => {}
): Promise<RarInfo | null> {
  const start = parseSevenZipStart(firstData)
  if (!start) return null
  const split = volumeCount > 1
  if (start.headerSize === 0) return sevenZipInfo([], false, false, split)

  const tail = await readTail(lastVolume, start, fetch)
  if (!tail) return null
  // Encrypted headers (-mhe): known from the header alone, no listing possible (most 7z uploads).
  if ('headersEncrypted' in tail) return sevenZipInfo([], true, true, split)

  const dir = await mkdtemp(path.join(tmpdir(), '7z-'))
  try {
    const archive = path.join(dir, 'archive.7z')
    const handle = await open(archive, 'w')
    try {
      await handle.write(firstData, 0, Math.min(firstData.length, start.archiveSize), 0)
      await handle.write(tail.data, 0, tail.data.length, tail.from)
      await handle.truncate(start.archiveSize)
    } finally {
      await handle.close()
    }
    return await bsdtar(archive, split, warn)
  } finally {
    await rm(dir, { recursive: true, force: true })
  }
}

/** Lists the sparse archive; a trial extraction of one entry tells whether its data is encrypted. */
async function bsdtar(archive: string, split: boolean, warn: (message: string) => void): Promise<RarInfo | null> {
  let stdout = ''
  try {
    stdout = (await run('bsdtar', ['-tvf', archive], { timeout: 60_000, maxBuffer: 32 * 1024 * 1024 })).stdout
  } catch (error: any) {
    if (/header is encrypted/i.test(String(error.stderr))) return sevenZipInfo([], true, true, split)
    warn(`bsdtar could not list a 7z archive: ${String(error.stderr || error.message).trim()}`)
    return null
  }
  const entries = parseBsdtarListing(stdout)
  const sample = entries.filter((e) => !e.directory).sort((a, b) => a.size - b.size)[0]
  let encrypted = false
  if (sample) {
    try {
      await run('bsdtar', ['-xOf', archive, sample.name], { timeout: 30_000, maxBuffer: 4 * 1024 * 1024, encoding: 'buffer' })
    } catch (error: any) {
      // Without the data (it's all zeros here), anything else fails too: only this message counts.
      encrypted = /content is encrypted/i.test(String(error.stderr))
    }
  }
  return sevenZipInfo(entries, false, encrypted, split)
}

export function sevenZipInfo(
  entries: { name: string; size: number; directory: boolean }[],
  headersEncrypted: boolean,
  encrypted: boolean,
  split: boolean
): RarInfo {
  return {
    format: '7z',
    volume: split,
    firstVolume: true,
    solid: false,
    headersEncrypted,
    truncated: false,
    next: 0,
    entries: entries.map((e) => ({
      name: e.name,
      size: e.size,
      packedSize: 0,
      directory: e.directory,
      encrypted: encrypted && !e.directory,
      splitBefore: false,
      splitAfter: false,
      stored: false,
      dataOffset: 0,
    })),
  }
}

/**
 * The archive's tail from the last volume: the header (checked against its
 * CRC) and, for an encoded header, the packed stream before it. `from` is
 * its position in the whole archive.
 */
async function readTail(
  last: { number: number; id: string }[],
  start: SevenZipStart,
  fetch: BodyFetcher
): Promise<{ from: number; data: Buffer } | { headersEncrypted: true } | null> {
  const ids = new Map(last.map((s) => [s.number, s]))
  const numbers = [...ids.keys()]
  if (numbers.length === 0) return null
  const segments = new Map<number, DecodedSegment>()
  const segment = async (n: number) => {
    if (!segments.has(n)) {
      const id = ids.get(n)?.id
      if (!id) throw new Error(`part ${n} of the last 7z volume is missing`)
      segments.set(n, decodeSegment(await fetch(id), { lenientSize: true }))
    }
    return segments.get(n)!
  }

  const lastNumber = numbers[numbers.length - 1]
  const lastSegment = await segment(lastNumber)
  const volumeSize = lastSegment.meta.begin.size
  const volumeStart = start.archiveSize - volumeSize
  const partBegin = (lastSegment.meta.part?.begin ?? 1) - 1
  const partSize = lastNumber > 1 ? partBegin / (lastNumber - 1) : volumeSize
  if (volumeStart < 0 || !Number.isInteger(partSize) || partSize <= 0) return null

  // Bytes [from, to) of the whole archive, from the last volume's parts.
  const read = async (from: number, to: number): Promise<Buffer | null> => {
    if (from < volumeStart) return null
    const a = from - volumeStart
    const b = to - volumeStart
    const pieces: Buffer[] = []
    for (let n = Math.floor(a / partSize) + 1; n <= Math.floor((b - 1) / partSize) + 1; n++) {
      const s = await segment(n)
      const offset = (s.meta.part?.begin ?? 1) - 1
      if (offset !== (n - 1) * partSize) return null
      pieces.push(s.data.subarray(Math.max(0, a - offset), Math.max(0, Math.min(s.data.length, b - offset))))
    }
    const data = Buffer.concat(pieces)
    return data.length === b - a ? data : null
  }

  const header = await read(start.headerStart, start.archiveSize)
  if (!header || !checkHeader(start, header)) return null
  if (encodedHeaderEncrypted(header)) return { headersEncrypted: true }
  const from = Math.min(listingStart(start, header), start.headerStart)
  if (start.archiveSize - from > MAX_TAIL_BYTES) return null
  const data = await read(from, start.archiveSize)
  return data ? { from, data } : null
}