/**
 * Automations alias REST API Route Tests (UX-Refactor Phase 3, S11/S20 / B4).
 *
 * Covers the 7 routes in routes/automations.ts, asserting alias delegation onto
 * the REAL cron handlers (cronRoutes + the history route from the REAL
 * notificationRoutes are registered on the test server, backed by a real
 * CronStore + a real LocalScheduler with a recording fake executor):
 *   GET    /api/automations            alias GET /api/cron, reshaped
 *   POST   /api/automations            alias POST /api/cron (C24/C25 in job_config)
 *   PATCH  /api/automations/:id        alias PATCH /api/cron/:id (jobConfig merge,
 *                                      stored trigger type preserved)
 *   POST   /api/automations/:id/run    alias /api/cron/:id/trigger (auto-enable
 *                                      kept for schedules; manual rows re-disable)
 *   POST   /api/automations/:id/pause  NET-NEW thin (enabled=0 + failure reset)
 *   GET    /api/automations/:id/logs   alias /api/cron/:id/history, camelCased
 *   POST   /api/automations/test       C26 VALIDATION-ONLY preview (no execution)
 *
 * The onJobComplete callback IS the prod wiring: makeRecordExecutionCallback
 * (cron.ts) — the same closure local/index.ts installs — so the logs alias is
 * tested against the real persistence path, not a hand-copied mirror.
 */

import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import os from 'node:os';
import Fastify from 'fastify';
import { EventEmitter } from 'node:events';
import { MindDB, CronStore, type CronSchedule } from '@waggle/core';
import { LocalScheduler, makeRecordExecutionCallback } from '../../src/local/cron.js';
import { cronRoutes } from '../../src/local/routes/cron.js';
import { notificationRoutes } from '../../src/local/routes/notifications.js';
import { automationRoutes } from '../../src/local/routes/automations.js';

describe('Automations alias routes (Phase 3)', () => {
  let db: MindDB;
  let cronStore: CronStore;
  let scheduler: LocalScheduler;
  let executed: CronSchedule[];
  let failNext: boolean;
  let server: ReturnType<typeof Fastify>;

  beforeEach(async () => {
    db = new MindDB(':memory:');
    cronStore = new CronStore(db);
    executed = [];
    failNext = false;
    scheduler = new LocalScheduler(
      cronStore,
      async (schedule) => {
        executed.push(schedule);
        if (failNext) throw new Error('boom: executor failed');
      },
      // F2: the REAL prod history-persistence closure (also installed by
      // local/index.ts) — not a hand-copied mirror.
      makeRecordExecutionCallback(cronStore),
    );

    server = Fastify({ logger: false });
    server.decorate('localConfig', { dataDir: '' });
    server.decorate('cronStore', cronStore);
    server.decorate('scheduler', scheduler);
    server.decorate('eventBus', new EventEmitter());
    // Minimal workspace index for the /test workspaceId validation: 'ws-test'
    // is the only known workspace.
    server.decorate('workspaceManager', {
      get: (id: string) => (id === 'ws-test' ? { id, name: 'Test WS' } : undefined),
    });
    await server.register(cronRoutes);
    // F4: the real /api/cron/:id/history route (notifications.ts) — its only
    // decoration needs are cronStore + eventBus, both provided above.
    await server.register(notificationRoutes);
    await server.register(automationRoutes);
  });

  afterEach(async () => {
    await server.close();
    db.close();
  });

  async function createAutomation(body: Record<string, unknown>) {
    const res = await server.inject({ method: 'POST', url: '/api/automations', payload: body });
    expect(res.statusCode).toBe(201);
    return res.json().automation;
  }

  it('GET /api/automations/engine returns liveness + sovereignty identity', async () => {
    const res = await server.inject({ method: 'GET', url: '/api/automations/engine' });
    expect(res.statusCode).toBe(200);
    const { engine } = res.json();
    expect(engine.host).toBe(os.hostname());
    expect(engine.sovereign).toBe(true);
    expect(engine.device).toBe('this device');
    expect(engine.consecutiveFailureCap).toBe(5);
    expect(engine.running).toBe(false); // scheduler decorated but not started
  });

  it('engine reports running once the scheduler starts', async () => {
    scheduler.start(60_000);
    const res = await server.inject({ method: 'GET', url: '/api/automations/engine' });
    expect(res.json().engine.running).toBe(true);
    scheduler.stop();
  });

  const SCHEDULE_BODY = {
    name: 'Nightly digest',
    trigger: { type: 'schedule', cron: '0 2 * * *' },
    condition: 'only if new memories exist',
    actions: ['workspace_health'],
    workspaceId: 'ws-test',
  };

  it('POST creates a cron row carrying trigger/condition/actions in job_config (C25 advisory)', async () => {
    const automation = await createAutomation(SCHEDULE_BODY);
    expect(automation.triggerType).toBe('schedule');
    expect(automation.schedule).toBe('0 2 * * *');
    expect(automation.condition).toBe('only if new memories exist');
    expect(automation.actions).toEqual(['workspace_health']);
    expect(automation.status).toBe('active');

    // The substrate row is a plain cron schedule — alias, not a new store (B4).
    const row = cronStore.getById(parseInt(automation.id, 10))!;
    expect(row.job_type).toBe('workspace_health'); // recognized action → job type
    const jc = JSON.parse(row.job_config);
    expect(jc.trigger).toEqual({ type: 'schedule' });
    expect(jc.condition).toBe('only if new memories exist');
    expect(jc.actions).toEqual(['workspace_health']);
  });

  it('C24: rejects event triggers (schedule-only v1)', async () => {
    const res = await server.inject({
      method: 'POST', url: '/api/automations',
      payload: { ...SCHEDULE_BODY, trigger: { type: 'event' } },
    });
    expect(res.statusCode).toBe(400);
    expect(res.json().error).toMatch(/schedule-only/i);
  });

  it('POST validation: name required; schedule trigger requires a cron expression', async () => {
    expect((await server.inject({ method: 'POST', url: '/api/automations', payload: { trigger: { type: 'schedule', cron: '* * * * *' } } })).statusCode).toBe(400);
    expect((await server.inject({ method: 'POST', url: '/api/automations', payload: { name: 'X', trigger: { type: 'schedule' } } })).statusCode).toBe(400);
    // Invalid cron expression → the existing cron handler's 400 passes through.
    expect((await server.inject({ method: 'POST', url: '/api/automations', payload: { ...SCHEDULE_BODY, trigger: { type: 'schedule', cron: 'not-cron' } } })).statusCode).toBe(400);
  });

  it('manual trigger maps to a DISABLED schedule that only fires via /run', async () => {
    const automation = await createAutomation({ name: 'On demand', trigger: { type: 'manual' }, actions: ['workspace_health'] });
    expect(automation.triggerType).toBe('manual');
    expect(automation.status).toBe('paused');
    expect(cronStore.getById(parseInt(automation.id, 10))!.enabled).toBe(0);
  });

  it('agent_task create accepts the "*" fan-out workspace sentinel (Builder "All workspaces")', async () => {
    // The store REQUIRES a workspaceId for agent_task; '*' is the executor's
    // fan-out-to-all sentinel the Builder sends (2026-06-10 live-smoke fix).
    const automation = await createAutomation({
      name: 'Smoke parity', trigger: { type: 'manual' },
      jobType: 'agent_task', jobConfig: { prompt: 'do the thing' }, workspaceId: '*',
    });
    expect(cronStore.getById(parseInt(automation.id, 10))!.workspace_id).toBe('*');
  });

  it('GET reshapes existing cron rows onto the Automation contract', async () => {
    await createAutomation(SCHEDULE_BODY);
    // A pre-existing plain cron job (no automation vocabulary) still projects.
    cronStore.create({ name: 'legacy', cronExpr: '0 3 * * *', jobType: 'memory_consolidation' });
    const res = await server.inject({ method: 'GET', url: '/api/automations' });
    expect(res.statusCode).toBe(200);
    const { automations, count } = res.json();
    expect(count).toBe(2);
    const legacy = automations.find((a: { name: string }) => a.name === 'legacy');
    expect(legacy.triggerType).toBe('schedule');
    expect(legacy.actions).toEqual(['memory_consolidation']); // falls back to jobType
  });

  it('PATCH merges jobConfig-borne fields over the stored blob', async () => {
    const automation = await createAutomation(SCHEDULE_BODY);
    const res = await server.inject({
      method: 'PATCH', url: `/api/automations/${automation.id}`,
      payload: { name: 'Renamed', condition: 'new condition', enabled: false },
    });
    expect(res.statusCode).toBe(200);
    const updated = res.json().automation;
    expect(updated.name).toBe('Renamed');
    expect(updated.condition).toBe('new condition');
    expect(updated.status).toBe('paused');
    // actions persisted earlier survive the merge.
    expect(updated.actions).toEqual(['workspace_health']);
    expect((await server.inject({ method: 'PATCH', url: '/api/automations/9999', payload: { name: 'X' } })).statusCode).toBe(404);
  });

  it('PATCH without trigger keeps a manual automation manual + disabled (no clobber)', async () => {
    const automation = await createAutomation({ name: 'Manual job', trigger: { type: 'manual' }, actions: ['workspace_health'] });
    // An unrelated PATCH (condition only) used to flip trigger → 'schedule'.
    const res = await server.inject({
      method: 'PATCH', url: `/api/automations/${automation.id}`,
      payload: { condition: 'only weekdays' },
    });
    expect(res.statusCode).toBe(200);
    const updated = res.json().automation;
    expect(updated.triggerType).toBe('manual');
    expect(updated.status).toBe('paused');
    expect(updated.condition).toBe('only weekdays');
    expect(cronStore.getById(parseInt(automation.id, 10))!.enabled).toBe(0);
  });

  it('PATCH trigger to manual on an enabled schedule disables it (mirrors the POST rule)', async () => {
    const automation = await createAutomation(SCHEDULE_BODY);
    expect(automation.status).toBe('active');
    const res = await server.inject({
      method: 'PATCH', url: `/api/automations/${automation.id}`,
      payload: { trigger: { type: 'manual' } },
    });
    expect(res.statusCode).toBe(200);
    expect(res.json().automation.triggerType).toBe('manual');
    expect(res.json().automation.status).toBe('paused');
    expect(cronStore.getById(parseInt(automation.id, 10))!.enabled).toBe(0);
  });

  it('run aliases the trigger (executes + auto-enables a disabled SCHEDULE job, by design)', async () => {
    const automation = await createAutomation({ ...SCHEDULE_BODY, enabled: false });
    const res = await server.inject({ method: 'POST', url: `/api/automations/${automation.id}/run` });
    expect(res.statusCode).toBe(200);
    expect(res.json().triggered).toBe(true);
    expect(res.json().runId).toBe(automation.id);
    expect(res.json().autoEnabled).toBe(true);
    expect(executed).toHaveLength(1);
    expect(cronStore.getById(parseInt(automation.id, 10))!.enabled).toBe(1);
  });

  it('run on a MANUAL automation executes but re-disables it (placeholder cron never goes live)', async () => {
    const automation = await createAutomation({ name: 'On demand', trigger: { type: 'manual' }, actions: ['workspace_health'] });
    const res = await server.inject({ method: 'POST', url: `/api/automations/${automation.id}/run` });
    expect(res.statusCode).toBe(200);
    expect(res.json().triggered).toBe(true);
    expect(res.json().autoEnabled).toBe(false); // never reported as enabled
    expect(executed).toHaveLength(1);           // the run DID execute

    // The row stays disabled — its '0 0 1 1 *' placeholder must not become a
    // live yearly Jan-1 schedule after "Run now" (the M-43 auto-enable is
    // reverted for manual rows).
    expect(cronStore.getById(parseInt(automation.id, 10))!.enabled).toBe(0);
    const list = (await server.inject({ method: 'GET', url: '/api/automations' })).json();
    const row = list.automations.find((a: { id: string }) => a.id === automation.id);
    expect(row.status).toBe('paused');
  });

  it('pause disables the schedule without the enabled-flag trick', async () => {
    const automation = await createAutomation(SCHEDULE_BODY);
    const res = await server.inject({ method: 'POST', url: `/api/automations/${automation.id}/pause` });
    expect(res.statusCode).toBe(200);
    expect(res.json()).toEqual({ ok: true, id: parseInt(automation.id, 10), enabled: false });
    expect(cronStore.getById(parseInt(automation.id, 10))!.enabled).toBe(0);
    expect((await server.inject({ method: 'POST', url: '/api/automations/9999/pause' })).statusCode).toBe(404);
    expect((await server.inject({ method: 'POST', url: '/api/automations/abc/pause' })).statusCode).toBe(400);
  });

  it('logs alias the execution history, camelCased (C27 substrate)', async () => {
    const automation = await createAutomation(SCHEDULE_BODY);
    await server.inject({ method: 'POST', url: `/api/automations/${automation.id}/run` });
    failNext = true;
    await server.inject({ method: 'POST', url: `/api/automations/${automation.id}/run` });
    failNext = false;

    const res = await server.inject({ method: 'GET', url: `/api/automations/${automation.id}/logs` });
    expect(res.statusCode).toBe(200);
    const { logs, count } = res.json();
    expect(count).toBe(2);
    const ok = logs.filter((l: { success: boolean }) => l.success);
    const failed = logs.filter((l: { success: boolean }) => !l.success);
    expect(ok).toHaveLength(1);
    expect(failed).toHaveLength(1);
    expect(failed[0].error).toMatch(/boom/);
    expect(typeof logs[0].executedAt).toBe('string');
  });

  it('C26: test is a VALIDATION-ONLY preview — ok draft, zero execution, zero persistence', async () => {
    // A pre-existing disabled job proves the enable flag is untouched too.
    const disabled = cronStore.create({ name: 'sleepy', cronExpr: '0 4 * * *', jobType: 'workspace_health', enabled: false });

    const res = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: {
        name: 'Draft automation',
        trigger: { type: 'schedule', cron: '0 5 * * *' },
        actions: ['workspace_health'],
        condition: 'advisory only',
        workspaceId: 'ws-test',
      },
    });
    expect(res.statusCode).toBe(200);
    const { previewResult } = res.json();
    expect(previewResult).toMatchObject({
      ok: true,
      jobType: 'workspace_health',
      triggerType: 'schedule',
      issues: [],
      executed: false,
      condition: 'advisory only', // echoed as advisory (C25), never evaluated
    });
    expect(previewResult.wouldRun).toContain('workspace_health');
    expect(previewResult.wouldRun).toContain('0 5 * * *');

    // NOTHING ran or persisted: executor untouched, no schedule row, no
    // history row, no notification row, no enable-flag mutation.
    expect(executed).toHaveLength(0);
    expect(cronStore.list()).toHaveLength(1); // only the pre-existing disabled job
    expect(cronStore.getExecutionHistory(disabled.id)).toHaveLength(0);
    expect(cronStore.getNotifications()).toHaveLength(0);
    expect(cronStore.getById(disabled.id)!.enabled).toBe(0);
  });

  it('C26: bad cron / missing agent_task prompt / unknown workspace surface as issues (ok:false)', async () => {
    const badCron = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { trigger: { type: 'schedule', cron: 'not-cron' }, actions: ['workspace_health'] },
    });
    expect(badCron.statusCode).toBe(200);
    expect(badCron.json().previewResult.ok).toBe(false);
    expect(badCron.json().previewResult.issues.join(' ')).toMatch(/cron/i);

    // agent_task with no jobConfig.prompt — the executor would skip the run.
    const noPrompt = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { trigger: { type: 'schedule', cron: '0 5 * * *' }, jobType: 'agent_task' },
    });
    expect(noPrompt.json().previewResult.ok).toBe(false);
    expect(noPrompt.json().previewResult.issues.join(' ')).toMatch(/prompt/);
    // agent_task with a prompt but NO workspaceId — CronStore.create would
    // throw ('agent_task jobs require a workspace ID'), so the preview must
    // flag it instead of saying "valid" (2026-06-10 live-smoke regression).
    const noWs = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { trigger: { type: 'schedule', cron: '0 5 * * *' }, jobType: 'agent_task', jobConfig: { prompt: 'Summarize the day' } },
    });
    expect(noWs.json().previewResult.ok).toBe(false);
    expect(noWs.json().previewResult.issues.join(' ')).toMatch(/workspaceId/);
    // ...and WITH a prompt + the '*' fan-out sentinel the draft previews clean.
    const withPrompt = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { trigger: { type: 'schedule', cron: '0 5 * * *' }, jobType: 'agent_task', jobConfig: { prompt: 'Summarize the day' }, workspaceId: '*' },
    });
    expect(withPrompt.json().previewResult.ok).toBe(true);

    const badWs = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { trigger: { type: 'schedule', cron: '0 5 * * *' }, actions: ['workspace_health'], workspaceId: 'ws-nope' },
    });
    expect(badWs.json().previewResult.ok).toBe(false);
    expect(badWs.json().previewResult.issues.join(' ')).toMatch(/workspaceId/);

    // An empty draft resolves to agent_task with no prompt → issues, not a 400.
    const empty = await server.inject({ method: 'POST', url: '/api/automations/test', payload: {} });
    expect(empty.statusCode).toBe(200);
    expect(empty.json().previewResult.ok).toBe(false);

    // A 'loop' draft with no jobConfig.prompt — the loop executor would skip it,
    // so the preview must flag it (parity with the agent_task prompt check).
    const loopNoPrompt = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { trigger: { type: 'schedule', cron: '0 8 * * *' }, jobType: 'loop' },
    });
    expect(loopNoPrompt.json().previewResult.ok).toBe(false);
    expect(loopNoPrompt.json().previewResult.issues.join(' ')).toMatch(/prompt/);
    // ...and a loop WITH a prompt previews clean (no workspaceId required).
    const loopOk = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { trigger: { type: 'schedule', cron: '0 8 * * *' }, jobType: 'loop', jobConfig: { prompt: 'Brief me' } },
    });
    expect(loopOk.json().previewResult.ok).toBe(true);

    // Across ALL previews: nothing executed, nothing persisted.
    expect(executed).toHaveLength(0);
    expect(cronStore.list()).toHaveLength(0);
  });

  it('C26 (edit mode): a draft carrying the stored row id is judged against the REAL job, not the agent_task fallback', async () => {
    // A stored agent_task WITH a prompt: the bare edit-mode draft (no jobType/
    // jobConfig) used to phantom-flag "agent_task requires jobConfig.prompt".
    const agentTask = await createAutomation({
      name: 'Daily summary',
      trigger: { type: 'schedule', cron: '0 6 * * *' },
      jobType: 'agent_task',
      jobConfig: { prompt: 'Summarize the day' },
      workspaceId: 'ws-test', // agent_task creates require a workspace
    });
    const res = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { id: agentTask.id, name: 'Daily summary', trigger: { type: 'schedule', cron: '0 7 * * *' } },
    });
    expect(res.statusCode).toBe(200);
    expect(res.json().previewResult.ok).toBe(true);
    expect(res.json().previewResult.jobType).toBe('agent_task');

    // Stored non-agent_task rows resolve their real jobType (correct wouldRun).
    const consolidation = await createAutomation({
      name: 'Nightly consolidation',
      trigger: { type: 'schedule', cron: '0 3 * * *' },
      jobType: 'memory_consolidation',
    });
    const res2 = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { id: consolidation.id, name: 'Nightly consolidation', trigger: { type: 'schedule', cron: '0 3 * * *' } },
    });
    expect(res2.json().previewResult.ok).toBe(true);
    expect(res2.json().previewResult.jobType).toBe('memory_consolidation');

    // An unknown id degrades to the plain draft preview (agent_task fallback).
    const res3 = await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { id: '99999', name: 'ghost', trigger: { type: 'manual' } },
    });
    expect(res3.statusCode).toBe(200);
    expect(res3.json().previewResult.ok).toBe(false);

    // Still validation-only: nothing executed.
    expect(executed).toHaveLength(0);
  });

  it('C24: test rejects event triggers (contract-level 400)', async () => {
    expect((await server.inject({
      method: 'POST', url: '/api/automations/test',
      payload: { trigger: { type: 'event' }, actions: ['workspace_health'] },
    })).statusCode).toBe(400);
  });
});