codeflash-internal/js/cf-api/endpoints/verify-existing-optimizations.ts

import { getInstallationOctokitByOwner, isUserCollaborator } from "../github/github-utils.js"
import { githubApp } from "../github/github-app.js"
import { Request, Response } from "express"
import { parseAndCreateOptimizationsDict } from "../github/pr-changes-utils.js"
import { posthog } from "../analytics.js"
import { userNickname } from "../auth0-mgmt.js"

// Dependencies interface for easier testing
export interface VerifyExistingOptimizationsDependencies {
  getInstallationOctokitByOwner: typeof getInstallationOctokitByOwner
  githubApp: typeof githubApp
  parseAndCreateOptimizationsDict: typeof parseAndCreateOptimizationsDict
  posthog: typeof posthog
  userNickname: typeof userNickname
  isUserCollaborator: typeof isUserCollaborator
}

// Default dependencies
let dependencies: VerifyExistingOptimizationsDependencies = {
  getInstallationOctokitByOwner,
  githubApp,
  parseAndCreateOptimizationsDict,
  posthog,
  userNickname,
  isUserCollaborator,
}

// For testing - allow dependency injection
export function setVerifyExistingOptimizationsDependencies(
  deps: Partial<VerifyExistingOptimizationsDependencies>,
) {
  dependencies = { ...dependencies, ...deps }
}

export function resetVerifyExistingOptimizationsDependencies() {
  dependencies = {
    getInstallationOctokitByOwner,
    githubApp,
    parseAndCreateOptimizationsDict,
    posthog,
    userNickname,
    isUserCollaborator,
  }
}

export async function verifyExistingOptimizations(req: Request, res: Response) {
  try {
    const { repo_owner, repo_name, pr_number } = req.body
    const userId = (req as any).userId

    if (!repo_name || !repo_owner || !pr_number) {
      return res.status(400).json({ error: "Missing or malformed fields" })
    }

    const nickname: string | null = await dependencies.userNickname(userId)
    if (nickname == null) {
      return res.status(401).json({ error: "Unauthorized" })
    }

    const octokit = await dependencies.getInstallationOctokitByOwner(
      dependencies.githubApp,
      repo_owner,
      repo_name,
    )
    if (octokit instanceof Error) {
      return res.status(500).json({ error: octokit.message })
    }

    console.log(`Got installation Octokit for ${repo_owner}/${repo_name}`)

    // Check collaborator status with error handling
    try {
      const isCollaborator = await dependencies.isUserCollaborator(
        octokit,
        repo_owner,
        repo_name,
        nickname,
      )
      if (!isCollaborator) {
        console.log(`${nickname} is not a collaborator on ${repo_owner}/${repo_name}`)
        return res.status(401).json({ error: "Unauthorized - User is not a collaborator" })
      }
    } catch (error) {
      console.error(`Error checking collaborator status: ${error}`)
      return res.status(500).json({ error: "Failed to verify collaborator status" })
    }

    // Get PR with specific 404 handling
    let pr
    try {
      pr = await octokit.rest.pulls.get({
        owner: repo_owner,
        repo: repo_name,
        pull_number: pr_number,
      })
    } catch (error: any) {
      if (error.status === 404) {
        return res.status(404).json({
          error: `PR #${pr_number} not found for ${repo_owner}/${repo_name}`,
        })
      }
      throw error // Re-throw to be caught by global handler
    }

    // Get PR comments with error handling
    let pr_messages
    try {
      pr_messages = await octokit.rest.issues.listComments({
        owner: repo_owner,
        repo: repo_name,
        issue_number: pr_number,
      })
    } catch (error) {
      console.error("Error getting PR messages:", error)
      return res.status(500).json({
        error: `Failed to retrieve PR comments for ${repo_owner}/${repo_name}`,
      })
    }

    // Get PR reviews with error handling
    let pr_reviews
    try {
      pr_reviews = await octokit.rest.pulls.listReviews({
        owner: repo_owner,
        repo: repo_name,
        pull_number: pr_number,
      })
    } catch (error) {
      console.error("Error getting PR reviews:", error)
      return res.status(500).json({
        error: `Failed to retrieve PR reviews for ${repo_owner}/${repo_name}`,
      })
    }

    const reviewBodies: { body: string }[] = []
    for (const review of pr_reviews.data) {
      // Add the main review body if it exists
      if (review.body) {
        reviewBodies.push({ body: review.body })
      }

      // Get review comments for this specific review
      try {
        const reviewComments = await octokit.rest.pulls.listCommentsForReview({
          owner: repo_owner,
          repo: repo_name,
          pull_number: pr_number,
          review_id: review.id,
        })
        // Add each review comment body
        for (const comment of reviewComments.data) {
          if (comment.body) {
            reviewBodies.push({ body: comment.body })
          }
        }
      } catch (error) {
        console.error(`Error getting review comments for review ${review.id}:`, error)
        // Continue with other reviews even if one fails
      }
    }

    // Also get all review comments (not tied to a specific review)
    try {
      const allReviewComments = await octokit.rest.pulls.listReviewComments({
        owner: repo_owner,
        repo: repo_name,
        pull_number: pr_number,
      })
      for (const comment of allReviewComments.data) {
        if (comment.body) {
          reviewBodies.push({ body: comment.body })
        }
      }
    } catch (error) {
      console.error("Error getting all review comments:", error)
      // Continue even if this fails
    }

    const prBody = pr.data.body || ""
    const validComments = pr_messages.data.filter(
      (comment: { body?: string }) => comment.body !== undefined,
    ) as { body: string }[]
    const allComments = [...validComments, ...reviewBodies]
    const optimizations_dict = dependencies.parseAndCreateOptimizationsDict(prBody, allComments)

    if (Object.keys(optimizations_dict).length === 0) {
      return res.status(200).json({ error: "No optimizations found for this PR" })
    }

    const response_dict: { [key: string]: string[] } = {}
    for (const key in optimizations_dict) {
      response_dict[key] = Array.from(optimizations_dict[key])
    }

    dependencies.posthog.capture({
      distinctId: userId,
      event: `cfapi-github-pr-optimization`,
      properties: {
        repo_owner,
        repo_name,
        pr_number,
      },
    })

    return res.status(200).json(response_dict)
  } catch (error) {
    console.error(`Error in /cfapi/verify-existing-optimizations: ${error}`)
    if (error instanceof Error) {
      return res.status(500).json({
        error: `Error verifying existing optimizations: ${error.message}`,
      })
    } else {
      return res.status(500).json({
        error: "Error verifying existing optimizations",
      })
    }
  }
}