/**
 * 起錶與停錶。
 *
 * 錶是工時報表的唯一來源，所以起錶那一半的價值全在「什麼時候不該起」：工作樹還沒建好
 * 不該起（那由流程的順序保證），自己的錶已經跑在別顆議題上更不該起——那會把兩顆
 * 工作包的時間攪在一起。
 *
 * `--stop` 只停 `--index` 指的那一顆。每個階段停掉自己起的那支錶，錶就不會跨階段跑；
 * 但別顆議題上的錶一律不碰——那一段時間該記在哪顆議題上只有人知道，而靜默替人結算
 * 正是領取鎖那條規則當初要擋的事。
 */
import test from 'node:test';
import assert from 'node:assert/strict';
import { runScript } from './helpers/run-script.js';
import { healthyRoutes, stubEnv as envFor, withStubGitea } from './helpers/stub-gitea.js';

const REPO = 'plugins/tea-sdlc';
const INDEX = 40;

/** 議題上跑著的碼錶長什麼樣 */
const stopwatchOn = (index, repo = REPO) => ({
  issue_index: index,
  repo_owner_name: repo.split('/')[0],
  repo_name: repo.split('/')[1],
});

function routes(overrides = {}, { stopwatches = [] } = {}) {
  return healthyRoutes(REPO, {
    [`GET /api/v1/repos/${REPO}/issues/${INDEX}`]: {
      status: 200,
      body: {
        number: INDEX,
        title: '以 worktree 建立工作包分支並備妥隔離環境',
        html_url: `https://gitea.jsc.idv.tw/${REPO}/issues/${INDEX}`,
      },
    },
    'GET /api/v1/user/stopwatches': { status: 200, body: stopwatches },
    [`POST /api/v1/repos/${REPO}/issues/${INDEX}/stopwatch/start`]: { status: 201, body: {} },
    [`POST /api/v1/repos/${REPO}/issues/${INDEX}/stopwatch/stop`]: { status: 200, body: {} },
    ...overrides,
  });
}

const withStub = (t, overrides = {}, options) => withStubGitea(t, routes(overrides, options));

const run = (args, stub) =>
  runScript('timer.js', ['--repo', REPO, '--index', String(INDEX), ...args], { env: envFor(stub) });

/** 會改動 Gitea 的請求；前置檢查打在 issues/0 的探針不算（見 lib 的 checkIssueWrite） */
const writes = (stub) =>
  stub.requests.filter((r) => r.method !== 'GET').filter((r) => !r.path.endsWith('/issues/0'));

test('沒有錶在跑時起錶，並回報起在哪一顆上', async (t) => {
  const stub = await withStub(t);

  const { code, json } = await run([], stub);

  assert.equal(code, 0, json.error?.message);
  assert.equal(json.data.碼錶中, true);
  assert.equal(json.data.index, INDEX);
  assert.deepEqual(
    writes(stub).map((r) => `${r.method} ${r.path}`),
    [`POST /api/v1/repos/${REPO}/issues/${INDEX}/stopwatch/start`],
  );
});

test('錶已經跑在這顆議題上時什麼都不做，重跑不會把計時打斷', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(INDEX)] });

  const { code, json } = await run([], stub);

  assert.equal(code, 0, json.error?.message);
  assert.equal(json.data.碼錶中, true);
  assert.equal(json.data.已在計時, true, '要如實說這顆本來就在計時，不要假裝是這次起的');
  assert.deepEqual(writes(stub), [], '重新起錶會把已經累積的時間切成兩段');
});

test('錶跑在別顆議題上時擋下，並指出是哪一顆', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(7)] });

  const { code, json } = await run([], stub);

  assert.equal(code, 1);
  assert.equal(json.error.code, 'STOPWATCH_ON_OTHER_ISSUE');
  assert.match(json.error.message, /#7/, '忘了停掉的是哪一顆，要指名');
  assert.deepEqual(writes(stub), [], '擋下來就不該寫進任何東西');
});

test('別的 repo 上的同號碼錶也算自己有錶在跑', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(INDEX, 'plugins/別的專案')] });

  const { json } = await run([], stub);

  assert.equal(json.error.code, 'STOPWATCH_ON_OTHER_ISSUE');
  assert.match(json.error.message, /別的專案/);
});

test('不代替使用者停錶：訊息要說清楚下一步是他自己去停', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(7)] });

  const { json } = await run([], stub);

  assert.match(json.error.message, /停/);
  assert.match(
    json.error.message,
    /不會動到任何既有的工作樹/,
    '碼錶只管時間、工作樹只管檔案；不講清楚，使用者會以為停錶等於放棄那顆工作包',
  );
});

test('議題不存在時回可區分的錯誤碼', async (t) => {
  const stub = await withStub(t, {
    [`GET /api/v1/repos/${REPO}/issues/${INDEX}`]: { status: 404, body: { message: 'not found' } },
  });

  const { json } = await run([], stub);

  assert.equal(json.error.code, 'ISSUE_NOT_FOUND');
  assert.deepEqual(writes(stub), []);
});

test('--index 不是正整數時擋在打 Gitea 之前', async (t) => {
  const stub = await withStub(t);

  const { json } = await runScript('timer.js', ['--repo', REPO, '--index', '0'], {
    env: envFor(stub),
  });

  assert.equal(json.error.code, 'BAD_INDEX');
  assert.equal(stub.requests.length, 0);
});

test('--dry-run 印出將發出的寫入，但一個字都不寫進去', async (t) => {
  const stub = await withStub(t);

  const { code, json } = await run(['--dry-run'], stub);

  assert.equal(code, 0);
  assert.equal(json.data.dryRun, true);
  assert.deepEqual(
    json.data.requests.map((r) => `${r.method} ${r.path}`),
    [`POST /repos/${REPO}/issues/${INDEX}/stopwatch/start`],
  );
  assert.deepEqual(writes(stub), [], '預覽不得真的寫入');
});

test('--dry-run 會先讀現況：已經在計時時預覽出來就是什麼都不做', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(INDEX)] });

  const { json } = await run(['--dry-run'], stub);

  assert.deepEqual(json.data.requests, [], '手寫一份固定的清單會跟實作走鐘');
  assert.equal(json.data.已在計時, true);
});

// ── 停錶 ───────────────────────────────────────────────────────────

test('--stop 停掉跑在這顆議題上的錶', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(INDEX)] });

  const { code, json } = await run(['--stop'], stub);

  assert.equal(code, 0, json.error?.message);
  assert.equal(json.data.碼錶已停, true);
  assert.deepEqual(
    writes(stub).map((r) => `${r.method} ${r.path}`),
    [`POST /api/v1/repos/${REPO}/issues/${INDEX}/stopwatch/stop`],
  );
});

test('--stop 在錶本來就沒在跑時不算失敗，並說明這一步略過了', async (t) => {
  const stub = await withStub(t);

  const { code, json } = await run(['--stop'], stub);

  assert.equal(code, 0, '這一步多半排在回報之前，報成失敗會讓人以為前面那件事沒做成');
  assert.equal(json.data.碼錶已停, false);
  assert.match(json.data.note, /沒在/);
  assert.deepEqual(writes(stub), []);
});

test('--stop 不碰別顆議題上的錶：錶在別顆時什麼都不停', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(7)] });

  const { code, json } = await run(['--stop'], stub);

  assert.equal(code, 0);
  assert.equal(json.data.碼錶已停, false);
  assert.deepEqual(writes(stub), [], '靜默替人結算別顆議題，正是領取鎖那條規則要擋的事');
});

test('--stop 的 --dry-run 印出將發出的停錶，且不真的停', async (t) => {
  const stub = await withStub(t, {}, { stopwatches: [stopwatchOn(INDEX)] });

  const { code, json } = await run(['--stop', '--dry-run'], stub);

  assert.equal(code, 0);
  assert.equal(json.data.dryRun, true);
  assert.deepEqual(
    json.data.requests.map((r) => `${r.method} ${r.path}`),
    [`POST /repos/${REPO}/issues/${INDEX}/stopwatch/stop`],
  );
  assert.deepEqual(writes(stub), []);
});

test('--stop 認得站台把「沒有錶在跑」回成 409 或 500 的兩種寫法', async (t) => {
  for (const status of [409, 500]) {
    const stub = await withStubGitea(
      t,
      routes(
        {
          [`POST /api/v1/repos/${REPO}/issues/${INDEX}/stopwatch/stop`]: {
            status,
            body: { message: 'cannot stop non existent stopwatch' },
          },
        },
        { stopwatches: [stopwatchOn(INDEX)] },
      ),
    );

    const { code, json } = await run(['--stop'], stub);

    assert.equal(code, 0, `${status} 若說的是碼錶，就不是真的伺服器錯誤`);
    assert.equal(json.data.碼錶已停, false);
  }
});

test('--stop 遇到真的伺服器錯誤時照樣失敗，不吞掉', async (t) => {
  const stub = await withStub(
    t,
    {
      [`POST /api/v1/repos/${REPO}/issues/${INDEX}/stopwatch/stop`]: {
        status: 500,
        body: { message: 'database is on fire' },
      },
    },
    { stopwatches: [stopwatchOn(INDEX)] },
  );

  const { code, json } = await run(['--stop'], stub);

  assert.equal(code, 1);
  assert.equal(json.error.code, 'HTTP_ERROR');
});