import { describe, expect, test } from 'bun:test';
import {
  builtinAlertKey,
  failingKeysFromHealthItems,
  moduleAlertKey,
  moduleCheckAlertKey,
  parentModuleKey,
  parseAlertKey,
  severityForItemStatus,
} from './keys';

describe('alert key construction', () => {
  test('module-level key', () => {
    expect(moduleAlertKey('caddy')).toBe('module:caddy');
  });

  test('module check key', () => {
    expect(moduleCheckAlertKey('caddy', 'cert-validity')).toBe('module:caddy/check:cert-validity');
  });

  test('builtin key', () => {
    expect(builtinAlertKey('machines_reachable', 'machine', 'iot')).toBe(
      'builtin:machines_reachable/machine:iot',
    );
  });
});

describe('parseAlertKey', () => {
  test('round-trips a module-level key', () => {
    expect(parseAlertKey('module:caddy')).toEqual({ source: 'module', moduleId: 'caddy' });
  });

  test('round-trips a module check key', () => {
    expect(parseAlertKey('module:caddy/check:cert-validity')).toEqual({
      source: 'module',
      moduleId: 'caddy',
      check: 'cert-validity',
    });
  });

  test('round-trips a builtin key', () => {
    expect(parseAlertKey('builtin:machines_reachable/machine:iot')).toEqual({
      source: 'builtin',
      check: 'machines_reachable',
      targetKind: 'machine',
      targetId: 'iot',
    });
  });

  // Check ITEM names are module-authored and unconstrained. A key must survive
  // an author choosing punctuation, or alert identity silently corrupts.
  test('check name containing a colon survives', () => {
    const key = moduleCheckAlertKey('caddy', 'tls:handshake');
    expect(parseAlertKey(key)).toEqual({
      source: 'module',
      moduleId: 'caddy',
      check: 'tls:handshake',
    });
  });

  test('check name containing a slash survives', () => {
    const key = moduleCheckAlertKey('caddy', 'disk:/var');
    expect(parseAlertKey(key)).toEqual({
      source: 'module',
      moduleId: 'caddy',
      check: 'disk:/var',
    });
  });

  // The bare form is the built-in counterpart of the module-level key:
  // "the check itself could not run", so it has no target.
  test('a bare builtin key parses as the monitor-level form', () => {
    expect(parseAlertKey('builtin:machines_reachable')).toEqual({
      source: 'builtin',
      check: 'machines_reachable',
    });
  });

  test.each([
    ['', 'empty'],
    ['caddy', 'no source prefix'],
    ['module:', 'empty module id'],
    ['module:caddy/check:', 'empty check name'],
    ['builtin:', 'empty check name'],
    ['builtin:machines_reachable/iot', 'builtin target without a kind'],
    ['unknown:thing', 'unrecognized source'],
  ])('rejects %p (%s)', (key) => {
    expect(parseAlertKey(key)).toBeNull();
  });
});

describe('parentModuleKey', () => {
  test('an item key is owned by its module key', () => {
    expect(parentModuleKey('module:caddy/check:cert-validity')).toBe('module:caddy');
  });

  test('a module-level key has no parent', () => {
    expect(parentModuleKey('module:caddy')).toBeNull();
  });

  test('a builtin key has no module parent', () => {
    expect(parentModuleKey('builtin:machines_reachable/machine:iot')).toBeNull();
  });
});

describe('severityForItemStatus', () => {
  test('pass produces no alert', () => {
    expect(severityForItemStatus('pass', 'critical')).toBeNull();
  });

  test('warn is always warning, never the monitor severity', () => {
    expect(severityForItemStatus('warn', 'critical')).toBe('warning');
  });

  test('fail takes the monitor severity', () => {
    expect(severityForItemStatus('fail', 'critical')).toBe('critical');
    expect(severityForItemStatus('fail', 'warning')).toBe('warning');
  });

  test('skip produces no alert — a check that could not run is not a failure', () => {
    expect(severityForItemStatus('skip', 'critical')).toBeNull();
  });
});

describe('failingKeysFromHealthItems', () => {
  const items = [
    { name: 'disk-space', status: 'fail' as const, message: '/var 94% used' },
    { name: 'cert-validity', status: 'pass' as const, message: 'expires in 62d' },
    { name: 'upstream', status: 'warn' as const, message: 'slow', details: '900ms' },
  ];

  test('only non-passing items produce keys', () => {
    const failing = failingKeysFromHealthItems('caddy', items, 'critical');
    expect(failing.map((f) => f.key)).toEqual([
      'module:caddy/check:disk-space',
      'module:caddy/check:upstream',
    ]);
  });

  test('severity follows the item status, not the monitor alone', () => {
    const failing = failingKeysFromHealthItems('caddy', items, 'critical');
    expect(failing.find((f) => f.key.endsWith('disk-space'))?.severity).toBe('critical');
    expect(failing.find((f) => f.key.endsWith('upstream'))?.severity).toBe('warning');
  });

  test('message and details are carried through', () => {
    const failing = failingKeysFromHealthItems('caddy', items, 'critical');
    const upstream = failing.find((f) => f.key.endsWith('upstream'));
    expect(upstream?.message).toBe('slow');
    expect(upstream?.details).toBe('900ms');
  });

  // The empty set here means "ran, found nothing wrong" — trustworthy.
  // The dangerous empty set (could not run) never reaches this function.
  test('all-passing produces an empty failing set', () => {
    const allPass = [{ name: 'x', status: 'pass' as const, message: 'ok' }];
    expect(failingKeysFromHealthItems('caddy', allPass, 'critical')).toEqual([]);
  });
});