import { describe, expect, test } from 'bun:test';
import { EnsureInputSchema, EnsureSchema } from './schema';

describe('EnsureInputSchema', () => {
  test('append_to_array with config target', () => {
    const result = EnsureInputSchema.safeParse({
      kind: 'append_to_array',
      target: 'config.additional_domains',
    });
    expect(result.success).toBe(true);
  });

  test('append_to_array with secret target', () => {
    // `append_to_array` is allowed against either scope by schema; runtime
    // currently only implements config but the schema is permissive so
    // future modules can extend.
    const result = EnsureInputSchema.safeParse({
      kind: 'append_to_array',
      target: 'secret.allowed_domains',
    });
    expect(result.success).toBe(true);
  });

  test('append_to_array rejects an invalid target prefix', () => {
    const result = EnsureInputSchema.safeParse({
      kind: 'append_to_array',
      target: 'output.domains',
    });
    expect(result.success).toBe(false);
  });

  test('set_in_object requires key and prompt', () => {
    const ok = EnsureInputSchema.safeParse({
      kind: 'set_in_object',
      target: 'secret.passwords',
      key: '{{value}}',
      prompt: 'Password for {{value}}',
    });
    expect(ok.success).toBe(true);

    const missingPrompt = EnsureInputSchema.safeParse({
      kind: 'set_in_object',
      target: 'secret.passwords',
      key: '{{value}}',
    });
    expect(missingPrompt.success).toBe(false);
  });

  test('rejects unknown kinds', () => {
    const result = EnsureInputSchema.safeParse({
      kind: 'mutate_universe',
      target: 'config.foo',
    });
    expect(result.success).toBe(false);
  });
});

describe('EnsureSchema', () => {
  test('full ensure block round-trips', () => {
    const result = EnsureSchema.safeParse({
      id: 'managed_domain',
      description: 'Add a domain.',
      inputs: [
        { kind: 'append_to_array', target: 'config.additional_domains' },
        {
          kind: 'set_in_object',
          target: 'secret.additional_ddns_passwords',
          key: '{{value}}',
          prompt: 'Password for {{value}}',
          hint: 'Find it in the panel',
        },
      ],
      post: 'redeploy_self',
    });
    expect(result.success).toBe(true);
    if (result.success) {
      expect(result.data.id).toBe('managed_domain');
      expect(result.data.inputs).toHaveLength(2);
      expect(result.data.post).toBe('redeploy_self');
    }
  });

  test('id must be snake_case', () => {
    const bad = EnsureSchema.safeParse({
      id: 'ManagedDomain',
      inputs: [{ kind: 'append_to_array', target: 'config.x' }],
    });
    expect(bad.success).toBe(false);
  });

  test('inputs cannot be empty', () => {
    const bad = EnsureSchema.safeParse({
      id: 'foo',
      inputs: [],
    });
    expect(bad.success).toBe(false);
  });

  test('post is optional', () => {
    const ok = EnsureSchema.safeParse({
      id: 'foo',
      inputs: [{ kind: 'append_to_array', target: 'config.x' }],
    });
    expect(ok.success).toBe(true);
  });

  test('rejects unknown post action', () => {
    const bad = EnsureSchema.safeParse({
      id: 'foo',
      inputs: [{ kind: 'append_to_array', target: 'config.x' }],
      post: 'restart_service',
    });
    expect(bad.success).toBe(false);
  });
});