/**
 * Tests for Hook Platform Adapters
 *
 * @module @agentkits/memory/hooks/__tests__/adapters.test
 */

import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
import { ClaudeCodeAdapter } from '../adapters/claude-code-adapter.js';
import { OpenCodeAdapter } from '../adapters/opencode-adapter.js';
import { GenericAdapter } from '../adapters/generic-adapter.js';
import { resolveAdapter } from '../adapters/platform-adapter.js';
import type { HookResult } from '../types.js';

describe('Platform Adapters', () => {
  const originalEnv = { ...process.env };

  afterEach(() => {
    process.env = { ...originalEnv };
    vi.restoreAllMocks();
  });

  // ===== resolveAdapter =====

  describe('resolveAdapter', () => {
    beforeEach(() => {
      delete process.env.AGENTKITS_PLATFORM;
    });

    it('should default to claude-code when no env var', () => {
      const adapter = resolveAdapter();
      expect(adapter.name).toBe('claude-code');
    });

    it('should resolve opencode from env var', () => {
      process.env.AGENTKITS_PLATFORM = 'opencode';
      const adapter = resolveAdapter();
      expect(adapter.name).toBe('opencode');
    });

    it('should resolve generic from env var', () => {
      process.env.AGENTKITS_PLATFORM = 'generic';
      const adapter = resolveAdapter();
      expect(adapter.name).toBe('generic');
    });

    it('should resolve claude-code from env var', () => {
      process.env.AGENTKITS_PLATFORM = 'claude-code';
      const adapter = resolveAdapter();
      expect(adapter.name).toBe('claude-code');
    });

    it('should fall back to claude-code for unknown platform', () => {
      process.env.AGENTKITS_PLATFORM = 'unknown-platform';
      const adapter = resolveAdapter();
      expect(adapter.name).toBe('claude-code');
    });
  });

  // ===== ClaudeCodeAdapter =====

  describe('ClaudeCodeAdapter', () => {
    const adapter = new ClaudeCodeAdapter();

    it('should have name claude-code', () => {
      expect(adapter.name).toBe('claude-code');
    });

    it('should support all 5 events', () => {
      expect(adapter.supportedEvents).toContain('context');
      expect(adapter.supportedEvents).toContain('session-init');
      expect(adapter.supportedEvents).toContain('observation');
      expect(adapter.supportedEvents).toContain('summarize');
      expect(adapter.supportedEvents).toContain('user-message');
    });

    describe('parseInput', () => {
      it('should parse valid Claude Code JSON', () => {
        const input = JSON.stringify({
          session_id: 'test-session',
          cwd: '/test/project',
          prompt: 'Hello world',
          tool_name: 'Edit',
          tool_input: { file_path: '/test/file.ts' },
          tool_result: 'success',
          transcript_path: '/test/transcript.jsonl',
          stop_reason: 'user',
        });

        const result = adapter.parseInput(input);
        expect(result.sessionId).toBe('test-session');
        expect(result.cwd).toBe('/test/project');
        expect(result.project).toBe('project');
        expect(result.prompt).toBe('Hello world');
        expect(result.toolName).toBe('Edit');
        expect(result.toolInput).toEqual({ file_path: '/test/file.ts' });
        expect(result.toolResponse).toBe('success');
        expect(result.transcriptPath).toBe('/test/transcript.jsonl');
        expect(result.stopReason).toBe('user');
        expect(result.timestamp).toBeGreaterThan(0);
      });

      it('should generate session ID when missing', () => {
        const result = adapter.parseInput(JSON.stringify({ cwd: '/test' }));
        expect(result.sessionId).toMatch(/^session_/);
      });

      it('should use process.cwd() when cwd missing', () => {
        const result = adapter.parseInput(JSON.stringify({ session_id: 'x' }));
        expect(result.cwd).toBe(process.cwd());
      });

      it('should handle invalid JSON gracefully', () => {
        const result = adapter.parseInput('not json');
        expect(result.sessionId).toMatch(/^session_/);
        expect(result.cwd).toBe(process.cwd());
      });

      it('should handle empty string', () => {
        const result = adapter.parseInput('');
        expect(result.sessionId).toMatch(/^session_/);
      });
    });

    describe('formatOutput', () => {
      it('should format result with additionalContext as SessionStart', () => {
        const result: HookResult = {
          continue: true,
          suppressOutput: false,
          additionalContext: 'Memory context here',
        };

        const output = JSON.parse(adapter.formatOutput(result));
        expect(output.hookSpecificOutput).toBeDefined();
        expect(output.hookSpecificOutput.hookEventName).toBe('SessionStart');
        expect(output.hookSpecificOutput.additionalContext).toBe('Memory context here');
      });

      it('should format standard response without context', () => {
        const result: HookResult = {
          continue: true,
          suppressOutput: true,
        };

        const output = JSON.parse(adapter.formatOutput(result));
        expect(output.continue).toBe(true);
        expect(output.suppressOutput).toBe(true);
        expect(output.hookSpecificOutput).toBeUndefined();
      });
    });
  });

  // ===== OpenCodeAdapter =====

  describe('OpenCodeAdapter', () => {
    const adapter = new OpenCodeAdapter();

    it('should have name opencode', () => {
      expect(adapter.name).toBe('opencode');
    });

    it('should support 4 events (no user-message)', () => {
      expect(adapter.supportedEvents).toContain('context');
      expect(adapter.supportedEvents).toContain('session-init');
      expect(adapter.supportedEvents).toContain('observation');
      expect(adapter.supportedEvents).toContain('summarize');
      expect(adapter.supportedEvents).not.toContain('user-message');
    });

    describe('parseInput', () => {
      it('should parse same format as Claude Code', () => {
        const input = JSON.stringify({
          session_id: 'oc-session',
          cwd: '/test/oc',
          prompt: 'Test prompt',
          tool_name: 'Bash',
        });

        const result = adapter.parseInput(input);
        expect(result.sessionId).toBe('oc-session');
        expect(result.cwd).toBe('/test/oc');
        expect(result.prompt).toBe('Test prompt');
        expect(result.toolName).toBe('Bash');
      });

      it('should handle invalid JSON', () => {
        const result = adapter.parseInput('broken');
        expect(result.sessionId).toMatch(/^session_/);
      });
    });

    describe('formatOutput', () => {
      it('should include additionalContext at top level', () => {
        const result: HookResult = {
          continue: true,
          suppressOutput: false,
          additionalContext: 'context text',
        };

        const output = JSON.parse(adapter.formatOutput(result));
        expect(output.continue).toBe(true);
        expect(output.additionalContext).toBe('context text');
        // OpenCode doesn't use hookSpecificOutput
        expect(output.hookSpecificOutput).toBeUndefined();
      });

      it('should include error when present', () => {
        const result: HookResult = {
          continue: true,
          suppressOutput: true,
          error: 'Something went wrong',
        };

        const output = JSON.parse(adapter.formatOutput(result));
        expect(output.error).toBe('Something went wrong');
      });

      it('should output minimal JSON without context or error', () => {
        const result: HookResult = {
          continue: true,
          suppressOutput: true,
        };

        const output = JSON.parse(adapter.formatOutput(result));
        expect(output.continue).toBe(true);
        expect(output.additionalContext).toBeUndefined();
        expect(output.error).toBeUndefined();
      });
    });
  });

  // ===== GenericAdapter =====

  describe('GenericAdapter', () => {
    const adapter = new GenericAdapter();

    it('should have name generic', () => {
      expect(adapter.name).toBe('generic');
    });

    describe('parseInput', () => {
      it('should parse camelCase fields', () => {
        const input = JSON.stringify({
          sessionId: 'gen-session',
          cwd: '/test/gen',
          prompt: 'Test',
          toolName: 'Read',
          toolInput: { file_path: '/x' },
          toolResponse: 'content',
          transcriptPath: '/test/t.jsonl',
          stopReason: 'done',
        });

        const result = adapter.parseInput(input);
        expect(result.sessionId).toBe('gen-session');
        expect(result.cwd).toBe('/test/gen');
        expect(result.prompt).toBe('Test');
        expect(result.toolName).toBe('Read');
        expect(result.toolInput).toEqual({ file_path: '/x' });
        expect(result.toolResponse).toBe('content');
        expect(result.transcriptPath).toBe('/test/t.jsonl');
        expect(result.stopReason).toBe('done');
      });

      it('should also accept snake_case fields as fallback', () => {
        const input = JSON.stringify({
          session_id: 'snake-session',
          cwd: '/test',
          tool_name: 'Bash',
          tool_input: { command: 'ls' },
          tool_result: 'files',
          transcript_path: '/t.jsonl',
          stop_reason: 'end',
        });

        const result = adapter.parseInput(input);
        expect(result.sessionId).toBe('snake-session');
        expect(result.toolName).toBe('Bash');
        expect(result.toolInput).toEqual({ command: 'ls' });
        expect(result.toolResponse).toBe('files');
        expect(result.transcriptPath).toBe('/t.jsonl');
        expect(result.stopReason).toBe('end');
      });

      it('should prefer camelCase over snake_case', () => {
        const input = JSON.stringify({
          sessionId: 'camel',
          session_id: 'snake',
          cwd: '/test',
        });

        const result = adapter.parseInput(input);
        expect(result.sessionId).toBe('camel');
      });

      it('should accept project field', () => {
        const input = JSON.stringify({
          cwd: '/test/dir',
          project: 'my-custom-project',
        });

        const result = adapter.parseInput(input);
        expect(result.project).toBe('my-custom-project');
      });

      it('should derive project from cwd when not provided', () => {
        const input = JSON.stringify({ cwd: '/test/my-project' });
        const result = adapter.parseInput(input);
        expect(result.project).toBe('my-project');
      });

      it('should handle invalid JSON', () => {
        const result = adapter.parseInput('{}{}');
        expect(result.sessionId).toMatch(/^session_/);
      });
    });

    describe('formatOutput', () => {
      it('should format with additionalContext', () => {
        const result: HookResult = {
          continue: true,
          suppressOutput: false,
          additionalContext: 'some context',
        };

        const output = JSON.parse(adapter.formatOutput(result));
        expect(output.continue).toBe(true);
        expect(output.additionalContext).toBe('some context');
      });

      it('should format with error', () => {
        const result: HookResult = {
          continue: true,
          suppressOutput: true,
          error: 'fail',
        };

        const output = JSON.parse(adapter.formatOutput(result));
        expect(output.error).toBe('fail');
      });

      it('should format minimal response', () => {
        const result: HookResult = {
          continue: true,
          suppressOutput: true,
        };

        const output = JSON.parse(adapter.formatOutput(result));
        expect(Object.keys(output)).toEqual(['continue']);
      });
    });
  });

  // ===== Cross-adapter consistency =====

  describe('Cross-adapter consistency', () => {
    const adapters = [
      new ClaudeCodeAdapter(),
      new OpenCodeAdapter(),
      new GenericAdapter(),
    ];

    it('all adapters should handle empty JSON', () => {
      for (const adapter of adapters) {
        const result = adapter.parseInput('{}');
        expect(result.sessionId).toBeTruthy();
        expect(result.cwd).toBeTruthy();
        expect(result.project).toBeTruthy();
        expect(result.timestamp).toBeGreaterThan(0);
      }
    });

    it('all adapters should produce valid JSON output', () => {
      const hookResult: HookResult = {
        continue: true,
        suppressOutput: false,
        additionalContext: 'test',
      };

      for (const adapter of adapters) {
        const output = adapter.formatOutput(hookResult);
        expect(() => JSON.parse(output)).not.toThrow();
      }
    });

    it('all adapters should have a name', () => {
      for (const adapter of adapters) {
        expect(adapter.name).toBeTruthy();
        expect(typeof adapter.name).toBe('string');
      }
    });

    it('all adapters should list supported events', () => {
      for (const adapter of adapters) {
        expect(adapter.supportedEvents.length).toBeGreaterThan(0);
        expect(adapter.supportedEvents).toContain('context');
      }
    });
  });
});