import { describe, it, expect } from '@jest/globals';
import {
  parseTextOutput,
  parseJsonOutput,
  parseJsonlOutput,
  extractJsonPath,
} from '../src/providers/cli/output-parsers';

describe('extractJsonPath', () => {
  it('should extract nested paths with $. prefix', () => {
    const obj = { foo: { bar: { baz: 'hello' } } };
    expect(extractJsonPath(obj, '$.foo.bar.baz')).toBe('hello');
  });

  it('should extract paths without $. prefix', () => {
    const obj = { foo: { bar: 'hello' } };
    expect(extractJsonPath(obj, 'foo.bar')).toBe('hello');
  });

  it('should return undefined for missing keys', () => {
    const obj = { foo: 'bar' };
    expect(extractJsonPath(obj, '$.missing.key')).toBeUndefined();
  });

  it('should handle array access', () => {
    const obj = { items: ['a', 'b', 'c'] };
    expect(extractJsonPath(obj, '$.items[1]')).toBe('b');
  });

  it('should handle null values gracefully', () => {
    expect(extractJsonPath(null, '$.foo')).toBeUndefined();
    expect(extractJsonPath(undefined, '$.foo')).toBeUndefined();
  });

  it('should handle nested objects in arrays', () => {
    const obj = { data: [{ name: 'first' }, { name: 'second' }] };
    expect(extractJsonPath(obj, '$.data[0].name')).toBe('first');
  });

  it('should return the full object for empty path after $. strip', () => {
    const obj = { result: 'test' };
    expect(extractJsonPath(obj, '$.result')).toBe('test');
  });

  it('should handle $[index] syntax for root-level arrays', () => {
    const arr = ['a', 'b', 'c'];
    expect(extractJsonPath(arr, '$[0]')).toBe('a');
    expect(extractJsonPath(arr, '$[2]')).toBe('c');
  });

  it('should handle out-of-bounds array access', () => {
    const obj = { items: ['a'] };
    expect(extractJsonPath(obj, '$.items[5]')).toBeUndefined();
  });

  it('should return full object for empty path', () => {
    const obj = { a: 1 };
    expect(extractJsonPath(obj, '')).toEqual({ a: 1 });
  });

  it('should access numeric keys on non-array objects', () => {
    const obj = { data: { '0': 'first', '1': 'second' } };
    expect(extractJsonPath(obj, '$.data[0]')).toBe('first');
    expect(extractJsonPath(obj, '$.data[1]')).toBe('second');
  });

  it('should return undefined when traversing through a primitive', () => {
    // Trying to access a property on a number should return undefined
    const obj = { count: 42 };
    expect(extractJsonPath(obj, '$.count.foo')).toBeUndefined();
  });

  it('should handle deeply nested mixed array/object access', () => {
    const obj = { a: [{ b: [1, 2, 3] }] };
    expect(extractJsonPath(obj, '$.a[0].b[2]')).toBe(3);
  });
});

describe('parseTextOutput', () => {
  it('should trim whitespace from output', () => {
    expect(parseTextOutput('  hello world  \n')).toEqual({ content: 'hello world' });
  });

  it('should handle empty output', () => {
    expect(parseTextOutput('')).toEqual({ content: '' });
    expect(parseTextOutput('  \n  ')).toEqual({ content: '' });
  });

  it('should handle multiline output', () => {
    const output = '  Line 1\nLine 2\nLine 3  ';
    expect(parseTextOutput(output)).toEqual({ content: 'Line 1\nLine 2\nLine 3' });
  });
});

describe('parseJsonOutput', () => {
  it('should extract field via path', () => {
    const json = JSON.stringify({ result: 'hello world' });
    const result = parseJsonOutput(json, '$.result');
    expect(result.content).toBe('hello world');
  });

  it('should handle missing response path by trying common fields', () => {
    const json = JSON.stringify({ result: 'found it' });
    const result = parseJsonOutput(json);
    expect(result.content).toBe('found it');
  });

  it('should try "response" field as fallback', () => {
    const json = JSON.stringify({ response: 'from response field' });
    const result = parseJsonOutput(json);
    expect(result.content).toBe('from response field');
  });

  it('should try "content" field as fallback', () => {
    const json = JSON.stringify({ content: 'from content field' });
    const result = parseJsonOutput(json);
    expect(result.content).toBe('from content field');
  });

  it('should try "message" field as fallback', () => {
    const json = JSON.stringify({ message: 'from message field' });
    const result = parseJsonOutput(json);
    expect(result.content).toBe('from message field');
  });

  it('should handle invalid JSON by returning raw text', () => {
    const result = parseJsonOutput('not valid json');
    expect(result.content).toBe('not valid json');
  });

  it('should handle empty output', () => {
    const result = parseJsonOutput('');
    expect(result.content).toBe('');
  });

  it('should extract usage stats via usage path', () => {
    const json = JSON.stringify({
      result: 'hello',
      usage: {
        prompt_tokens: 10,
        completion_tokens: 20,
      },
    });
    const result = parseJsonOutput(json, '$.result', '$.usage');
    expect(result.content).toBe('hello');
    expect(result.usage).toEqual({
      promptTokens: 10,
      completionTokens: 20,
      totalTokens: 30,
    });
  });

  it('should handle usage with alternative field names', () => {
    const json = JSON.stringify({
      result: 'hello',
      stats: {
        input_tokens: 5,
        output_tokens: 15,
      },
    });
    const result = parseJsonOutput(json, '$.result', '$.stats');
    expect(result.usage).toEqual({
      promptTokens: 5,
      completionTokens: 15,
      totalTokens: 20,
    });
  });

  it('should stringify non-string extracted values', () => {
    const json = JSON.stringify({ data: { nested: true } });
    const result = parseJsonOutput(json, '$.data');
    expect(result.content).toBe('{"nested":true}');
  });

  it('should return full JSON when responsePath points to nonexistent field', () => {
    const obj = { result: 'hello', other: 'data' };
    const json = JSON.stringify(obj);
    const result = parseJsonOutput(json, '$.nonexistent');
    // Should fall back to stringifying the full object, not return "undefined"
    expect(result.content).toBe(json);
  });

  it('should return full JSON when responsePath points to null value', () => {
    const obj = { result: null, other: 'data' };
    const json = JSON.stringify(obj);
    const result = parseJsonOutput(json, '$.result');
    expect(result.content).toBe(json);
  });

  it('should handle JSON primitive values without response path', () => {
    // JSON.parse('42') gives number 42, not an object
    const result = parseJsonOutput('42');
    expect(result.content).toBe('42');

    const result2 = parseJsonOutput('"just a string"');
    expect(result2.content).toBe('just a string');

    const result3 = parseJsonOutput('true');
    expect(result3.content).toBe('true');
  });

  it('should handle numeric extracted values', () => {
    const json = JSON.stringify({ count: 42 });
    const result = parseJsonOutput(json, '$.count');
    expect(result.content).toBe('42');
  });

  it('should handle boolean extracted values', () => {
    const json = JSON.stringify({ success: true });
    const result = parseJsonOutput(json, '$.success');
    expect(result.content).toBe('true');
  });
});

describe('parseJsonlOutput', () => {
  it('should extract content from last line with result field', () => {
    const lines = [
      JSON.stringify({ type: 'start', id: '1' }),
      JSON.stringify({ type: 'progress', message: 'working' }),
      JSON.stringify({ type: 'result', result: 'final answer' }),
    ].join('\n');

    const result = parseJsonlOutput(lines);
    expect(result.content).toBe('final answer');
  });

  it('should extract via custom response path', () => {
    const lines = [
      JSON.stringify({ event: 'done', data: { answer: 'custom path' } }),
    ].join('\n');

    const result = parseJsonlOutput(lines, '$.data.answer');
    expect(result.content).toBe('custom path');
  });

  it('should handle single-line JSONL', () => {
    const line = JSON.stringify({ message: 'single line response' });
    const result = parseJsonlOutput(line);
    expect(result.content).toBe('single line response');
  });

  it('should handle empty stream', () => {
    const result = parseJsonlOutput('');
    expect(result.content).toBe('');
  });

  it('should skip non-JSON lines', () => {
    const lines = 'not json\n' + JSON.stringify({ content: 'valid' }) + '\nalso not json';
    const result = parseJsonlOutput(lines);
    expect(result.content).toBe('valid');
  });

  it('should use last matching field when multiple lines have content', () => {
    const lines = [
      JSON.stringify({ message: 'first' }),
      JSON.stringify({ message: 'second' }),
      JSON.stringify({ message: 'last' }),
    ].join('\n');

    const result = parseJsonlOutput(lines);
    expect(result.content).toBe('last');
  });

  it('should fall back to raw text when no JSON is found', () => {
    const result = parseJsonlOutput('just plain text');
    expect(result.content).toBe('just plain text');
  });

  it('should stringify last object when responsePath finds nothing in any line', () => {
    const lines = [
      JSON.stringify({ type: 'progress', data: 1 }),
      JSON.stringify({ type: 'done', data: 2 }),
    ].join('\n');

    const result = parseJsonlOutput(lines, '$.nonexistent.path');
    // Falls back to stringifying the last parsed object
    expect(result.content).toBe(JSON.stringify({ type: 'done', data: 2 }));
  });

  it('should extract content from "text" field', () => {
    const line = JSON.stringify({ text: 'from text field' });
    const result = parseJsonlOutput(line);
    expect(result.content).toBe('from text field');
  });

  it('should handle JSONL line that is a bare JSON string', () => {
    const lines = '"just a string"';
    const result = parseJsonlOutput(lines);
    expect(result.content).toBe('just a string');
  });

  it('should stringify last object when no common fields are present', () => {
    const lines = [
      JSON.stringify({ foo: 'bar', baz: 123 }),
    ].join('\n');

    const result = parseJsonlOutput(lines);
    expect(result.content).toBe(JSON.stringify({ foo: 'bar', baz: 123 }));
  });
});