/**
 * The contract check.
 *
 * Signs in once, calls every endpoint the console reads, and reports what came
 * back: the HTTP status, the envelope, whether `details` is an array or an
 * object or null, how many rows, and — the part that matters — the keys on the
 * first row against the keys `src/api/types.ts` says to expect.
 *
 * This exists because field-name drift is invisible until a real payload
 * arrives, and it is the single most likely way connecting to the backend goes
 * wrong. It has already happened once from fixtures alone: POS health returns
 * `terminal_id` while the sales split returns `terminalid`, and an index
 * signature on the type let the wrong one typecheck in silence.
 *
 * READ-ONLY. Nothing here writes. Every create, update and import is left to a
 * person on a scratch tenant, because several of them are unscoped and one of
 * them moves stock.
 *
 * Run:
 *   npm run contract        (prompts for the password, hidden)
 *
 * Or, for CI, set NEARLE_EMAIL and NEARLE_PASSWORD in the environment. Neither
 * is ever written into this file — see the note beside EMAIL below.
 *
 * Plain JavaScript on purpose: it runs with the node you already have, with no
 * install step and no TypeScript loader in the way.
 *
 * The credentials are read from the environment and never printed, logged or
 * written to a file. Put them in front of the command rather than in a script,
 * and they stay out of your shell history if your shell is configured for it.
 */

import { createInterface } from 'node:readline';

const BASE = process.env['NEARLE_API'] ?? 'https://fiesta.nearle.app';

/**
 * `/web/pos`, not `/pos`.
 *
 * The `/v1/pos` group sits behind the terminal's session guard; the console's
 * copies of the same reads are registered under `/v1/web/pos`. Sweeping the
 * wrong one would report a surface the console never calls.
 */
const WEB = '/live/api/v1/web';
const POS = '/live/api/v1/web/pos';
const MOB = '/live/api/v1/mob';

/**
 * The account to sweep with.
 *
 * The email defaults because it is not a secret. The PASSWORD is never
 * defaulted and never written into this file: a password in source is
 * committed, synced to every machine that clones the repo, and survives in the
 * history after it is changed. It is read from the environment if set, and
 * otherwise typed at the prompt below, where it is not echoed and does not
 * reach the shell history.
 */
const EMAIL = process.env['NEARLE_EMAIL'] ?? 'care@nearle.in';

/** Reads a line without echoing it. */
function askHidden(question) {
  return new Promise((resolve) => {
    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true });
    const onData = (char) => {
      // Stop echoing everything except the newline that ends the answer.
      if (char.toString() !== '\n' && char.toString() !== '\r' && char.toString() !== '\u0004') {
        process.stdout.write('\u001b[2K\u001b[200D' + question + '*'.repeat(rl.line.length));
      }
    };
    process.stdin.on('data', onData);
    rl.question(question, (answer) => {
      process.stdin.off('data', onData);
      rl.close();
      process.stdout.write('\n');
      resolve(answer);
    });
  });
}

const PASSWORD =
  process.env['NEARLE_PASSWORD'] ?? (await askHidden(`Password for ${EMAIL}: `));

if (!PASSWORD) {
  console.error('No password given — nothing to sign in with.');
  process.exit(1);
}

async function call(path, init = {}) {
  const search = new URLSearchParams();
  for (const [key, value] of Object.entries(init.params ?? {})) {
    if (value === undefined || value === null || value === '') continue;
    search.set(key, String(value));
  }
  const query = search.toString();
  const response = await fetch(`${BASE}${path}${query ? `?${query}` : ''}`, {
    method: init.method ?? 'GET',
    headers: init.body
      ? { Accept: 'application/json', 'Content-Type': 'application/json' }
      : { Accept: 'application/json' },
    ...(init.body ? { body: JSON.stringify(init.body) } : {}),
  });
  let envelope = {};
  try {
    envelope = await response.json();
  } catch {
    envelope = { message: 'not JSON' };
  }
  return { http: response.status, envelope };
}

/**
 * A call that reports a dead host rather than crashing the run.
 *
 * A wrong `NEARLE_API`, a VPN that is not up, or one endpoint timing out should
 * leave the other twenty-four results on screen — a stack trace at check four
 * tells you nothing about checks five to twenty-five.
 */
async function attempt(path, init = {}) {
  try {
    return await call(path, init);
  } catch (cause) {
    return {
      http: 0,
      envelope: { status: false, message: `could not reach the server (${String(cause)})` },
    };
  }
}

/* ── Sign in ─────────────────────────────────────────────────────────────── */

const login = await attempt(`${WEB}/users/applogin`, {
  method: 'POST',
  // `configid` is not optional: the lookup is `WHERE authname = ? AND configid = ?`.
  body: { authname: EMAIL, password: PASSWORD, configid: 1 },
});

if (login.envelope.status !== true || !login.envelope.details) {
  console.error(
    `Sign-in failed — HTTP ${login.http}, code ${login.envelope.code}: ${login.envelope.message}`,
  );
  process.exit(1);
}

const me = login.envelope.details;
const tenantid = Number(me['tenantid'] ?? 0);
const locationid = Number(me['locationid'] ?? 0);
const issuperadmin = me['issuperadmin'] === true;

console.log('── signed in ─────────────────────────────────────────────');
console.log(`userid ${me['userid']} · roleid ${me['roleid']} · issuperadmin ${issuperadmin}`);
console.log(`tenantid ${tenantid} · locationid ${locationid} · ${me['locationname'] ?? '—'}`);
console.log('login keys:', Object.keys(me).sort().join(', '));
console.log('');

/**
 * A tenant and a branch to probe the scoped endpoints with.
 *
 * A super admin has neither of their own, so one is borrowed from the platform
 * list. Override with NEARLE_TENANT / NEARLE_LOCATION to aim at a specific one.
 */
let probeTenant = Number(process.env['NEARLE_TENANT'] ?? 0) || tenantid;
let probeLocation = Number(process.env['NEARLE_LOCATION'] ?? 0) || locationid;

if (!probeTenant) {
  const tenants = await attempt(`${WEB}/tenants/getalltenants`, {
    params: { pageno: 1, pagesize: 1 },
  });
  probeTenant = Number(tenants.envelope.details?.[0]?.['tenantid'] ?? 0);
}
if (probeTenant && !probeLocation) {
  const locations = await attempt(`${WEB}/tenants/gettenantlocations`, {
    params: { tenantid: probeTenant },
  });
  probeLocation = Number(locations.envelope.details?.[0]?.['locationid'] ?? 0);
}

console.log(`probing with tenantid ${probeTenant} · locationid ${probeLocation}\n`);

/* ── What we expect ──────────────────────────────────────────────────────── */

/**
 * The keys each row should carry, taken from `src/api/types.ts`.
 *
 * Only the ones the console actually reads are listed — a backend that returns
 * MORE than this is fine and normal, and is reported as extras rather than as a
 * failure. What matters is anything missing.
 */
const CHECKS = [
  {
    name: 'tenants/getalltenants',
    path: `${WEB}/tenants/getalltenants`,
    params: { pageno: 1, pagesize: 5 },
    expect: ['tenantid', 'tenantname', 'locationid', 'locationname', 'status'],
  },
  {
    name: 'tenants/search?pending',
    path: `${WEB}/tenants/search`,
    params: { status: 'pending' },
    expect: ['tenantid', 'tenantname'],
  },
  {
    name: 'tenants/gettenantlocations',
    path: `${WEB}/tenants/gettenantlocations`,
    params: { tenantid: probeTenant },
    needs: 'tenant',
    expect: ['locationid', 'tenantid', 'locationname', 'status'],
  },
  {
    name: 'utils/getappcategories',
    path: `${WEB}/utils/getappcategories`,
    expect: ['categoryid', 'categoryname'],
  },
  {
    name: 'orders/getlocationsummary',
    path: `${WEB}/orders/getlocationsummary`,
    params: { tenantid: probeTenant },
    needs: 'tenant',
    expect: ['locationid', 'locationname', 'total', 'delivered', 'cancelled'],
  },
  {
    name: 'orders/getordersummary',
    path: `${WEB}/orders/getordersummary`,
    params: { tenantid: probeTenant },
    needs: 'tenant',
    expect: ['total', 'delivered', 'cancelled'],
  },
  {
    name: 'catalogue/getbrands',
    path: `${WEB}/catalogue/getbrands`,
    expect: ['brand', 'product_count'],
  },
  {
    name: 'catalogue/getproducts',
    path: `${WEB}/catalogue/getproducts`,
    params: { pageno: 1, pagesize: 5 },
    expect: ['id', 'brand', 'product_name'],
  },
  {
    name: 'products/getimportedcatalogueproducts',
    path: `${WEB}/products/getimportedcatalogueproducts`,
    params: { tenantid: probeTenant },
    needs: 'tenant',
    expect: ['brand', 'catalogueid'],
  },
  {
    name: 'products/getproductcategories',
    path: `${WEB}/products/getproductcategories`,
    params: { tenantid: probeTenant },
    needs: 'tenant',
    expect: ['categoryid', 'categoryname'],
  },
  {
    name: 'products/gettenantcategories',
    path: `${WEB}/products/gettenantcategories`,
    params: { tenantid: probeTenant },
    needs: 'tenant',
    expect: ['categoryid', 'categoryname'],
  },
  {
    name: 'products/getlocationproducts',
    path: `${WEB}/products/getlocationproducts`,
    params: { tenantid: probeTenant, locationid: probeLocation, pageno: 1, pagesize: 5 },
    needs: 'location',
    expect: ['productid', 'productname', 'price', 'publishedat', 'status'],
  },
  {
    name: 'products/getallproducts',
    path: `${WEB}/products/getallproducts`,
    params: { tenantid: probeTenant, pageno: 1, pagesize: 5 },
    needs: 'tenant',
    expect: ['productid', 'productname'],
  },
  {
    name: 'products/getstockstatement',
    path: `${WEB}/products/getstockstatement`,
    params: { tenantid: probeTenant, locationid: probeLocation, pageno: 1, pagesize: 5 },
    needs: 'location',
    expect: ['productid', 'opening', 'credit', 'debit', 'closing'],
  },
  {
    name: 'products/getstockrequests',
    path: `${WEB}/products/getstockrequests`,
    params: { tenantid: probeTenant, locationid: probeLocation, pageno: 1, pagesize: 5 },
    needs: 'tenant',
    expect: ['requestid', 'productid', 'qty', 'status'],
  },
  {
    name: 'products/getsaletemplate',
    path: `${WEB}/products/getsaletemplate`,
    params: { tenantid: probeTenant, locationid: probeLocation },
    needs: 'tenant',
    expect: ['tenantid', 'locations', 'products'],
  },
  {
    name: 'customers/gettenantcustomers',
    path: `${WEB}/customers/gettenantcustomers`,
    params: { tenantid: probeTenant, locationid: probeLocation, pageno: 1, pagesize: 5 },
    needs: 'tenant',
    expect: ['customerid', 'firstname', 'contactno'],
  },
  {
    name: 'orders/getorders',
    path: `${WEB}/orders/tenant/getorders`,
    params: {
      tenantid: probeTenant,
      locationid: probeLocation,
      fromdate: isoDaysAgo(30),
      todate: isoDaysAgo(0),
      pageno: 1,
      pagesize: 5,
    },
    needs: 'tenant',
    expect: ['orderheaderid', 'orderstatus'],
  },
  {
    name: 'deliveries/getdeliveries',
    path: `${WEB}/deliveries/getdeliveries`,
    params: {
      tenantid: probeTenant,
      locationid: probeLocation,
      fromdate: isoDaysAgo(30),
      todate: isoDaysAgo(0),
      pageno: 1,
      pagesize: 5,
    },
    needs: 'tenant',
    expect: ['orderheaderid', 'orderstatus'],
  },
  {
    name: 'pos/sales/summary',
    path: `${POS}/sales/summary`,
    params: { locationid: probeLocation, fromdate: isoDaysAgo(7), todate: isoDaysAgo(0) },
    needs: 'location',
    expect: ['billcount', 'grosssales', 'taxcollected'],
  },
  {
    name: 'pos/sales',
    path: `${POS}/sales`,
    params: { locationid: probeLocation, pageno: 0, pagesize: 5 },
    needs: 'location',
    expect: ['bills', 'total'],
  },
  {
    name: 'pos/health/location',
    path: `${POS}/health/location`,
    params: { location_id: probeLocation },
    needs: 'location',
    expect: ['total', 'online', 'terminals'],
  },
  {
    name: 'tenants/getposusers',
    path: `${WEB}/tenants/getposusers`,
    params: { tenantid: probeTenant, locationid: probeLocation },
    needs: 'location',
    expect: ['users', 'location_id'],
  },
  {
    name: 'tenants/getstaffs (MOB)',
    path: `${MOB}/tenants/getstaffs`,
    params: { tenantid: probeTenant },
    needs: 'tenant',
    expect: ['userid', 'rolename', 'firstname'],
  },
  { name: 'tenants/posroles', path: `${WEB}/tenants/posroles`, expect: ['role_id', 'role'] },
  {
    name: 'tenants/getstaffshifts',
    path: `${WEB}/tenants/getstaffshifts`,
    params: { tenantid: probeTenant, locationid: probeLocation },
    needs: 'location',
    expect: ['shifts', 'location_id'],
  },
];

function isoDaysAgo(days) {
  const date = new Date();
  date.setDate(date.getDate() - days);
  return date.toISOString().slice(0, 10);
}

/* ── Run ─────────────────────────────────────────────────────────────────── */

let mismatches = 0;
let unreachable = 0;

for (const check of CHECKS) {
  if (check.needs === 'tenant' && !probeTenant) {
    console.log(`SKIP  ${check.name} — no tenant to probe with`);
    continue;
  }
  if (check.needs === 'location' && !probeLocation) {
    console.log(`SKIP  ${check.name} — no location to probe with`);
    continue;
  }

  const { http, envelope } = await attempt(check.path, { params: check.params });
  const payload = envelope.details ?? envelope.data;

  const shape = Array.isArray(payload)
    ? `array(${payload.length})`
    : payload === null || payload === undefined
      ? 'null'
      : typeof payload;

  // The row to inspect: the first element of a list, or the object itself.
  const row = Array.isArray(payload) ? payload[0] : payload;
  const keys = row && typeof row === 'object' ? Object.keys(row) : [];
  const missing = check.expect.filter((key) => !keys.includes(key));

  const ok = envelope.status !== false && http < 400 && missing.length === 0;
  if (!ok) mismatches += 1;
  if (http >= 400 || envelope.status === false) unreachable += 1;

  console.log(
    `${ok ? 'OK   ' : 'CHECK'} ${check.name.padEnd(38)} http ${http} · code ${envelope.code ?? '—'} · ${shape}`,
  );
  if (envelope.status === false || http >= 400) {
    console.log(`      message: ${envelope.message ?? '(none)'}`);
  }
  if (missing.length > 0 && keys.length > 0) {
    console.log(`      MISSING: ${missing.join(', ')}`);
    console.log(`      got:     ${keys.sort().join(', ')}`);
  }
  if (keys.length === 0 && shape !== 'null' && !Array.isArray(payload)) {
    console.log(`      payload: ${JSON.stringify(payload).slice(0, 160)}`);
  }
}

console.log('');
console.log(`${CHECKS.length} checked · ${mismatches} to look at · ${unreachable} refused`);
console.log(
  mismatches === 0
    ? 'Every endpoint answered in the shape the console expects.'
    : 'Anything marked CHECK either refused the call or is missing a key the console reads.',
);