'use strict'
const cfg = require('./config')
const { log, json, parseBody } = require('./helpers')
const erp = require('./erp')

// Prefer bearer token (revocable, no password in env); fall back to Basic auth for legacy.
const authHeader = cfg.TRACCAR_TOKEN
  ? 'Bearer ' + cfg.TRACCAR_TOKEN
  : 'Basic ' + Buffer.from(cfg.TRACCAR_USER + ':' + cfg.TRACCAR_PASS).toString('base64')

async function traccarFetch (path) {
  const res = await fetch(cfg.TRACCAR_URL + path, {
    headers: { Authorization: authHeader, Accept: 'application/json' },
  })
  if (!res.ok) throw new Error(`Traccar ${res.status}: ${path}`)
  return res.json()
}

// Variante RAW (texte) — pour GPX/KML (Accept différent, pas de parse JSON).
async function traccarRaw (path, accept) {
  const res = await fetch(cfg.TRACCAR_URL + path, { headers: { Authorization: authHeader, Accept: accept } })
  if (!res.ok) throw new Error(`Traccar ${res.status}: ${path}`)
  return res.text()
}

// Résout l'appareil Traccar depuis ?device= OU ?tech= (technician_id puis docname Dispatch Technician).
async function deviceFor (url) {
  let device = url.searchParams.get('device'); const tech = url.searchParams.get('tech')
  if (!device && tech) {
    let rows = await erp.list('Dispatch Technician', { filters: [['technician_id', '=', tech]], fields: ['traccar_device_id'], limit: 1 })
    if (!rows.length) rows = await erp.list('Dispatch Technician', { filters: [['name', '=', tech]], fields: ['traccar_device_id'], limit: 1 })
    device = rows.length ? rows[0].traccar_device_id : null
  }
  return device
}

// Cache devices for 60s (they rarely change)
let _devCache = null, _devCacheTs = 0
async function getDevices () {
  if (_devCache && Date.now() - _devCacheTs < 60000) return _devCache
  _devCache = await traccarFetch('/api/devices?all=true')
  _devCacheTs = Date.now()
  return _devCache
}

async function getPositions (deviceIds) {
  if (!deviceIds?.length) return []
  const results = await Promise.allSettled(
    deviceIds.map(id => traccarFetch('/api/positions?deviceId=' + id))
  )
  return results.flatMap(r => r.status === 'fulfilled' ? r.value : [])
}

// HISTORIQUE des positions d'un device sur une fenêtre (ISO from/to) — pour la détection d'arrivée « rétrospective »
// (géofence basé sur la TRACE, robuste aux redémarrages/scans manqués), contrairement à getPositions (dernière position).
async function getHistory (deviceId, fromISO, toISO) {
  if (!deviceId) return []
  return traccarFetch('/api/positions?deviceId=' + encodeURIComponent(deviceId) + '&from=' + encodeURIComponent(fromISO) + '&to=' + encodeURIComponent(toISO))
}

// Distance en mètres (haversine).
function haversineM (aLat, aLon, bLat, bLon) {
  const R = 6371000, toR = x => x * Math.PI / 180
  const dLat = toR(bLat - aLat), dLon = toR(bLon - aLon)
  const s = Math.sin(dLat / 2) ** 2 + Math.cos(toR(aLat)) * Math.cos(toR(bLat)) * Math.sin(dLon / 2) ** 2
  return 2 * R * Math.asin(Math.sqrt(s))
}
// ANCRE D'ACTIVATION SERVICE (GenieACS) : le 1er inform (`registered`) ou le dernier bootstrap (`lastBoot`) du modem,
// s'il tombe dans la fenêtre du jour, = le moment RÉEL où le service a été livré sur place. Sert à BORNER la « traîne »
// du GPS (camion resté stationné après le travail → faux +500 %). Résout customer → Service Equipment → serial →
// résumé device (cache si déjà `registered`, sinon fetch ACS). Renvoie {serial, anchor (ISO), kind} ou null.
async function modemAnchor (customer, dayFromMs, dayToMs) {
  if (!customer) return null
  const devices = require('./devices')
  let eq = []
  try { eq = await erp.list('Service Equipment', { filters: [['customer', '=', customer]], fields: ['serial_number'], limit: 3 }) } catch (e) { return null }
  for (const e of (eq || [])) {
    const sn = e.serial_number; if (!sn) continue
    let sum = null
    // le poller rapide ne stocke que lastInform → si `registered` absent du cache, on fetch le détail complet (ACS).
    try { const c = devices.getCached(sn); sum = (c && c.summary && c.summary.registered) ? c.summary : await devices.fetchDeviceDetails(sn) } catch (_) { /* ACS indispo → on saute */ }
    if (!sum) continue
    for (const [t, kind] of [[sum.registered, 'registered'], [sum.lastBoot, 'boot']]) {
      const ms = t ? Date.parse(t) : NaN
      if (ms && ms >= dayFromMs && ms <= dayToMs) return { serial: sn, anchor: t, kind }
    }
  }
  return null
}

// CROISEMENT positions Traccar × emplacement de job → fenêtre « sur site » (rec C). Pour les jobs assignés/localisés
// récents : on tire l'historique GPS du tech ce jour-là, on garde les points à ≤ radiusM du job, et la 1ère→dernière
// proximité = actual_start/end. dryRun=true (défaut) = APERÇU (n'écrit rien).
//  - anchor=true (défaut) : enrichit chaque fenêtre avec l'ancre d'activation modem (clamped_end / clamped_minutes).
//  - clamp=true : ÉCRIT la fin BORNÉE par l'ancre (corrige les outliers GPS-stationné) — réécrit même si déjà capté.
//    Sinon (clamp=false), n'écrit que les jobs SANS temps déjà capté (idempotent), avec la fin GPS brute.
async function crossOnSite ({ days = 14, radiusM = 150, minMin = 10, dryRun = true, anchor = true, clamp = false, bufferMin = 30 } = {}) {
  const since = new Date(Date.now() - days * 86400000).toISOString().slice(0, 10)
  const jobs = await erp.list('Dispatch Job', { filters: [['assigned_tech', '!=', ''], ['scheduled_date', '>', since]], fields: ['name', 'assigned_tech', 'customer', 'latitude', 'longitude', 'scheduled_date', 'actual_start', 'actual_end'], limit: 800 })
  const techIds = [...new Set((jobs || []).map(j => j.assigned_tech).filter(Boolean))]
  const devOf = {}
  if (techIds.length) { const tr = await erp.list('Dispatch Technician', { filters: [['name', 'in', techIds]], fields: ['name', 'traccar_device_id'], limit: 500 }); for (const t of (tr || [])) if (t.traccar_device_id) devOf[t.name] = t.traccar_device_id }
  const out = []; let noDevice = 0, noGps = 0, anchored = 0, clamped = 0
  const fmt = s => new Date(s).toISOString().slice(0, 19).replace('T', ' ')
  for (const j of (jobs || [])) {
    if (!j.latitude || !j.longitude || Math.abs(j.latitude) < 1) continue
    const dev = devOf[j.assigned_tech]; if (!dev) { noDevice++; continue }
    const from = j.scheduled_date + 'T00:00:00-04:00'; const to = j.scheduled_date + 'T23:59:59-04:00'
    let pts = []
    try { pts = await traccarFetch(`/api/positions?deviceId=${encodeURIComponent(dev)}&from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`) } catch (e) { noGps++; continue }
    const times = (Array.isArray(pts) ? pts : []).filter(p => p.latitude != null && haversineM(j.latitude, j.longitude, p.latitude, p.longitude) <= radiusM).map(p => p.fixTime || p.deviceTime || p.serverTime).filter(Boolean).sort()
    if (times.length < 2) continue
    const start = times[0]; const end = times[times.length - 1]
    const rawMins = Math.round((Date.parse(end) - Date.parse(start)) / 60000)
    if (rawMins < minMin) continue
    // Ancre d'activation : si le modem est venu en ligne durant la visite, borner la fin à activation + tampon de
    // nettoyage/test (retire la traîne du GPS stationné). On garde toujours fin ≥ start + minMin.
    let anc = null, clampedEnd = end, clampedMins = rawMins
    if (anchor) {
      anc = await modemAnchor(j.customer, Date.parse(from), Date.parse(to))
      if (anc) {
        anchored++
        const cap = Date.parse(anc.anchor) + bufferMin * 60000
        if (cap < Date.parse(end) && cap >= Date.parse(start) + minMin * 60000) {
          clampedEnd = new Date(cap).toISOString(); clampedMins = Math.round((cap - Date.parse(start)) / 60000); clamped++
        }
      }
    }
    const already = !!(j.actual_start && String(j.actual_start).trim())
    const writeEnd = clamp ? clampedEnd : end
    out.push({ job: j.name, tech: j.assigned_tech, customer: j.customer || null, date: j.scheduled_date, onsite_start: start, onsite_end: end, minutes: rawMins, clamped_end: clampedEnd, clamped_minutes: clampedMins, service_anchor: anc ? anc.anchor : null, anchor_kind: anc ? anc.kind : null, points: times.length, already })
    if (!dryRun && (clamp || !already)) { await erp.update('Dispatch Job', j.name, { actual_start: fmt(start), actual_end: fmt(writeEnd) }).catch(() => {}) }
  }
  return { ok: true, days, radius_m: radiusM, min_min: minMin, buffer_min: bufferMin, dryRun, clamp, candidates: (jobs || []).length, no_device: noDevice, gps_errors: noGps, anchored, clamped, matched: out.length, written: dryRun ? 0 : out.filter(o => clamp || !o.already).length, results: out.slice(0, 50) }
}

async function handle (req, res, method, path) {
  const sub = path.replace('/traccar', '').replace(/^\//, '')

  // Croisement temps réel sur site (rec C) : GET = aperçu (dryRun) ; POST = écrit actual_start/end.
  //  &anchor=0 désactive l'ancre GenieACS ; &clamp=1 (POST) écrit la fin BORNÉE par l'activation modem (corrige outliers) ;
  //  &buffer=<min> = tampon après activation (défaut 30).
  if (sub === 'onsite' && (method === 'GET' || method === 'POST')) {
    try {
      const url = new URL(req.url, 'http://localhost')
      const opts = {
        days: Math.min(120, Math.max(1, Number(url.searchParams.get('days')) || 14)),
        radiusM: Math.min(1000, Math.max(30, Number(url.searchParams.get('radius')) || 150)),
        minMin: Math.max(1, Number(url.searchParams.get('min')) || 10),
        bufferMin: Math.min(180, Math.max(0, Number(url.searchParams.get('buffer')) || 30)),
        anchor: url.searchParams.get('anchor') !== '0',
        clamp: url.searchParams.get('clamp') === '1',
        dryRun: method === 'GET',
      }
      return json(res, 200, await crossOnSite(opts))
    } catch (e) { log('Traccar onsite error:', e.message); return json(res, 200, { ok: false, error: e.message }) }
  }

  if (sub === 'devices' && method === 'GET') {
    try {
      return json(res, 200, await getDevices())
    } catch (e) {
      log('Traccar devices error:', e.message)
      return json(res, 502, { error: 'Traccar unavailable' })
    }
  }

  if (sub === 'positions' && method === 'GET') {
    try {
      const url = new URL(req.url, 'http://localhost')
      const ids = (url.searchParams.get('deviceIds') || '').split(',').map(Number).filter(Boolean)
      return json(res, 200, await getPositions(ids))
    } catch (e) {
      log('Traccar positions error:', e.message)
      return json(res, 502, { error: 'Traccar unavailable' })
    }
  }

  // Export GPX du parcours d'un tech sur une fenêtre (jour courant) — résout le device depuis Dispatch Technician.
  if (sub === 'gpx' && method === 'GET') {
    try {
      const url = new URL(req.url, 'http://localhost')
      const device = await deviceFor(url)
      if (!device) return json(res, 404, { error: 'Aucun appareil GPS associé à ce technicien' })
      const from = url.searchParams.get('from'); const to = url.searchParams.get('to')
      if (!from || !to) return json(res, 400, { error: 'from + to (ISO 8601) requis' })
      const gpx = await traccarRaw(`/api/positions?deviceId=${encodeURIComponent(device)}&from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`, 'application/gpx+xml')
      res.writeHead(200, { 'Content-Type': 'application/gpx+xml; charset=utf-8', 'Content-Disposition': `attachment; filename="parcours-${device}-${String(from).slice(0, 10)}.gpx"` })
      return res.end(gpx)
    } catch (e) { log('Traccar gpx error:', e.message); return json(res, 502, { error: 'Traccar GPX indisponible' }) }
  }

  // Tracé GPS (breadcrumb) d'un tech sur UNE journée → coords [lon,lat] (JSON léger) pour superposer sur la carte.
  // IMPORTANT : exiger une plage EXACTE (1 jour) — sinon Traccar renvoie un volume énorme et lent.
  if (sub === 'track' && method === 'GET') {
    try {
      const url = new URL(req.url, 'http://localhost')
      const device = await deviceFor(url)
      if (!device) return json(res, 404, { error: 'Aucun appareil GPS associé à ce technicien' })
      const from = url.searchParams.get('from'); const to = url.searchParams.get('to')
      if (!from || !to) return json(res, 400, { error: 'from + to (ISO 8601) requis' })
      const pts = await traccarFetch(`/api/positions?deviceId=${encodeURIComponent(device)}&from=${encodeURIComponent(from)}&to=${encodeURIComponent(to)}`)
      const arr = (Array.isArray(pts) ? pts : []).filter(p => p.latitude != null && p.longitude != null)
      const coords = arr.map(p => [p.longitude, p.latitude])
      // Distance + temps de CONDUITE réels : segments > 25 m ET < 30 min d'écart (ignore la gigue GPS à l'arrêt + les trous de signal).
      let km = 0, movingMs = 0, firstT = null, lastT = null
      const tOf = p => Date.parse(p.fixTime || p.deviceTime || p.serverTime || 0) || 0
      for (let i = 0; i < arr.length; i++) {
        const t = tOf(arr[i]); if (t) { if (firstT == null) firstT = t; lastT = t }
        if (i > 0) {
          const d = haversineM(arr[i - 1].latitude, arr[i - 1].longitude, arr[i].latitude, arr[i].longitude)
          const dt = t - tOf(arr[i - 1])
          if (d > 25 && dt > 0 && dt < 1800000) { km += d; movingMs += dt }
        }
      }
      return json(res, 200, { device, count: coords.length, coords, km: Math.round(km / 100) / 10, moving_min: Math.round(movingMs / 60000), span_min: (firstT && lastT) ? Math.round((lastT - firstT) / 60000) : null })
    } catch (e) { log('Traccar track error:', e.message); return json(res, 502, { error: 'Traccar track indisponible' }) }
  }

  // Position GPS LIVE (dernière connue) d'un tech → pour fixer son domicile/point de départ à sa position actuelle.
  // ?tech=<id> (ou ?device=). Renvoie {ok, lat, lon, time, speed} ; ok:false si pas d'appareil associé / pas de fix.
  if (sub === 'live' && method === 'GET') {
    try {
      const url = new URL(req.url, 'http://localhost')
      const device = await deviceFor(url)
      if (!device) return json(res, 200, { ok: false, error: 'Aucun appareil GPS associé à ce technicien' })
      const pts = await traccarFetch('/api/positions?deviceId=' + encodeURIComponent(device))
      const p = (Array.isArray(pts) ? pts : [])[0]
      if (!p || p.latitude == null) return json(res, 200, { ok: false, error: 'Aucune position GPS récente' })
      return json(res, 200, { ok: true, device, lat: p.latitude, lon: p.longitude, time: p.fixTime || p.deviceTime || p.serverTime || null, speed: p.speed })
    } catch (e) { log('Traccar live error:', e.message); return json(res, 200, { ok: false, error: e.message }) }
  }

  // Proxy any other Traccar API path (fallback)
  if (method === 'GET') {
    try {
      return json(res, 200, await traccarFetch('/api/' + sub))
    } catch (e) {
      return json(res, 502, { error: e.message })
    }
  }

  json(res, 404, { error: 'Traccar endpoint not found' })
}

module.exports = { handle, getDevices, getPositions, getHistory, crossOnSite }
