/**
 * @fileoverview GraphQL response processor for run checks queries
 * @packageDocumentation
 */

import { z } from 'zod';
import { DeepSourceIssue } from '../../../models/issues.js';
import { createLogger } from '../../logging/logger.js';

const logger = createLogger('DeepSource:RunChecksProcessor');

/**
 * Schema for issue data in GraphQL response
 */
const IssueSchema = z.object({
  shortcode: z.string().optional(),
  title: z.string().optional(),
  category: z.string().optional(),
  severity: z.string().optional(),
  description: z.string().optional(),
  tags: z.array(z.string()).optional(),
});

/**
 * Schema for occurrence node in GraphQL response
 */
const OccurrenceNodeSchema = z.object({
  id: z.string().optional(),
  issue: IssueSchema.optional(),
  path: z.string().optional(),
  beginLine: z.number().optional(),
});

/**
 * Schema for page info
 */
const PageInfoSchema = z.object({
  hasNextPage: z.boolean(),
  hasPreviousPage: z.boolean(),
  startCursor: z.string().optional(),
  endCursor: z.string().optional(),
});

/**
 * Schema for occurrences in check node
 */
const OccurrencesSchema = z.object({
  pageInfo: PageInfoSchema.optional(),
  totalCount: z.number().optional(),
  edges: z
    .array(
      z.object({
        node: OccurrenceNodeSchema.optional(),
      })
    )
    .optional(),
});

/**
 * Schema for check node
 */
const CheckNodeSchema = z.object({
  occurrences: OccurrencesSchema.optional(),
});

/**
 * Schema for run checks GraphQL response
 */
const RunChecksResponseSchema = z.object({
  data: z.object({
    data: z
      .object({
        run: z
          .object({
            checks: z
              .object({
                edges: z
                  .array(
                    z.object({
                      node: CheckNodeSchema,
                    })
                  )
                  .optional(),
              })
              .optional(),
          })
          .optional(),
      })
      .optional(),
  }),
});

/**
 * Result type for processed run checks
 */
export interface ProcessedRunChecks {
  issues: DeepSourceIssue[];
  pageInfo: {
    hasNextPage: boolean;
    hasPreviousPage: boolean;
    startCursor: string | undefined;
    endCursor: string | undefined;
  };
  totalCount: number;
}

/**
 * Create a DeepSourceIssue from an occurrence node
 * @param occurrence - Occurrence node from GraphQL response
 * @returns DeepSourceIssue object
 * @private
 */
function createIssueFromOccurrence(
  occurrence: z.infer<typeof OccurrenceNodeSchema>
): DeepSourceIssue {
  return {
    id: occurrence.id ?? 'unknown',
    shortcode: occurrence.issue?.shortcode ?? '',
    title: occurrence.issue?.title ?? 'Untitled Issue',
    category: occurrence.issue?.category ?? 'UNKNOWN',
    severity: occurrence.issue?.severity ?? 'UNKNOWN',
    status: 'OPEN',
    issue_text: occurrence.issue?.description ?? '',
    file_path: occurrence.path ?? 'N/A',
    line_number: occurrence.beginLine ?? 0,
    tags: occurrence.issue?.tags ?? [],
  };
}

/**
 * Extract issues from validated response data
 * @param validated - Validated response data
 * @returns Processed run checks data
 * @private
 */
function extractIssues(validated: z.infer<typeof RunChecksResponseSchema>): ProcessedRunChecks {
  const issues: DeepSourceIssue[] = [];
  let pageInfo = {
    hasNextPage: false,
    hasPreviousPage: false,
    startCursor: undefined as string | undefined,
    endCursor: undefined as string | undefined,
  };
  let totalCount = 0;

  const checks = validated.data.data?.run?.checks?.edges ?? [];

  for (const { node: check } of checks) {
    const occurrences = check.occurrences?.edges ?? [];
    const occurrencesPageInfo = check.occurrences?.pageInfo;
    const occurrencesTotalCount = check.occurrences?.totalCount ?? 0;

    // Aggregate page info (using the first check's pagination info for simplicity)
    if (occurrencesPageInfo) {
      pageInfo = {
        hasNextPage: occurrencesPageInfo.hasNextPage,
        hasPreviousPage: occurrencesPageInfo.hasPreviousPage,
        startCursor: occurrencesPageInfo.startCursor,
        endCursor: occurrencesPageInfo.endCursor,
      };
    }

    // Always aggregate the total count
    totalCount += occurrencesTotalCount;

    for (const { node: occurrence } of occurrences) {
      if (!occurrence || !occurrence.issue) continue;

      issues.push(createIssueFromOccurrence(occurrence));
    }
  }

  return { issues, pageInfo, totalCount };
}

/**
 * Processor for run checks GraphQL responses
 */
export const RunChecksProcessor = {
  /**
   * Process a run checks GraphQL response
   * @param response - Raw GraphQL response
   * @returns Processed run checks data
   */
  process(response: unknown): ProcessedRunChecks {
    try {
      // Validate response structure
      const validated = RunChecksResponseSchema.parse(response);

      // Extract and process data
      return extractIssues(validated);
    } catch (error) {
      logger.warn('Failed to parse run checks response', {
        error: error instanceof Error ? error.message : String(error),
      });

      // Return empty result on parse failure
      return {
        issues: [],
        pageInfo: {
          hasNextPage: false,
          hasPreviousPage: false,
          startCursor: undefined,
          endCursor: undefined,
        },
        totalCount: 0,
      };
    }
  },
};