import { isMediaOverflowError } from './media-overflow'
import { isUnsupportedCodexAcpVersionError } from './codex-runtime'
import { CLAUDE_CLI_INCOMPATIBLE_MESSAGE } from './claude-runtime'
export { CLAUDE_CLI_INCOMPATIBLE_MESSAGE, isClaudeCliCompatibilityError } from './claude-runtime'

// Classifies a failed run into "expected" (keep the message, no report button) vs "unknown/reportable"
// (an opaque or internal failure worth a GitHub issue). The primary signal is STRUCTURAL, not textual:
// a model/provider failure is tagged `providerError` on the error event at the ACP layer (runtime.ts,
// via isProviderPromptError) and persisted as `session.errorReportable = false`. Arbitrary provider
// wording is not guessed from text — that was fragile and repeatedly swallowed genuine app errors.
//
// This module owns only the SECONDARY, text-based tier: recognizing the app's OWN crafted reminder
// strings (which we author, so an exact-match set is reliable) so their report button is hidden even
// on the paths that don't carry the structural flag (a persisted pre-flag session, or a renderer-side
// failRun call). Two fixed Claude Code transport wrappers are recognized here (`API Error: Unable to
// connect to API` and `API Error: Connection closed mid-response`) so historical sessions and
// createSession failRun hide Report without rewriting stored records. Arbitrary provider text is still
// not guessed. It is a pure, dependency-light leaf module (like media-overflow.ts) usable from both
// processes.

// App-crafted resume-failure messages (useWorkspaceAgentRuntime.getResumeFailureMessage). Each is the
// actionable text the app writes when it recognizes a specific resume cause. The generic
// "Agent session resume failed: …" fallback is deliberately NOT here — an unrecognized resume cause
// stays reportable.
export const RESUME_WORKSPACE_MISSING_MESSAGE =
  'Session workspace is missing; start a new conversation.'
export const RESUME_TIMED_OUT_MESSAGE = 'Agent session resume timed out; click Resume to try again.'
export const RESUME_UNSUPPORTED_MESSAGE =
  'This agent build cannot resume sessions; start a new conversation.'
export const RESUME_RECONNECT_FAILED_MESSAGE =
  'Could not reconnect to the agent; check it is installed, then click Resume to retry.'
export const RESUME_MODEL_INCOMPATIBLE_MESSAGE =
  "The active model isn't compatible with this agent framework. Open Settings → Model to pick a compatible model or switch frameworks."

// A conversation that needs image replay on a text-only model (useWorkspaceAgentRuntime).
export const IMAGE_REPLAY_UNSUPPORTED_MESSAGE =
  'This conversation needs image replay, but the selected model does not support image input.'

// App-owned Vision relay failures cross Electron's invoke boundary as Error text, so public error
// identity is kept in shared constants instead of depending on non-enumerable Error properties.
export const VISION_MODEL_NOT_CONFIGURED_MESSAGE =
  "The selected model doesn't support images. Configure a Vision model in Settings > Model to enable image support."
const LEGACY_VISION_MODEL_NOT_CONFIGURED_MESSAGE =
  'Configure a Vision model in Settings > Model before sending images to this model.'
export const VISION_IMAGE_TOO_LARGE_MESSAGE =
  'The attached image is too large to prepare for the Vision model.'
export const VISION_IMAGE_INVALID_MESSAGE = 'The attached image is invalid.'
export const VISION_IMAGE_BUDGET_MESSAGE =
  'The current images exceed the Vision evidence request budget.'
export const VISION_EVIDENCE_BUDGET_MESSAGE =
  'The current Vision evidence exceeds the request budget.'
export const VISION_EVIDENCE_INVALID_MESSAGE = 'The Vision model returned invalid image evidence.'

const VISION_RUN_FAILURE_MESSAGES = [
  VISION_MODEL_NOT_CONFIGURED_MESSAGE,
  VISION_IMAGE_TOO_LARGE_MESSAGE,
  VISION_IMAGE_INVALID_MESSAGE,
  VISION_IMAGE_BUDGET_MESSAGE,
  VISION_EVIDENCE_BUDGET_MESSAGE,
  VISION_EVIDENCE_INVALID_MESSAGE
] as const

export type VisionRunFailureMessage = (typeof VISION_RUN_FAILURE_MESSAGES)[number]

export const visionRunFailureMessage = (
  error: string | null | undefined
): VisionRunFailureMessage | undefined => {
  const message = error?.trim()
  if (!message) return undefined
  if (
    message === LEGACY_VISION_MODEL_NOT_CONFIGURED_MESSAGE ||
    message.endsWith(`Error: ${LEGACY_VISION_MODEL_NOT_CONFIGURED_MESSAGE}`)
  ) {
    return VISION_MODEL_NOT_CONFIGURED_MESSAGE
  }
  return VISION_RUN_FAILURE_MESSAGES.find(
    (candidate) => message === candidate || message.endsWith(`Error: ${candidate}`)
  )
}

// App-authored agent-setup guidance thrown by settings/service.ts:resolveActiveAgentBackend at spawn
// time — surfaced when a conversation FAILS TO START (createSession), which does not route through the
// resume-path softener. All three are wrong-config the user fixes in Settings → Model, not app bugs, so
// they must hide the report button. service.ts builds its throws from these SAME constants/builder so
// the text can never drift from what the classifier recognizes.
export const NO_ACTIVE_PROVIDER_MESSAGE =
  'No active model provider is configured. Configure one in settings.'
export const CLAUDE_EXECUTABLE_MISSING_MESSAGE =
  'Claude executable is not configured. Complete onboarding in settings.'
export const CODEX_BRIDGE_UNSUPPORTED_MESSAGE =
  'The active model is not supported over the Codex Chat Completions bridge. Pick another model in Settings → Model.'
export const CONFIGURED_MODEL_UNAVAILABLE_PREFIX =
  'The configured model is no longer available from provider'
export const buildConfiguredModelUnavailableMessage = (
  model: string,
  providerName: string
): string =>
  `${CONFIGURED_MODEL_UNAVAILABLE_PREFIX} "${providerName}": "${model}". Pick another model in Settings → Model.`
// The model↔framework mismatch message interpolates the framework name, so the classifier matches on
// this leading, framework-independent phrase. It also covers the resume-path RESUME_MODEL_INCOMPATIBLE
// wording (both begin here), so either surfacing is recognized.
export const ACTIVE_MODEL_INCOMPATIBLE_PREFIX = "The active model isn't compatible with"
export const buildActiveModelIncompatibleMessage = (frameworkDisplayName: string): string =>
  `${ACTIVE_MODEL_INCOMPATIBLE_PREFIX} ${frameworkDisplayName}. Open Settings → Model to pick a compatible model or switch the agent framework.`

// Stable prefix of the provider "resource not found" message produced by main's describePromptError.
// That message interpolates the model name and the provider's own response, so the classifier matches
// on this leading, model-independent phrase. prompt-error.ts builds its message from the SAME constant
// so the two can never drift (a drift-guard test feeds describePromptError's real output through the
// classifier).
export const PROVIDER_RESOURCE_NOT_FOUND_PREFIX =
  'The model provider could not find the requested resource'
export const PROVIDER_CONNECTION_FAILED_PREFIX = 'Could not connect to the model provider'

// Claude Code's fixed unreachable-API wrapper. Recognized here so createSession failRun and persisted
// pre-flag sessions hide Report without a stored-schema migration. Match the distinctive
// `API Error: Unable to connect to API` phrase only — not a generic "connection" or "connect" word.
const CLAUDE_API_CONNECTION_FAILURE_PATTERN = /(?:^|:\s*)api error:\s*unable to connect to api\b/i
const CLAUDE_API_RESPONSE_INTERRUPTION_PATTERN =
  /(?:^|:\s*)api error:\s*connection closed mid-response\b/i

export const isClaudeApiConnectionFailure = (error: string | null | undefined): boolean => {
  const message = error?.trim()
  if (!message) return false
  return CLAUDE_API_CONNECTION_FAILURE_PATTERN.test(message)
}

// Claude Code's fixed wrapper for a response stream that ended after partial output. Keep this
// separate from connect-time failures: the latter gets base-URL/proxy guidance, while this one is
// projected as an interrupted turn that can use the existing Resume flow.
export const isClaudeApiResponseInterruption = (error: string | null | undefined): boolean => {
  const message = error?.trim()
  if (!message) return false
  return CLAUDE_API_RESPONSE_INTERRUPTION_PATTERN.test(message)
}

// The exact app-crafted messages an equality check recognizes as expected.
const EXPECTED_RUN_FAILURE_MESSAGES = new Set<string>([
  RESUME_WORKSPACE_MISSING_MESSAGE,
  RESUME_TIMED_OUT_MESSAGE,
  RESUME_UNSUPPORTED_MESSAGE,
  RESUME_RECONNECT_FAILED_MESSAGE,
  RESUME_MODEL_INCOMPATIBLE_MESSAGE,
  CLAUDE_CLI_INCOMPATIBLE_MESSAGE,
  IMAGE_REPLAY_UNSUPPORTED_MESSAGE,
  NO_ACTIVE_PROVIDER_MESSAGE,
  CLAUDE_EXECUTABLE_MISSING_MESSAGE,
  CODEX_BRIDGE_UNSUPPORTED_MESSAGE
])

// Whether a run failure is one the app itself already surfaced with a purpose — an app-crafted
// actionable reminder, the reworded provider not-found, Claude Code's fixed unreachable-API wrapper,
// or a request-size overflow the app auto-recovers — so the report button is hidden even without the
// structural `providerError` flag (an old persisted session, or a renderer-side failRun). Recognition
// is by EXACT crafted string / known prefix only; it deliberately does NOT try to recognize arbitrary
// provider error text (that is the structural flag's job), so an unknown/opaque failure it doesn't
// author stays reportable.
export const isExpectedRunFailure = (error: string | null | undefined): boolean => {
  const message = error?.trim()

  // An empty message is itself an unknown failure (a run failed with nothing to explain it).
  if (!message) return false

  if (EXPECTED_RUN_FAILURE_MESSAGES.has(message)) return true
  if (visionRunFailureMessage(message)) return true
  // An outdated app-managed adapter is an actionable Settings problem, not a reportable app bug.
  if (isUnsupportedCodexAcpVersionError(message)) return true
  // The reworded provider not-found (a model-config problem the user fixes in Settings, not a bug).
  if (message.startsWith(PROVIDER_RESOURCE_NOT_FOUND_PREFIX)) return true
  // The actionable provider connection reminder produced for Claude Code connection failures.
  if (message.startsWith(PROVIDER_CONNECTION_FAILED_PREFIX)) return true
  if (message.startsWith(CONFIGURED_MODEL_UNAVAILABLE_PREFIX)) return true
  // Model↔framework incompatibility raised at spawn/createSession. The main-side message names the
  // framework (`…compatible with Codex.`) while the resume path rewords it to a generic form; both
  // share this leading phrase, so one prefix covers the createSession path (which is not reworded) and
  // any framework name. It is app-authored setup guidance ("Open Settings → Model"), not a bug.
  if (message.startsWith(ACTIVE_MODEL_INCOMPATIBLE_PREFIX)) return true
  // Claude Code's fixed transport wrappers (createSession / persisted pre-flag sessions).
  if (isClaudeApiConnectionFailure(message) || isClaudeApiResponseInterruption(message)) return true
  // A request-size overflow the app auto-recovers from — never a reportable bug.
  return isMediaOverflowError(message)
}

// Whether a run failure should offer the "Report error → open a GitHub issue" affordance. True only for
// unknown/opaque failures; recognized (expected) ones return false so they are not reported as bugs.
export const isReportableRunFailure = (error: string | null | undefined): boolean =>
  !isExpectedRunFailure(error)