import { describe, it, expect, jest, beforeEach } from '@jest/globals';
import type { ResolvedCLIConfig } from '../src/providers/cli/presets';
import type { CLIRunResult } from '../src/providers/cli/process-runner';

// ESM-compatible mock setup
const mockRunCLIProcess = jest.fn<(options: unknown) => Promise<CLIRunResult>>();

jest.unstable_mockModule('../src/providers/cli/process-runner', () => ({
  runCLIProcess: mockRunCLIProcess,
}));

jest.unstable_mockModule('../src/utils/logger', () => ({
  logger: {
    info: jest.fn(),
    warn: jest.fn(),
    error: jest.fn(),
    debug: jest.fn(),
  },
}));

// Dynamic import after mocking
const { CLIDuckProvider } = await import('../src/providers/cli/cli-provider');

function makeConfig(overrides: Partial<ResolvedCLIConfig> = {}): ResolvedCLIConfig {
  return {
    cli_command: 'test-cli',
    prompt_delivery: 'flag',
    prompt_flag: '-p',
    output_format: 'text',
    cli_args: [],
    process_timeout: 30000,
    nickname: 'Test CLI',
    cli_type: 'custom',
    ...overrides,
  };
}

describe('CLIDuckProvider', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });

  describe('chat()', () => {
    it('should spawn CLI with correct flag-based prompt delivery', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'CLI response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig());
      const result = await provider.chat({
        messages: [{ role: 'user', content: 'Hello CLI', timestamp: new Date() }],
      });

      expect(mockRunCLIProcess).toHaveBeenCalledWith(
        expect.objectContaining({
          command: 'test-cli',
          args: expect.arrayContaining(['-p', 'Hello CLI']),
        })
      );
      expect(result.content).toBe('CLI response');
      expect(result.finishReason).toBe('stop');
    });

    it('should not include prompt in args when flag delivery has no prompt_flag', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        prompt_delivery: 'flag',
        prompt_flag: undefined,
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'my prompt', timestamp: new Date() }],
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      // Prompt should NOT appear in args since there's no flag to deliver it with
      expect(callArgs.args).not.toContain('my prompt');
    });

    it('should use positional prompt delivery', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        prompt_delivery: 'positional',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'my prompt', timestamp: new Date() }],
      });

      expect(mockRunCLIProcess).toHaveBeenCalledWith(
        expect.objectContaining({
          args: expect.arrayContaining(['my prompt']),
        })
      );
    });

    it('should use stdin prompt delivery', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        prompt_delivery: 'stdin',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'stdin prompt', timestamp: new Date() }],
      });

      expect(mockRunCLIProcess).toHaveBeenCalledWith(
        expect.objectContaining({
          stdin: 'stdin prompt',
        })
      );
    });

    it('should parse JSON output correctly', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: JSON.stringify({ result: 'json response' }),
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        output_format: 'json',
        response_json_path: '$.result',
      }));
      const result = await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
      });

      expect(result.content).toBe('json response');
    });

    it('should parse JSONL output correctly', async () => {
      const stdout = [
        JSON.stringify({ type: 'progress', message: 'working' }),
        JSON.stringify({ type: 'result', content: 'final answer' }),
      ].join('\n');

      mockRunCLIProcess.mockResolvedValue({
        stdout,
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        output_format: 'jsonl',
      }));
      const result = await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
      });

      expect(result.content).toBe('final answer');
    });

    it('should surface CLI process errors as readable messages', async () => {
      mockRunCLIProcess.mockRejectedValue(new Error('CLI process "test-cli" exited with code 1: something went wrong'));

      const provider = new CLIDuckProvider('test', makeConfig());

      await expect(
        provider.chat({
          messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
        })
      ).rejects.toThrow(/Test CLI couldn't respond/);
    });

    it('should handle non-Error thrown objects', async () => {
      mockRunCLIProcess.mockRejectedValue('string error');

      const provider = new CLIDuckProvider('test', makeConfig());

      await expect(
        provider.chat({
          messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
        })
      ).rejects.toThrow(/Test CLI couldn't respond: string error/);
    });

    it('should return empty string when messages array is empty', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig());
      await provider.chat({
        messages: [],
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      // The -p flag should have an empty string as prompt
      expect(callArgs.args).toContain('-p');
      expect(callArgs.args).toContain('');
    });

    it('should include configured CLI args', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'ok',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_args: ['--verbose', '--no-color'],
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
      });

      expect(mockRunCLIProcess).toHaveBeenCalledWith(
        expect.objectContaining({
          args: expect.arrayContaining(['--verbose', '--no-color']),
        })
      );
    });

    it('should pass timeout and working directory', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'ok',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        process_timeout: 60000,
        working_directory: '/custom/dir',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
      });

      expect(mockRunCLIProcess).toHaveBeenCalledWith(
        expect.objectContaining({
          timeout: 60000,
          cwd: '/custom/dir',
        })
      );
    });

    it('should not duplicate system prompt for claude type with stdin delivery', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'claude',
        prompt_delivery: 'stdin',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'hello', timestamp: new Date() }],
        systemPrompt: 'Be helpful',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[]; stdin?: string };
      // System prompt should go via --system-prompt flag
      expect(callArgs.args).toContain('--system-prompt');
      expect(callArgs.args).toContain('Be helpful');
      // stdin should NOT contain the system prompt (only the user prompt)
      expect(callArgs.stdin).toBe('hello');
    });

    it('should remove duplicate --system-prompt from cli_args for claude type', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'claude',
        cli_args: ['--system-prompt', 'old prompt', '--verbose'],
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'hello', timestamp: new Date() }],
        systemPrompt: 'New prompt',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      // Should have the new system prompt, not the old one
      expect(callArgs.args).toContain('New prompt');
      expect(callArgs.args).not.toContain('old prompt');
      // Other args preserved
      expect(callArgs.args).toContain('--verbose');
      // Only one --system-prompt flag
      const spFlags = callArgs.args.filter(a => a === '--system-prompt');
      expect(spFlags).toHaveLength(1);
    });

    it('should prepend system prompt to stdin for non-claude type', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'custom',
        prompt_delivery: 'stdin',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'hello', timestamp: new Date() }],
        systemPrompt: 'Be helpful',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { stdin?: string };
      expect(callArgs.stdin).toBe('Be helpful\n\nhello');
    });

    it('should not add model flag for custom cli_type', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'custom',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
        model: 'some-model',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      // Custom cli_type has no model flag mapping, so model should not appear in args
      expect(callArgs.args).not.toContain('--model');
      expect(callArgs.args).not.toContain('-m');
      expect(callArgs.args).not.toContain('some-model');
    });

    it('should prepend system prompt to prompt for flag delivery non-claude type', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'custom',
        prompt_delivery: 'flag',
        prompt_flag: '-p',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'hello', timestamp: new Date() }],
        systemPrompt: 'Be brief',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      // System prompt should be prepended to the prompt value
      expect(callArgs.args).toContain('-p');
      const flagIdx = callArgs.args.indexOf('-p');
      expect(callArgs.args[flagIdx + 1]).toBe('Be brief\n\nhello');
    });

    it('should use last message content when no user message exists', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig());
      await provider.chat({
        messages: [{ role: 'assistant', content: 'assistant msg', timestamp: new Date() }],
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      expect(callArgs.args).toContain('assistant msg');
    });

    it('should add --model flag for claude cli_type', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'claude',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
        model: 'claude-sonnet-4-20250514',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      expect(callArgs.args).toContain('--model');
      expect(callArgs.args).toContain('claude-sonnet-4-20250514');
    });

    it('should reflect model override in response', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        default_model: 'default-model',
      }));
      const result = await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
        model: 'override-model',
      });

      expect(result.model).toBe('override-model');
    });

    it('should use default model in response when no override', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        default_model: 'my-default',
      }));
      const result = await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
      });

      expect(result.model).toBe('my-default');
    });

    it('should use "cli" as model fallback when nothing configured', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig());
      const result = await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
      });

      expect(result.model).toBe('cli');
    });

    it('should add --model flag for codex cli_type', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'codex',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
        model: 'codex-mini',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      expect(callArgs.args).toContain('--model');
      expect(callArgs.args).toContain('codex-mini');
    });

    it('should add --model flag for gemini cli_type', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'gemini',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
        model: 'gemini-pro',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      expect(callArgs.args).toContain('--model');
      expect(callArgs.args).toContain('gemini-pro');
    });

    it('should add -m flag for grok cli_type', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'grok',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
        model: 'grok-2',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      expect(callArgs.args).toContain('-m');
      expect(callArgs.args).toContain('grok-2');
    });

    it('should remove duplicate model flag from cli_args when model override is given', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      // Grok preset includes '-m grok-code-fast-1' in cli_args
      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'grok',
        cli_args: ['-m', 'grok-code-fast-1', '--verbose'],
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
        model: 'grok-2',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      // Should have the override model, not the default
      expect(callArgs.args).toContain('grok-2');
      expect(callArgs.args).not.toContain('grok-code-fast-1');
      // Other args should be preserved
      expect(callArgs.args).toContain('--verbose');
      // Only one -m flag
      const mFlags = callArgs.args.filter(a => a === '-m');
      expect(mFlags).toHaveLength(1);
    });

    it('should add --model flag for aider cli_type', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'response',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        cli_type: 'aider',
      }));
      await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
        model: 'gpt-4',
      });

      const callArgs = mockRunCLIProcess.mock.calls[0][0] as { args: string[] };
      expect(callArgs.args).toContain('--model');
      expect(callArgs.args).toContain('gpt-4');
    });

    it('should return usage stats from JSON output', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: JSON.stringify({
          result: 'hello',
          usage: { prompt_tokens: 10, completion_tokens: 20 },
        }),
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig({
        output_format: 'json',
        response_json_path: '$.result',
        usage_json_path: '$.usage',
      }));
      const result = await provider.chat({
        messages: [{ role: 'user', content: 'test', timestamp: new Date() }],
      });

      expect(result.usage).toEqual({
        promptTokens: 10,
        completionTokens: 20,
        totalTokens: 30,
      });
    });
  });

  describe('healthCheck()', () => {
    it('should return true on successful execution', async () => {
      mockRunCLIProcess.mockResolvedValue({
        stdout: 'hello',
        stderr: '',
        exitCode: 0,
      });

      const provider = new CLIDuckProvider('test', makeConfig());
      expect(await provider.healthCheck()).toBe(true);
    });

    it('should return false on error', async () => {
      mockRunCLIProcess.mockRejectedValue(new Error('command not found'));

      const provider = new CLIDuckProvider('test', makeConfig());
      expect(await provider.healthCheck()).toBe(false);
    });
  });

  describe('listModels()', () => {
    it('should return configured models', async () => {
      const provider = new CLIDuckProvider('test', makeConfig({
        models: ['model-a', 'model-b'],
      }));
      const models = await provider.listModels();

      expect(models).toHaveLength(2);
      expect(models[0].id).toBe('model-a');
      expect(models[1].id).toBe('model-b');
    });

    it('should return default model when no models configured', async () => {
      const provider = new CLIDuckProvider('test', makeConfig({
        default_model: 'my-model',
      }));
      const models = await provider.listModels();

      expect(models).toHaveLength(1);
      expect(models[0].id).toBe('my-model');
    });

    it('should return "default" when nothing is configured', async () => {
      const provider = new CLIDuckProvider('test', makeConfig());
      const models = await provider.listModels();

      expect(models).toHaveLength(1);
      expect(models[0].id).toBe('default');
    });
  });

  describe('getInfo()', () => {
    it('should return type: cli with correct fields', () => {
      const provider = new CLIDuckProvider('test', makeConfig({
        default_model: 'v1',
        cli_type: 'claude',
      }));
      const info = provider.getInfo();

      expect(info.type).toBe('cli');
      expect(info.name).toBe('test');
      expect(info.nickname).toBe('Test CLI');
      expect(info.model).toBe('v1');
      expect(info.cliCommand).toBe('test-cli');
      expect(info.cliType).toBe('claude');
    });

    it('should not include HTTP-specific fields', () => {
      const provider = new CLIDuckProvider('test', makeConfig());
      const info = provider.getInfo();

      expect(info.baseURL).toBeUndefined();
      expect(info.hasApiKey).toBeUndefined();
    });
  });
});