/**
 * @fileoverview AnalysisRun repository implementation
 *
 * Concrete implementation of IAnalysisRunRepository using DeepSource API.
 */

import { IAnalysisRunRepository } from '../../domain/aggregates/analysis-run/analysis-run.repository.js';
import { AnalysisRun } from '../../domain/aggregates/analysis-run/analysis-run.aggregate.js';
import {
  RunId,
  ProjectKey,
  BranchName,
  CommitOid,
  asRunId,
  asBranchName,
  asCommitOid,
  asGraphQLNodeId,
} from '../../types/branded.js';
import { RunStatus } from '../../domain/aggregates/analysis-run/analysis-run.types.js';
import { PaginationOptions, PaginatedResult } from '../../domain/shared/repository.interface.js';
import { DeepSourceClient } from '../../deepsource.js';
import { AnalysisRunMapper } from '../mappers/analysis-run.mapper.js';
import { createLogger } from '../../utils/logging/logger.js';
import { DeepSourceRun, AnalysisRunStatus, RunSummary } from '../../models/runs.js';

const logger = createLogger('AnalysisRunRepository');

/**
 * Converts client run response to model DeepSourceRun
 * The client returns plain strings but the model expects branded types
 */
function convertClientRunToModelRun(clientRun: {
  id: string;
  runUid: string;
  commitOid: string;
  branchName: string;
  baseOid: string;
  status: AnalysisRunStatus;
  createdAt: string;
  updatedAt: string;
  finishedAt?: string;
  summary: RunSummary;
  repository: {
    id: string;
    name: string;
  };
}): DeepSourceRun {
  return {
    ...clientRun,
    id: asGraphQLNodeId(clientRun.id),
    runUid: asRunId(clientRun.runUid),
    commitOid: asCommitOid(clientRun.commitOid),
    branchName: asBranchName(clientRun.branchName),
    baseOid: asCommitOid(clientRun.baseOid),
    repository: {
      ...clientRun.repository,
      id: asGraphQLNodeId(clientRun.repository.id),
    },
  };
}

/**
 * Concrete implementation of IAnalysisRunRepository using DeepSource API
 *
 * This repository provides access to AnalysisRun aggregates by fetching data
 * from the DeepSource API and mapping it to domain models.
 *
 * Note: The DeepSource API doesn't support querying individual runs by ID,
 * so some methods need to fetch and filter runs locally. This ensures fresh
 * data retrieval on every request as per requirements.
 */
export class AnalysisRunRepository implements IAnalysisRunRepository {
  constructor(private readonly client: DeepSourceClient) {
    // client is stored for use in methods
  }

  /**
   * Finds a run by its unique identifier
   *
   * Note: DeepSource API doesn't support direct run lookup by ID,
   * so this method is not efficiently implementable.
   *
   * @param id - The run ID
   * @returns The run if found, null otherwise
   */
  async findById(id: RunId): Promise<AnalysisRun | null> {
    return this.findByRunId(id);
  }

  /**
   * Finds a run by its unique ID
   *
   * Note: Since the API doesn't support direct lookup, this searches
   * through all projects to find the run.
   *
   * @param id - The run ID
   * @returns The run if found, null otherwise
   */
  async findByRunId(id: RunId): Promise<AnalysisRun | null> {
    try {
      logger.debug('Finding run by ID', { runId: id });

      // We need to search through all projects since we don't know which project the run belongs to
      const projects = await this.client.listProjects();

      for (const project of projects) {
        const projectKey = project.key;
        let cursor: string | undefined;
        let hasNextPage = true;

        while (hasNextPage) {
          const filterParams: { first: number; after?: string } = { first: 50 };
          if (cursor !== undefined) {
            filterParams.after = cursor;
          }
          const response = await this.client.listRuns(projectKey, filterParams);

          const run = response.items.find((r) => r.runUid === id);
          if (run) {
            const modelRun = convertClientRunToModelRun(run);
            const analysisRun = AnalysisRunMapper.toDomain(modelRun, projectKey);
            logger.debug('Run found', { runId: id, projectKey });
            return analysisRun;
          }

          hasNextPage = response.pageInfo.hasNextPage;
          cursor = response.pageInfo.endCursor;
        }
      }

      logger.debug('Run not found', { runId: id });
      return null;
    } catch (error) {
      logger.error('Error finding run by ID', { runId: id, error });
      throw error;
    }
  }

  /**
   * Finds runs for a specific project with pagination
   *
   * @param projectKey - The project key
   * @param options - Pagination options
   * @returns Paginated analysis runs
   */
  async findByProject(
    projectKey: ProjectKey,
    options: PaginationOptions
  ): Promise<PaginatedResult<AnalysisRun>> {
    try {
      logger.debug('Finding runs by project', { projectKey, options });

      // Calculate cursor for pagination
      const first = options.pageSize;
      const skip = (options.page - 1) * options.pageSize;

      // Fetch runs from API
      const response = await this.client.listRuns(projectKey, {
        first: skip + first, // Fetch enough to skip to the desired page
      });

      // Skip to the desired page
      const items = response.items.slice(skip, skip + first);
      const modelRuns = items.map(convertClientRunToModelRun);
      const runs = AnalysisRunMapper.toDomainList(modelRuns, projectKey);

      // Calculate total pages based on a reasonable estimate
      // Since we don't have total count from API, we estimate based on hasNextPage
      const hasMoreItems = response.items.length > skip + first || response.pageInfo.hasNextPage;
      const estimatedTotal = hasMoreItems
        ? (options.page + 1) * options.pageSize + 1
        : response.items.length;
      const totalPages = Math.ceil(estimatedTotal / options.pageSize);

      const result: PaginatedResult<AnalysisRun> = {
        items: runs,
        page: options.page,
        pageSize: options.pageSize,
        totalCount: estimatedTotal,
        totalPages,
        hasNextPage: options.page < totalPages,
        hasPreviousPage: options.page > 1,
      };

      logger.debug('Runs found', { projectKey, count: runs.length });
      return result;
    } catch (error) {
      logger.error('Error finding runs by project', { projectKey, error });
      throw error;
    }
  }

  /**
   * Finds the most recent run for a project
   *
   * @param projectKey - The project key
   * @param branch - Optional branch filter
   * @returns The most recent run if found, null otherwise
   */
  async findMostRecent(projectKey: ProjectKey, branch?: BranchName): Promise<AnalysisRun | null> {
    try {
      logger.debug('Finding most recent run', { projectKey, branch });

      // Find the most recent run by fetching runs and filtering
      let mostRecentRun: DeepSourceRun | null = null;
      let cursor: string | undefined;
      let hasNextPage = true;

      while (hasNextPage) {
        const filterParams: { first: number; after?: string } = { first: 50 };
        if (cursor !== undefined) {
          filterParams.after = cursor;
        }
        const response = await this.client.listRuns(projectKey, filterParams);

        // Filter by branch if specified
        const runsToCheck = branch
          ? response.items.filter((r) => r.branchName === branch)
          : response.items;

        // Find the most recent run
        for (const run of runsToCheck) {
          if (!mostRecentRun || new Date(run.createdAt) > new Date(mostRecentRun.createdAt)) {
            mostRecentRun = convertClientRunToModelRun(run);
          }
        }

        // If we found a run and no branch filter, we can stop
        // (runs are returned in descending order by createdAt)
        if (mostRecentRun && !branch) {
          break;
        }

        hasNextPage = response.pageInfo.hasNextPage;
        cursor = response.pageInfo.endCursor;
      }

      if (!mostRecentRun) {
        logger.debug('No recent run found', { projectKey, branch });
        return null;
      }

      const analysisRun = AnalysisRunMapper.toDomain(mostRecentRun, projectKey);
      logger.debug('Most recent run found', {
        projectKey,
        branch,
        runId: analysisRun.runId,
      });

      return analysisRun;
    } catch (error) {
      logger.error('Error finding most recent run', { projectKey, branch, error });
      throw error;
    }
  }

  /**
   * Finds a run by commit OID
   *
   * @param projectKey - The project key
   * @param commitOid - The commit OID
   * @returns The run if found, null otherwise
   */
  async findByCommit(projectKey: ProjectKey, commitOid: CommitOid): Promise<AnalysisRun | null> {
    try {
      logger.debug('Finding run by commit', { projectKey, commitOid });

      let cursor: string | undefined;
      let hasNextPage = true;

      while (hasNextPage) {
        const filterParams: { first: number; after?: string } = { first: 50 };
        if (cursor !== undefined) {
          filterParams.after = cursor;
        }
        const response = await this.client.listRuns(projectKey, filterParams);

        const run = response.items.find((r) => r.commitOid === commitOid);
        if (run) {
          const modelRun = convertClientRunToModelRun(run);
          const analysisRun = AnalysisRunMapper.toDomain(modelRun, projectKey);
          logger.debug('Run found for commit', { projectKey, commitOid, runId: run.runUid });
          return analysisRun;
        }

        hasNextPage = response.pageInfo.hasNextPage;
        cursor = response.pageInfo.endCursor;
      }

      logger.debug('No run found for commit', { projectKey, commitOid });
      return null;
    } catch (error) {
      logger.error('Error finding run by commit', { projectKey, commitOid, error });
      throw error;
    }
  }

  /**
   * Finds runs by status
   *
   * @param projectKey - The project key
   * @param status - The run status
   * @param options - Pagination options
   * @returns Paginated analysis runs
   */
  async findByStatus(
    projectKey: ProjectKey,
    status: RunStatus,
    options: PaginationOptions
  ): Promise<PaginatedResult<AnalysisRun>> {
    try {
      logger.debug('Finding runs by status', { projectKey, status, options });

      // Fetch all runs and filter by status
      // This is inefficient but necessary since API doesn't support status filtering
      const allRuns: DeepSourceRun[] = [];
      let cursor: string | undefined;
      let hasNextPage = true;

      while (hasNextPage) {
        const filterParams: { first: number; after?: string } = { first: 100 };
        if (cursor !== undefined) {
          filterParams.after = cursor;
        }
        const response = await this.client.listRuns(projectKey, filterParams);

        const modelRuns = response.items.map(convertClientRunToModelRun);
        allRuns.push(...modelRuns);
        hasNextPage = response.pageInfo.hasNextPage;
        cursor = response.pageInfo.endCursor;
      }

      // Map and filter by status
      const mappedRuns = AnalysisRunMapper.toDomainList(allRuns, projectKey);
      const filteredRuns = mappedRuns.filter((run) => run.status === status);

      // Apply pagination
      const start = (options.page - 1) * options.pageSize;
      const paginatedRuns = filteredRuns.slice(start, start + options.pageSize);

      const result: PaginatedResult<AnalysisRun> = {
        items: paginatedRuns,
        page: options.page,
        pageSize: options.pageSize,
        totalCount: filteredRuns.length,
        totalPages: Math.ceil(filteredRuns.length / options.pageSize),
        hasNextPage: start + options.pageSize < filteredRuns.length,
        hasPreviousPage: options.page > 1,
      };

      logger.debug('Runs found by status', {
        projectKey,
        status,
        count: paginatedRuns.length,
        totalCount: filteredRuns.length,
      });

      return result;
    } catch (error) {
      logger.error('Error finding runs by status', { projectKey, status, error });
      throw error;
    }
  }

  /**
   * Finds runs within a date range
   *
   * @param projectKey - The project key
   * @param startDate - Start date (inclusive)
   * @param endDate - End date (inclusive)
   * @param options - Pagination options
   * @returns Paginated analysis runs
   */
  async findByDateRange(
    projectKey: ProjectKey,
    startDate: Date,
    endDate: Date,
    options: PaginationOptions
  ): Promise<PaginatedResult<AnalysisRun>> {
    try {
      logger.debug('Finding runs by date range', {
        projectKey,
        startDate,
        endDate,
        options,
      });

      // Fetch all runs and filter by date range
      const allRuns: DeepSourceRun[] = [];
      let cursor: string | undefined;
      let hasNextPage = true;

      while (hasNextPage) {
        const filterParams: { first: number; after?: string } = { first: 100 };
        if (cursor !== undefined) {
          filterParams.after = cursor;
        }
        const response = await this.client.listRuns(projectKey, filterParams);

        // Filter runs by date range
        const runsInRange = response.items.filter((run) => {
          const runDate = new Date(run.createdAt);
          return runDate >= startDate && runDate <= endDate;
        });

        const modelRuns = runsInRange.map(convertClientRunToModelRun);
        allRuns.push(...modelRuns);

        // If we found runs outside the range, we can stop
        if (response.items.length > 0) {
          const oldestRun = response.items[response.items.length - 1];
          if (oldestRun && new Date(oldestRun.createdAt) < startDate) {
            break;
          }
        }

        hasNextPage = response.pageInfo.hasNextPage;
        cursor = response.pageInfo.endCursor;
      }

      // Map to domain models
      const mappedRuns = AnalysisRunMapper.toDomainList(allRuns, projectKey);

      // Apply pagination
      const start = (options.page - 1) * options.pageSize;
      const paginatedRuns = mappedRuns.slice(start, start + options.pageSize);

      const result: PaginatedResult<AnalysisRun> = {
        items: paginatedRuns,
        page: options.page,
        pageSize: options.pageSize,
        totalCount: mappedRuns.length,
        totalPages: Math.ceil(mappedRuns.length / options.pageSize),
        hasNextPage: start + options.pageSize < mappedRuns.length,
        hasPreviousPage: options.page > 1,
      };

      logger.debug('Runs found in date range', {
        projectKey,
        count: paginatedRuns.length,
        totalCount: mappedRuns.length,
      });

      return result;
    } catch (error) {
      logger.error('Error finding runs by date range', {
        projectKey,
        startDate,
        endDate,
        error,
      });
      throw error;
    }
  }

  /**
   * Counts runs for a project
   *
   * @param projectKey - The project key
   * @returns The total number of runs
   */
  async countByProject(projectKey: ProjectKey): Promise<number> {
    try {
      logger.debug('Counting runs for project', { projectKey });

      // Count all runs
      let count = 0;
      let cursor: string | undefined;
      let hasNextPage = true;

      while (hasNextPage) {
        const filterParams: { first: number; after?: string } = { first: 100 };
        if (cursor !== undefined) {
          filterParams.after = cursor;
        }
        const response = await this.client.listRuns(projectKey, filterParams);

        count += response.items.length;
        hasNextPage = response.pageInfo.hasNextPage;
        cursor = response.pageInfo.endCursor;
      }

      logger.debug('Run count for project', { projectKey, count });
      return count;
    } catch (error) {
      logger.error('Error counting runs for project', { projectKey, error });
      throw error;
    }
  }

  /**
   * Counts runs by status for a project
   *
   * @param projectKey - The project key
   * @param status - The run status
   * @returns The number of runs with the given status
   */
  async countByStatus(projectKey: ProjectKey, status: RunStatus): Promise<number> {
    try {
      logger.debug('Counting runs by status', { projectKey, status });

      // Fetch all runs and count by status
      let count = 0;
      let cursor: string | undefined;
      let hasNextPage = true;

      while (hasNextPage) {
        const filterParams: { first: number; after?: string } = { first: 100 };
        if (cursor !== undefined) {
          filterParams.after = cursor;
        }
        const response = await this.client.listRuns(projectKey, filterParams);

        // Map and count matching status
        const modelRuns = response.items.map(convertClientRunToModelRun);
        const mappedRuns = AnalysisRunMapper.toDomainList(modelRuns, projectKey);
        count += mappedRuns.filter((run) => run.status === status).length;

        hasNextPage = response.pageInfo.hasNextPage;
        cursor = response.pageInfo.endCursor;
      }

      logger.debug('Run count by status', { projectKey, status, count });
      return count;
    } catch (error) {
      logger.error('Error counting runs by status', { projectKey, status, error });
      throw error;
    }
  }

  /**
   * Checks if a run exists for a commit
   *
   * @param projectKey - The project key
   * @param commitOid - The commit OID
   * @returns True if a run exists, false otherwise
   */
  async existsForCommit(projectKey: ProjectKey, commitOid: CommitOid): Promise<boolean> {
    try {
      logger.debug('Checking if run exists for commit', { projectKey, commitOid });

      const run = await this.findByCommit(projectKey, commitOid);
      const exists = run !== null;

      logger.debug('Run existence check for commit', { projectKey, commitOid, exists });
      return exists;
    } catch (error) {
      logger.error('Error checking run existence for commit', { projectKey, commitOid, error });
      throw error;
    }
  }

  /**
   * Saves an analysis run
   *
   * Note: The DeepSource API doesn't support creating/updating runs
   * through the GraphQL API. This method is implemented to satisfy the
   * interface but will throw an error indicating the operation is not supported.
   *
   * @param run - The run to save
   * @throws Error indicating the operation is not supported
   */
  // skipcq: JS-0105 - Repository method required by interface contract
  async save(run: AnalysisRun): Promise<void> {
    logger.warn('Attempted to save run', {
      runId: run.runId,
      projectKey: run.projectKey,
    });

    throw new Error(
      'Save operation is not supported by DeepSource API. ' +
        'Analysis runs are created automatically when code is pushed to the repository.'
    );
  }

  /**
   * Deletes an analysis run
   *
   * Note: The DeepSource API doesn't support deleting runs
   * through the GraphQL API. This method is implemented to satisfy the
   * interface but will throw an error indicating the operation is not supported.
   *
   * @param id - The run ID to delete
   * @throws Error indicating the operation is not supported
   */
  // skipcq: JS-0105 - Repository method required by interface contract
  async delete(id: RunId): Promise<void> {
    logger.warn('Attempted to delete run', { runId: id });

    throw new Error(
      'Delete operation is not supported by DeepSource API. ' +
        'Analysis runs cannot be deleted through the API.'
    );
  }
}