apiServer.js

/**
 * Local HTTP API server that replicates the Flask recordings_viewer.pyw endpoints.
 * Runs inside Electron's main process on a random port.
 */
const http = require('http')
const fs = require('fs')
const path = require('path')
const { exec, execFile, spawn } = require('child_process')
const { shell } = require('electron')
const url = require('url')

const { MIME_TYPES, formatFileSize, FFMPEG_PATH, FFPROBE_PATH, CODEC_MAP } = require('./constants')
const service = require('./recordingService')
const { loadMarkers, saveMarkers } = require('./markerService')
const { getVideoDuration, getDiskUsage } = require('./videoMetadata')
const { getWaveform, setWaveform } = require('./waveformCache')
const { getNumPeaks, generateWaveform, generateWaveformChunk } = require('./waveformUtils')

let store // set in startApiServer

const MAX_BODY_SIZE = 1024 * 1024 // 1 MB

function isAllowedPath(filePath) {
  if (!filePath) return false
  const resolved = path.resolve(filePath)
  const roots = [store.get('settings.obsRecordingPath'), store.get('settings.destinationPath')]
    .filter(Boolean)
    .map((p) => path.resolve(p))
  return roots.some((base) => resolved === base || resolved.startsWith(base + path.sep))
}

function readBody(req) {
  return new Promise((resolve, reject) => {
    let body = ''
    let size = 0
    req.on('data', (chunk) => {
      size += chunk.length
      if (size > MAX_BODY_SIZE) {
        req.destroy()
        reject(new Error('Payload too large'))
        return
      }
      body += chunk
    })
    req.on('end', () => {
      try {
        resolve(JSON.parse(body))
      } catch {
        resolve({})
      }
    })
  })
}

function json(res, data, status = 200) {
  res.writeHead(status, { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' })
  res.end(JSON.stringify(data))
}

function startApiServer(appStore) {
  store = appStore
  service.init(appStore)

  const server = http.createServer(async (req, res) => {
    // CORS preflight
    if (req.method === 'OPTIONS') {
      res.writeHead(204, {
        'Access-Control-Allow-Origin': '*',
        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
        'Access-Control-Allow-Headers': 'Content-Type',
      })
      return res.end()
    }

    const parsed = url.parse(req.url, true)
    const pathname = parsed.pathname
    const query = parsed.query

    try {
      // GET /api/recordings
      if (pathname === '/api/recordings' && req.method === 'GET') {
        return json(res, service.scanRecordings())
      }

      // GET /api/clips
      if (pathname === '/api/clips' && req.method === 'GET') {
        return json(res, service.scanClips())
      }

      // GET /api/video?path=...
      if (pathname === '/api/video' && req.method === 'GET') {
        const filePath = query.path
        if (!filePath) return json(res, { error: 'File not found' }, 404)
        if (!isAllowedPath(filePath)) return json(res, { error: 'Forbidden' }, 403)

        let stat
        try {
          stat = fs.statSync(filePath)
        } catch {
          return json(res, { error: 'File not found' }, 404)
        }

        const ext = path.extname(filePath).toLowerCase()
        const mimeType = MIME_TYPES[ext] || 'video/mp4'
        const fileSize = stat.size
        const range = req.headers.range

        if (range) {
          const match = range.match(/bytes=(\d+)-(\d*)/)
          const start = parseInt(match[1])
          const end = match[2] ? parseInt(match[2]) : fileSize - 1
          const contentLength = end - start + 1
          res.writeHead(206, {
            'Content-Range': `bytes ${start}-${end}/${fileSize}`,
            'Accept-Ranges': 'bytes',
            'Content-Length': contentLength,
            'Content-Type': mimeType,
            'Access-Control-Allow-Origin': '*',
          })
          const rangeStream = fs.createReadStream(filePath, { start, end })
          rangeStream.on('error', () => {})
          res.on('close', () => rangeStream.destroy())
          rangeStream.pipe(res)
        } else {
          res.writeHead(200, {
            'Accept-Ranges': 'bytes',
            'Content-Length': fileSize,
            'Content-Type': mimeType,
            'Access-Control-Allow-Origin': '*',
          })
          const fullStream = fs.createReadStream(filePath)
          fullStream.on('error', () => {})
          res.on('close', () => fullStream.destroy())
          fullStream.pipe(res)
        }
        return
      }

      // POST /api/clips/create
      if (pathname === '/api/clips/create' && req.method === 'POST') {
        const data = await readBody(req)
        const {
          source_path,
          start_time,
          end_time,
          game_name = 'Unknown',
          audio_tracks = null,
        } = data
        try {
          const result = await service.createClip(
            source_path,
            start_time,
            end_time,
            game_name,
            audio_tracks
          )
          return json(res, result)
        } catch (e) {
          const status = e.message.includes('not found')
            ? 404
            : e.message.includes('End time')
              ? 400
              : 500
          return json(res, { error: e.message }, status)
        }
      }

      // POST /api/clips/trim
      if (pathname === '/api/clips/trim' && req.method === 'POST') {
        const data = await readBody(req)
        const { source_path, start_time, end_time } = data
        try {
          const result = await service.trimClip(source_path, start_time, end_time)
          return json(res, result)
        } catch (e) {
          const status = e.message.includes('not found')
            ? 404
            : e.message.includes('End time')
              ? 400
              : 500
          return json(res, { error: e.message }, status)
        }
      }

      // GET /api/clips/trim-status?path=...
      if (pathname === '/api/clips/trim-status' && req.method === 'GET') {
        const filePath = query.path
        if (!filePath) return json(res, { status: 'idle' })
        return json(res, service.getTrimState(filePath))
      }

      // POST /api/clips/trim-finalize — frontend calls this after clearing video src
      if (pathname === '/api/clips/trim-finalize' && req.method === 'POST') {
        const data = await readBody(req)
        const { source_path } = data
        try {
          await service.finalizeTrim(source_path)
          return json(res, { success: true })
        } catch (e) {
          return json(res, { error: e.message }, 500)
        }
      }

      // POST /api/clips/delete or /api/delete
      if (
        (pathname === '/api/clips/delete' || pathname === '/api/delete') &&
        req.method === 'POST'
      ) {
        const data = await readBody(req)
        if (!data.path) return json(res, { error: 'Not found' }, 404)
        if (!isAllowedPath(data.path)) return json(res, { error: 'Forbidden' }, 403)
        const result = await service.deleteFile(data.path)
        return json(res, result, result.status || 200)
      }

      // POST /api/recordings/delete
      if (pathname === '/api/recordings/delete' && req.method === 'POST') {
        const data = await readBody(req)
        if (!data.path) return json(res, { error: 'Not found' }, 404)
        if (!isAllowedPath(data.path)) return json(res, { error: 'Forbidden' }, 403)
        const result = await service.deleteFile(data.path)
        return json(res, result, result.status || 200)
      }

      // POST /api/open-external
      if (pathname === '/api/open-external' && req.method === 'POST') {
        const data = await readBody(req)
        if (data.path) shell.openPath(data.path)
        return json(res, { success: true })
      }

      // POST /api/show-in-explorer
      if (pathname === '/api/show-in-explorer' && req.method === 'POST') {
        const data = await readBody(req)
        if (data.path) shell.showItemInFolder(data.path)
        return json(res, { success: true })
      }

      // GET /api/markers
      if (pathname === '/api/markers' && req.method === 'GET') {
        const filePath = query.path
        const gameName = query.game_name
        if (!filePath) return json(res, { error: 'Not found' }, 404)

        let stat
        try {
          stat = fs.statSync(filePath)
        } catch {
          return json(res, { error: 'Not found' }, 404)
        }

        const duration = await getVideoDuration(filePath)
        if (!duration) return json(res, { markers: [], error: 'Could not get duration' })
        const fileMtime = stat.mtimeMs / 1000
        const recordingStart = fileMtime - duration
        const markersData = loadMarkers()
        const matching = []
        for (const m of markersData.markers || []) {
          if (m.game_name === gameName) {
            const mt = m.timestamp || 0
            if (mt >= recordingStart && mt <= fileMtime) {
              matching.push({
                position: mt - recordingStart,
                timestamp: mt,
                created_at: m.created_at || '',
              })
            }
          }
        }
        matching.sort((a, b) => a.position - b.position)
        return json(res, { markers: matching, duration })
      }

      // POST /api/markers/delete
      if (pathname === '/api/markers/delete' && req.method === 'POST') {
        const data = await readBody(req)
        const markersData = loadMarkers()
        const before = markersData.markers.length
        markersData.markers = markersData.markers.filter((m) => m.timestamp !== data.timestamp)
        if (markersData.markers.length < before) {
          saveMarkers(markersData)
          return json(res, { success: true })
        }
        return json(res, { error: 'Not found' }, 404)
      }

      // GET /api/storage/stats
      if (pathname === '/api/storage/stats' && req.method === 'GET') {
        const recordings = service.scanRecordings()
        const clips = service.scanClips()
        const lockedRecordings = store.get('lockedRecordings') || []
        const totalRecSize = recordings.reduce((s, r) => s + r.size_bytes, 0)
        const totalClipSize = clips.reduce((s, c) => s + c.size_bytes, 0)
        const totalSize = totalRecSize + totalClipSize
        const games = {}
        for (const r of recordings) {
          if (!games[r.game_name]) games[r.game_name] = { recordings: [], clips: [], total_size: 0 }
          games[r.game_name].recordings.push(r)
          games[r.game_name].total_size += r.size_bytes
        }
        for (const c of clips) {
          if (!games[c.game_name]) games[c.game_name] = { recordings: [], clips: [], total_size: 0 }
          games[c.game_name].clips.push(c)
          games[c.game_name].total_size += c.size_bytes
        }
        let diskUsage = null
        const orgPath = service.getOrganizedPath()
        if (orgPath && fs.existsSync(orgPath)) {
          diskUsage = await getDiskUsage(orgPath)
        }
        return json(res, {
          recordings,
          clips,
          total_size: totalSize,
          total_size_formatted: formatFileSize(totalSize),
          recording_size: totalRecSize,
          recording_size_formatted: formatFileSize(totalRecSize),
          clip_size: totalClipSize,
          clip_size_formatted: formatFileSize(totalClipSize),
          recording_count: recordings.length,
          clip_count: clips.length,
          games,
          disk_usage: diskUsage,
          locked_recordings: lockedRecordings,
        })
      }

      // GET/POST /api/storage/settings
      if (pathname === '/api/storage/settings') {
        if (req.method === 'POST') {
          const data = await readBody(req)
          if (data.storage_settings) store.set('storageSettings', data.storage_settings)
          return json(res, { success: true, settings: store.get('storageSettings') || {} })
        }
        return json(
          res,
          store.get('storageSettings') || {
            auto_delete_enabled: false,
            max_storage_gb: 100,
            max_age_days: 30,
            exclude_clips: true,
          }
        )
      }

      // POST /api/storage/lock
      if (pathname === '/api/storage/lock' && req.method === 'POST') {
        const data = await readBody(req)
        const locked = store.get('lockedRecordings') || []
        const normalized = path.normalize(data.path)
        if (data.locked) {
          if (!locked.includes(normalized)) locked.push(normalized)
        } else {
          const idx = locked.indexOf(normalized)
          if (idx >= 0) locked.splice(idx, 1)
        }
        store.set('lockedRecordings', locked)
        return json(res, { success: true, locked: data.locked })
      }

      // POST /api/storage/delete-batch
      if (pathname === '/api/storage/delete-batch' && req.method === 'POST') {
        const data = await readBody(req)
        const paths = data.paths || []
        const locked = (store.get('lockedRecordings') || []).map((p) => path.normalize(p))
        const deleted = [],
          failed = [],
          skippedLocked = []
        for (const p of paths) {
          if (locked.includes(path.normalize(p))) {
            skippedLocked.push(p)
            continue
          }
          const result = await service.deleteFile(p)
          if (result.success) deleted.push(p)
          else failed.push({ path: p, error: result.error })
        }
        return json(res, {
          success: true,
          deleted,
          deleted_count: deleted.length,
          failed,
          failed_count: failed.length,
          skipped_locked: skippedLocked,
          skipped_locked_count: skippedLocked.length,
        })
      }

      // POST /api/reencode
      if (pathname === '/api/reencode' && req.method === 'POST') {
        const data = await readBody(req)
        const {
          source_path,
          codec = 'h265',
          crf = 23,
          preset = 'medium',
          replace_original = false,
          original_size = 0,
          audio_tracks = null,
        } = data
        if (!isAllowedPath(source_path)) return json(res, { error: 'Forbidden' }, 403)
        if (!CODEC_MAP[codec]) return json(res, { error: `Unsupported codec: ${codec}` }, 400)
        const locked = (store.get('lockedRecordings') || []).map((p) => path.normalize(p))
        if (locked.includes(path.normalize(source_path)))
          return json(res, { error: 'Forbidden' }, 403)
        try {
          const result = await service.reencodeVideo(source_path, {
            codec,
            crf,
            preset,
            replaceOriginal: replace_original,
            originalSize: original_size,
            audioTracks: audio_tracks,
          })
          return json(res, result)
        } catch (e) {
          const status = e.message.includes('Not found') ? 404 : 500
          return json(res, { error: e.message }, status)
        }
      }

      // GET /api/video/tracks?path=...
      if (pathname === '/api/video/tracks' && req.method === 'GET') {
        const filePath = query.path
        if (!filePath || !isAllowedPath(filePath)) return json(res, { error: 'Forbidden' }, 403)
        if (!fs.existsSync(filePath)) return json(res, { error: 'File not found' }, 404)
        // Load sidecar track names if present (written during MKV→MP4 remux)
        let sidecarNames = null
        try {
          sidecarNames = JSON.parse(fs.readFileSync(filePath + '.tracks.json', 'utf-8'))
        } catch {}
        return new Promise((resolve) => {
          execFile(
            FFPROBE_PATH,
            ['-v', 'error', '-show_streams', '-select_streams', 'a', '-of', 'json', filePath],
            { encoding: 'utf-8', timeout: 10000 },
            (error, stdout) => {
              if (error) {
                resolve(json(res, { tracks: [] }))
                return
              }
              try {
                const data = JSON.parse(stdout)
                const tracks = (data.streams || []).map((s, i) => ({
                  index: i,
                  stream_index: s.index ?? i,
                  codec_name: s.codec_name || 'unknown',
                  channels: s.channels || 0,
                  channel_layout: s.channel_layout || '',
                  sample_rate: s.sample_rate || '',
                  title: sidecarNames?.[i] || s.tags?.title || s.tags?.TITLE || `Track ${i + 1}`,
                }))
                resolve(json(res, { tracks }))
              } catch {
                resolve(json(res, { tracks: [] }))
              }
            }
          )
        })
      }

      // GET /api/video/waveform/chunk?path=...&track=0&start=0&end=30&totalDuration=1800&resolution=default
      if (pathname === '/api/video/waveform/chunk' && req.method === 'GET') {
        const filePath = query.path
        const rawTrack = parseInt(query.track, 10)
        const startTime = parseFloat(query.start)
        const endTime = parseFloat(query.end)
        const totalDuration = parseFloat(query.totalDuration)
        const resolution = query.resolution || 'default'
        if (isNaN(rawTrack) || rawTrack < 0) return json(res, { error: 'Invalid track index' }, 400)
        if (
          isNaN(startTime) ||
          isNaN(endTime) ||
          isNaN(totalDuration) ||
          startTime < 0 ||
          endTime <= startTime ||
          totalDuration <= 0
        )
          return json(res, { error: 'Invalid time parameters' }, 400)
        if (!filePath || !isAllowedPath(filePath)) return json(res, { error: 'Forbidden' }, 403)
        if (!fs.existsSync(filePath)) return json(res, { error: 'File not found' }, 404)

        const numPeaksTotal = getNumPeaks(resolution)
        const peaksForChunk = Math.max(
          1,
          Math.round(numPeaksTotal * (endTime - startTime) / totalDuration)
        )
        const rawPeaks = await generateWaveformChunk(filePath, rawTrack, startTime, endTime, peaksForChunk)
        if (!rawPeaks || !rawPeaks.length)
          return json(res, { peaks: [], startTime, endTime, numPeaksTotal })
        return json(res, { peaks: rawPeaks, startTime, endTime, numPeaksTotal })
      }

      // POST /api/video/waveform/cache
      if (pathname === '/api/video/waveform/cache' && req.method === 'POST') {
        const data = await readBody(req)
        const { path: filePath, track, resolution } = data
        const rawTrack = parseInt(track, 10)
        if (isNaN(rawTrack) || rawTrack < 0) return json(res, { error: 'Invalid track index' }, 400)
        if (!filePath || !isAllowedPath(filePath)) return json(res, { error: 'Forbidden' }, 403)
        if (!fs.existsSync(filePath)) return json(res, { error: 'File not found' }, 404)
        json(res, { status: 'accepted' }, 202)
        setImmediate(async () => {
          try {
            const NUM_PEAKS = getNumPeaks(resolution || 'default')
            const existing = getWaveform(filePath, rawTrack, NUM_PEAKS)
            if (existing?.peaks?.length) return
            const result = await generateWaveform(filePath, rawTrack, NUM_PEAKS, getVideoDuration)
            if (result) setWaveform(filePath, rawTrack, NUM_PEAKS, result.peaks, result.duration)
          } catch {}
        })
        return
      }

      // GET /api/video/waveform?path=...&track=0&resolution=default
      if (pathname === '/api/video/waveform' && req.method === 'GET') {
        const filePath = query.path
        const rawTrack = parseInt(query.track, 10)
        const resolution = query.resolution || 'default'
        if (isNaN(rawTrack) || rawTrack < 0) return json(res, { error: 'Invalid track index' }, 400)
        const trackIndex = rawTrack
        if (!filePath || !isAllowedPath(filePath)) return json(res, { error: 'Forbidden' }, 403)
        if (!fs.existsSync(filePath)) return json(res, { error: 'File not found' }, 404)

        const NUM_PEAKS = getNumPeaks(resolution)

        // Check cache first
        const cached = getWaveform(filePath, trackIndex, NUM_PEAKS)
        if (cached && cached.peaks?.length) {
          return json(res, { peaks: cached.peaks, duration: cached.duration })
        }

        // Cache miss — signal the client to use the chunked path
        const duration = await getVideoDuration(filePath)
        if (!duration) return json(res, { peaks: [] })
        return json(res, { status: 'miss', duration })
      }

      // GET /api/ffmpeg-check
      if (pathname === '/api/ffmpeg-check' && req.method === 'GET') {
        execFile('ffmpeg', ['-version'], { timeout: 5000 }, (err) => {
          json(res, { available: !err })
        })
        return
      }

      // 404
      json(res, { error: 'Not found' }, 404)
    } catch (e) {
      if (res.headersSent) return
      if (e.message === 'Payload too large') {
        json(res, { error: 'Payload too large' }, 413)
      } else {
        json(res, { error: e.message }, 500)
      }
    }
  })

  // In dev mode use a fixed port so vite proxy can reach us; otherwise random
  // Also check for --integration-mode since those tests also need the fixed port
  const isDev =
    process.env.NODE_ENV === 'development' ||
    process.argv.includes('--dev') ||
    process.argv.includes('--integration-mode')
  const listenPort = isDev ? 47531 : 0
  server.listen(listenPort, '127.0.0.1', () => {
    const port = server.address().port
    console.log(`API server listening on http://127.0.0.1:${port}`)
  })

  return server
}

module.exports = { startApiServer }