/**
 * @vitest-environment node
 */

import { vi } from 'vitest';
import {
  asProjectKey,
  asRunId,
  asCommitOid,
  asBranchName,
  asGraphQLNodeId,
} from '../../types/branded';
import type { IAnalysisRunRepository } from '../../domain/aggregates/analysis-run/analysis-run.repository';
import type { AnalysisRun } from '../../domain/aggregates/analysis-run/analysis-run.aggregate';
import type { Logger } from '../../utils/logging/logger';
import { IssueCount } from '../../domain/value-objects/issue-count';

// Create mock logger
const mockLogger = {
  debug: vi.fn(),
  info: vi.fn(),
  warn: vi.fn(),
  error: vi.fn(),
};

// Mock modules before importing the implementation
vi.mock('../../utils/logging/logger', () => ({
  createLogger: vi.fn(() => mockLogger),
}));

// Mock the repository and factory
const mockFindMostRecent = vi.fn();
const mockAnalysisRunRepository = {
  findMostRecent: mockFindMostRecent,
} as unknown as IAnalysisRunRepository;

const mockCreateAnalysisRunRepository = vi.fn(() => mockAnalysisRunRepository);
const mockRepositoryFactory = vi.fn(() => ({
  createAnalysisRunRepository: mockCreateAnalysisRunRepository,
}));

vi.mock('../../infrastructure/factories/repository.factory', () => ({
  RepositoryFactory: mockRepositoryFactory,
}));

// Mock the DeepSource client
const mockGetRecentRunIssues = vi.fn();
const mockDeepSourceClient = vi.fn(() => ({
  getRecentRunIssues: mockGetRecentRunIssues,
}));

vi.mock('../../deepsource.js', () => ({
  DeepSourceClient: mockDeepSourceClient,
  ReportType: {
    OWASP_TOP_10: 'OWASP_TOP_10',
    SANS_TOP_25: 'SANS_TOP_25',
    MISRA_C: 'MISRA_C',
    CODE_COVERAGE: 'CODE_COVERAGE',
    CODE_HEALTH_TREND: 'CODE_HEALTH_TREND',
    ISSUE_DISTRIBUTION: 'ISSUE_DISTRIBUTION',
    ISSUES_PREVENTED: 'ISSUES_PREVENTED',
    ISSUES_AUTOFIXED: 'ISSUES_AUTOFIXED',
  },
  ReportStatus: {
    PASSING: 'PASSING',
    FAILING: 'FAILING',
    NOOP: 'NOOP',
  },
}));

// Import the modules under test AFTER mocking
const { handleDeepsourceRecentRunIssues, createRecentRunIssuesHandlerWithRepo } = await import(
  '../../handlers/recent-run-issues'
);

describe('Recent Run Issues Handler', () => {
  // Environment backup
  let originalEnv: Record<string, string | undefined>;

  beforeEach(() => {
    // Backup environment
    originalEnv = { ...process.env };
    process.env.DEEPSOURCE_API_KEY = 'test-api-key';

    // Reset mocks
    vi.clearAllMocks();
  });

  afterEach(() => {
    // Restore environment
    process.env = originalEnv;
  });

  describe('createRecentRunIssuesHandlerWithRepo', () => {
    it('should create a handler that finds recent run and fetches issues', async () => {
      // Mock domain analysis run
      const projectKey = asProjectKey('test-project');
      const branchName = asBranchName('main');
      const mockRun = {
        runId: asRunId('run-123'),
        projectKey,
        repositoryId: asGraphQLNodeId('repo-1'),
        commitInfo: {
          oid: asCommitOid('commit-abc'),
          branch: branchName,
          baseOid: asCommitOid('base-def'),
        },
        status: 'SUCCESS' as const,
        timestamps: {
          createdAt: new Date('2023-01-01T00:00:00Z'),
          startedAt: new Date('2023-01-01T00:01:00Z'),
          finishedAt: new Date('2023-01-01T00:05:00Z'),
        },
        summary: {
          totalIntroduced: IssueCount.create(3),
          totalResolved: IssueCount.create(1),
          totalSuppressed: IssueCount.create(0),
          byAnalyzer: [
            {
              analyzerShortcode: 'eslint',
              introduced: IssueCount.create(2),
              resolved: IssueCount.create(1),
              suppressed: IssueCount.create(0),
            },
          ],
          byCategory: [
            {
              category: 'BUG_RISK',
              introduced: IssueCount.create(3),
              resolved: IssueCount.create(1),
              suppressed: IssueCount.create(0),
            },
          ],
        },
      } as AnalysisRun;

      // Mock client response for issues
      const mockClientResponse = {
        run: {
          id: 'run-graphql-id-1',
          runUid: 'run-123',
          commitOid: 'commit-abc',
          branchName: 'main',
          baseOid: 'base-def',
          status: 'SUCCESS',
          createdAt: '2023-01-01T00:00:00Z',
          updatedAt: '2023-01-01T00:05:00Z',
          finishedAt: '2023-01-01T00:05:00Z',
          summary: {
            occurrencesIntroduced: 3,
            occurrencesResolved: 1,
            occurrencesSuppressed: 0,
          },
          repository: {
            name: 'test-repo',
            id: 'repo-graphql-id-1',
          },
        },
        items: [
          {
            id: 'issue-1',
            title: 'Test issue',
            shortcode: 'PY-E1101',
            category: 'BUG',
            severity: 'MAJOR',
            status: 'OPEN',
            issue_text: 'Instance of class has no attribute',
            file_path: 'src/test.py',
            line_number: 42,
            tags: ['python', 'bug-risk'],
          },
        ],
        pageInfo: {
          hasNextPage: false,
          hasPreviousPage: false,
          startCursor: null,
          endCursor: null,
        },
        totalCount: 1,
      };

      // Set up the mocks
      mockFindMostRecent.mockResolvedValue(mockRun);
      mockGetRecentRunIssues.mockResolvedValue(mockClientResponse);

      const mockClient = {
        getRecentRunIssues: mockGetRecentRunIssues,
      };

      const handler = createRecentRunIssuesHandlerWithRepo({
        analysisRunRepository: mockAnalysisRunRepository,
        client: mockClient,
        logger: mockLogger as unknown as Logger,
      });

      // Call the handler
      const result = await handler({
        projectKey: 'test-project',
        branchName: 'main',
      });

      // Verify repository was used correctly
      expect(mockFindMostRecent).toHaveBeenCalledWith(projectKey, branchName);

      // Verify client was used correctly
      expect(mockGetRecentRunIssues).toHaveBeenCalledWith('test-project', 'main');

      // Verify the response structure
      const parsedContent = JSON.parse(result.content[0].text);
      expect(parsedContent.run.id).toBe('run-123');
      expect(parsedContent.run.runUid).toBe('run-123');
      expect(parsedContent.run.status).toBe('SUCCESS');
      expect(parsedContent.run.commitOid).toBe('commit-abc');
      expect(parsedContent.run.branchName).toBe('main');
      expect(parsedContent.run.summary.occurrencesIntroduced).toBe(3);
      expect(parsedContent.run.summary.occurrencesResolved).toBe(1);
      expect(parsedContent.run.summary.occurrencesSuppressed).toBe(0);
      expect(parsedContent.issues).toHaveLength(1);
      expect(parsedContent.issues[0].id).toBe('issue-1');
      expect(parsedContent.issues[0].title).toBe('Test issue');
      expect(parsedContent.totalCount).toBe(1);
      expect(parsedContent.usage_examples).toBeDefined();
    });

    it('should handle case when no recent run is found', async () => {
      // Set up the mock to return null
      mockFindMostRecent.mockResolvedValue(null);

      const mockClient = {
        getRecentRunIssues: mockGetRecentRunIssues,
      };

      const handler = createRecentRunIssuesHandlerWithRepo({
        analysisRunRepository: mockAnalysisRunRepository,
        client: mockClient,
        logger: mockLogger as unknown as Logger,
      });

      // Call the handler
      const result = await handler({
        projectKey: 'test-project',
        branchName: 'feature-branch',
      });

      // Verify error response
      expect(result.isError).toBe(true);
      const parsedContent = JSON.parse(result.content[0].text);
      expect(parsedContent.error).toContain(
        'No recent analysis run found for branch "feature-branch" in project "test-project"'
      );
      expect(parsedContent.details).toBe('Failed to retrieve recent run issues');
    });

    it('should handle repository errors gracefully', async () => {
      // Set up the mock to throw an error
      const testError = new Error('Repository connection failed');
      mockFindMostRecent.mockRejectedValue(testError);

      const mockClient = {
        getRecentRunIssues: mockGetRecentRunIssues,
      };

      const handler = createRecentRunIssuesHandlerWithRepo({
        analysisRunRepository: mockAnalysisRunRepository,
        client: mockClient,
        logger: mockLogger as unknown as Logger,
      });

      // Call the handler
      const result = await handler({
        projectKey: 'test-project',
        branchName: 'main',
      });

      // Verify error was logged using injected logger
      expect(mockLogger.error).toHaveBeenCalledWith(
        'Error in handleRecentRunIssues',
        expect.any(Object)
      );

      // Verify error response
      expect(result.isError).toBe(true);
      const parsedContent = JSON.parse(result.content[0].text);
      expect(parsedContent).toEqual({
        error: 'Repository connection failed',
        details: 'Failed to retrieve recent run issues',
      });
    });

    it('should handle client errors gracefully', async () => {
      // Mock successful repository call but failing client call
      const mockRun = {
        runId: asRunId('run-123'),
        projectKey: asProjectKey('test-project'),
        repositoryId: asGraphQLNodeId('repo-1'),
        commitInfo: {
          oid: asCommitOid('commit-abc'),
          branch: asBranchName('main'),
          baseOid: asCommitOid('base-def'),
        },
        status: 'SUCCESS' as const,
        timestamps: {
          createdAt: new Date('2023-01-01T00:00:00Z'),
        },
        summary: {
          totalIntroduced: IssueCount.create(0),
          totalResolved: IssueCount.create(0),
          totalSuppressed: IssueCount.create(0),
          byAnalyzer: [],
          byCategory: [],
        },
      } as AnalysisRun;

      mockFindMostRecent.mockResolvedValue(mockRun);

      const testError = new Error('Client API failed');
      mockGetRecentRunIssues.mockRejectedValue(testError);

      const mockClient = {
        getRecentRunIssues: mockGetRecentRunIssues,
      };

      const handler = createRecentRunIssuesHandlerWithRepo({
        analysisRunRepository: mockAnalysisRunRepository,
        client: mockClient,
        logger: mockLogger as unknown as Logger,
      });

      // Call the handler
      const result = await handler({
        projectKey: 'test-project',
        branchName: 'main',
      });

      // Verify error response
      expect(result.isError).toBe(true);
      const parsedContent = JSON.parse(result.content[0].text);
      expect(parsedContent.error).toBe('Client API failed');
    });

    it('should warn when domain run and client run mismatch', async () => {
      // Mock domain analysis run
      const mockRun = {
        runId: asRunId('run-123'),
        projectKey: asProjectKey('test-project'),
        repositoryId: asGraphQLNodeId('repo-1'),
        commitInfo: {
          oid: asCommitOid('commit-abc'),
          branch: asBranchName('main'),
          baseOid: asCommitOid('base-def'),
        },
        status: 'SUCCESS' as const,
        timestamps: {
          createdAt: new Date('2023-01-01T00:00:00Z'),
        },
        summary: {
          totalIntroduced: IssueCount.create(1),
          totalResolved: IssueCount.create(0),
          totalSuppressed: IssueCount.create(0),
          byAnalyzer: [],
          byCategory: [],
        },
      } as AnalysisRun;

      // Mock client response with different run ID
      const mockClientResponse = {
        run: {
          id: 'run-graphql-id-different',
          runUid: 'run-456', // Different from domain run
          commitOid: 'commit-different',
          branchName: 'main',
          status: 'SUCCESS',
          createdAt: '2023-01-01T00:00:00Z',
          summary: {
            occurrencesIntroduced: 1,
            occurrencesResolved: 0,
            occurrencesSuppressed: 0,
          },
          repository: {
            name: 'test-repo',
            id: 'repo-graphql-id-1',
          },
        },
        items: [],
        pageInfo: {
          hasNextPage: false,
          hasPreviousPage: false,
        },
        totalCount: 0,
      };

      mockFindMostRecent.mockResolvedValue(mockRun);
      mockGetRecentRunIssues.mockResolvedValue(mockClientResponse);

      const mockClient = {
        getRecentRunIssues: mockGetRecentRunIssues,
      };

      const handler = createRecentRunIssuesHandlerWithRepo({
        analysisRunRepository: mockAnalysisRunRepository,
        client: mockClient,
        logger: mockLogger as unknown as Logger,
      });

      // Call the handler
      const result = await handler({
        projectKey: 'test-project',
        branchName: 'main',
      });

      // Verify warning was logged
      expect(mockLogger.warn).toHaveBeenCalledWith('Mismatch between domain run and client run', {
        domainRunId: 'run-123',
        clientRunUid: 'run-456',
      });

      // Should still return successful response using domain data
      expect(result.isError).toBeUndefined();
      const parsedContent = JSON.parse(result.content[0].text);
      expect(parsedContent.run.id).toBe('run-123'); // Uses domain data
      expect(parsedContent.run.runUid).toBe('run-123'); // Uses domain data
    });

    it('should handle run with missing optional data', async () => {
      // Mock domain analysis run with minimal data
      const mockRun = {
        runId: asRunId('run-minimal'),
        projectKey: asProjectKey('test-project'),
        repositoryId: asGraphQLNodeId('repo-1'),
        commitInfo: {
          oid: asCommitOid('commit-minimal'),
          branch: asBranchName('main'),
          baseOid: asCommitOid('base-minimal'),
        },
        status: 'PENDING' as const,
        timestamps: {
          createdAt: new Date('2023-01-01T00:00:00Z'),
        },
        summary: {
          totalIntroduced: IssueCount.create(0),
          totalResolved: IssueCount.create(0),
          totalSuppressed: IssueCount.create(0),
          byAnalyzer: [],
          byCategory: [],
        },
      } as AnalysisRun;

      const mockClientResponse = {
        run: {
          id: 'run-graphql-id-minimal',
          runUid: 'run-minimal',
          commitOid: 'commit-minimal',
          branchName: 'main',
          status: 'PENDING',
          createdAt: '2023-01-01T00:00:00Z',
          summary: {
            occurrencesIntroduced: 0,
            occurrencesResolved: 0,
            occurrencesSuppressed: 0,
          },
          repository: {
            name: 'test-repo',
            id: 'repo-graphql-id-1',
          },
        },
        items: [],
        pageInfo: {
          hasNextPage: false,
          hasPreviousPage: false,
        },
        totalCount: 0,
      };

      mockFindMostRecent.mockResolvedValue(mockRun);
      mockGetRecentRunIssues.mockResolvedValue(mockClientResponse);

      const mockClient = {
        getRecentRunIssues: mockGetRecentRunIssues,
      };

      const handler = createRecentRunIssuesHandlerWithRepo({
        analysisRunRepository: mockAnalysisRunRepository,
        client: mockClient,
        logger: mockLogger as unknown as Logger,
      });

      // Call the handler
      const result = await handler({
        projectKey: 'test-project',
        branchName: 'main',
      });

      // Verify the response handles missing optional data gracefully
      const parsedContent = JSON.parse(result.content[0].text);
      expect(parsedContent.run.status).toBe('PENDING');
      expect(parsedContent.run.finishedAt).toBeUndefined();
      expect(parsedContent.issues).toEqual([]);
      expect(parsedContent.totalCount).toBe(0);
    });
  });

  describe('handleDeepsourceRecentRunIssues', () => {
    it('should throw an error if DEEPSOURCE_API_KEY is not set', async () => {
      // Unset API key
      delete process.env.DEEPSOURCE_API_KEY;

      // Call the handler and expect it to throw
      await expect(
        handleDeepsourceRecentRunIssues({
          projectKey: 'test-project',
          branchName: 'main',
        })
      ).rejects.toThrow('Configuration error: DeepSource API key is required but not configured');
    });

    it('should return recent run issues successfully', async () => {
      // Mock domain analysis run
      const mockRun = {
        runId: asRunId('run-success'),
        projectKey: asProjectKey('test-project'),
        repositoryId: asGraphQLNodeId('repo-1'),
        commitInfo: {
          oid: asCommitOid('commit-success'),
          branch: asBranchName('main'),
          baseOid: asCommitOid('base-success'),
        },
        status: 'SUCCESS' as const,
        timestamps: {
          createdAt: new Date('2023-01-01T00:00:00Z'),
          startedAt: new Date('2023-01-01T00:01:00Z'),
          finishedAt: new Date('2023-01-01T00:05:00Z'),
        },
        summary: {
          totalIntroduced: IssueCount.create(2),
          totalResolved: IssueCount.create(1),
          totalSuppressed: IssueCount.create(0),
          byAnalyzer: [],
          byCategory: [],
        },
      } as AnalysisRun;

      const mockClientResponse = {
        run: {
          id: 'run-graphql-id-success',
          runUid: 'run-success',
          commitOid: 'commit-success',
          branchName: 'main',
          status: 'SUCCESS',
          createdAt: '2023-01-01T00:00:00Z',
          summary: {
            occurrencesIntroduced: 2,
            occurrencesResolved: 1,
            occurrencesSuppressed: 0,
          },
          repository: {
            name: 'test-repo',
            id: 'repo-graphql-id-1',
          },
        },
        items: [
          {
            id: 'issue-success',
            title: 'Success issue',
            shortcode: 'JS-0001',
            category: 'BUG',
            severity: 'MINOR',
            status: 'OPEN',
            issue_text: 'Test issue',
            file_path: 'src/success.js',
            line_number: 10,
            tags: ['javascript'],
          },
        ],
        pageInfo: {
          hasNextPage: false,
          hasPreviousPage: false,
        },
        totalCount: 1,
      };

      // Set up the mocks
      mockFindMostRecent.mockResolvedValue(mockRun);
      mockGetRecentRunIssues.mockResolvedValue(mockClientResponse);

      // Call the handler
      const result = await handleDeepsourceRecentRunIssues({
        projectKey: 'test-project',
        branchName: 'main',
      });

      // Verify factory was created with the API key
      expect(mockRepositoryFactory).toHaveBeenCalledWith({ apiKey: 'test-api-key' });

      // Verify createAnalysisRunRepository was called
      expect(mockCreateAnalysisRunRepository).toHaveBeenCalled();

      // Verify DeepSourceClient was created with the API key
      expect(mockDeepSourceClient).toHaveBeenCalledWith('test-api-key');

      // Verify logging behavior
      expect(mockLogger.info).toHaveBeenCalledWith(
        'Fetching recent run from repository and issues from client',
        expect.any(Object)
      );

      // Verify the response structure
      expect(result).toHaveProperty('content');
      expect(result.content).toHaveLength(1);
      expect(result.content[0]).toHaveProperty('type', 'text');

      // Parse and verify the content
      const parsedContent = JSON.parse(result.content[0].text);
      expect(parsedContent.run.id).toBe('run-success');
      expect(parsedContent.run.status).toBe('SUCCESS');
      expect(parsedContent.issues).toHaveLength(1);
      expect(parsedContent.issues[0].id).toBe('issue-success');
    });

    it('should throw error when repository fails', async () => {
      // Set up the mock to throw an error
      const testError = new Error('Repository connection failed');
      mockFindMostRecent.mockRejectedValue(testError);

      // Call the handler and expect it to throw
      await expect(
        handleDeepsourceRecentRunIssues({
          projectKey: 'test-project',
          branchName: 'main',
        })
      ).rejects.toThrow('Repository connection failed');
    });

    it('should throw error when no recent run found', async () => {
      // Set up the mock to return null
      mockFindMostRecent.mockResolvedValue(null);

      // Call the handler and expect it to throw
      await expect(
        handleDeepsourceRecentRunIssues({
          projectKey: 'test-project',
          branchName: 'feature-branch',
        })
      ).rejects.toThrow(
        'No recent analysis run found for branch "feature-branch" in project "test-project"'
      );
    });

    it('should handle non-Error type exceptions', async () => {
      // Set up the mock to throw a non-Error value
      mockFindMostRecent.mockRejectedValue('Just a string error');

      // Call the handler and expect it to throw
      await expect(
        handleDeepsourceRecentRunIssues({
          projectKey: 'test-project',
          branchName: 'main',
        })
      ).rejects.toThrow('Unknown error');
    });
  });
});