import type {
  ApprovalResponse,
  PermissionPolicyResolution,
} from '#/agent/permissionPolicy/types';
import type { IAgentToolApprovalService } from '#/agent/toolApproval/toolApproval';
import type {
  BeforeExecuteDecision,
  ResolvedToolExecutionHookContext,
} from '#/agent/toolExecutor/toolHooks';
import type { PlanResolvedEvent, PlanSubmittedEvent } from '#/app/telemetry/events';
import type { ITelemetryService } from '#/app/telemetry/telemetry';
import type { ToolInputDisplay } from '#/tool/toolInputDisplay';

import type { IAgentPlanService } from './plan';

type PlanReviewDisplay = Extract<ToolInputDisplay, { kind: 'plan_review' }>;
type PlanReviewOption = NonNullable<PlanReviewDisplay['options']>[number];

export class ExitPlanModeReview {
  constructor(
    private readonly plan: IAgentPlanService,
    private readonly toolApproval: IAgentToolApprovalService,
    private readonly telemetry: ITelemetryService,
  ) {}

  async requestApproval(
    context: ResolvedToolExecutionHookContext,
  ): Promise<BeforeExecuteDecision | undefined> {
    const display = context.execution.display;
    if (display?.kind !== 'plan_review') return undefined;
    if (display.plan.trim().length === 0) return undefined;
    this.trackPlanTelemetry('plan_submitted', {
      has_options: display.options !== undefined && display.options.length >= 2,
    });
    return this.toolApproval.requestToolApproval(
      context,
      {
        kind: 'ask',
        reason: {
          has_options: display.options !== undefined,
        },
        resolveApproval: (result) => this.approvalResult(result, display),
      },
      'exit-plan-mode-review-ask',
    );
  }

  private approvalResult(
    result: ApprovalResponse,
    display: PlanReviewDisplay,
  ): PermissionPolicyResolution | undefined {
    if (result.decision !== 'approved') {
      return this.rejectedApprovalResult(result);
    }

    const selected = selectedExitPlanModeOption(display.options, result.selectedLabel);
    this.plan.exit();

    if (result.selectedLabel !== undefined && result.selectedLabel.length > 0) {
      this.trackPlanTelemetry('plan_resolved', {
        outcome: 'approved',
        chosen_option: result.selectedLabel,
      });
    } else {
      this.trackPlanTelemetry('plan_resolved', { outcome: 'approved' });
    }

    const optionPrefix =
      selected === undefined
        ? ''
        : `Selected approach: ${selected.label}\nExecute ONLY the selected approach. Do not execute any unselected alternatives.\n\n`;
    const savedTo = display.path !== undefined ? `Plan saved to: ${display.path}\n\n` : '';
    const formattedPlan = `Plan mode deactivated. All tools are now available.\n${savedTo}## Approved Plan:\n${display.plan}`;
    return {
      kind: 'result',
      result: {
        isError: false,
        output: `Exited plan mode. ${optionPrefix}${formattedPlan}`,
      },
    };
  }

  private rejectedApprovalResult(result: ApprovalResponse): PermissionPolicyResolution {
    this.trackRejectedPlanResolution(result);

    if (result.decision === 'cancelled') {
      return {
        kind: 'result',
        result: {
          isError: false,
          output: 'Plan approval dismissed. Plan mode remains active.',
        },
      };
    }

    if (result.selectedLabel === 'Reject and Exit') {
      this.plan.exit();
      return {
        kind: 'result',
        result: {
          isError: true,
          stopTurn: true,
          output: 'Plan rejected by user. Plan mode deactivated.',
        },
      };
    }

    const feedback = result.feedback ?? '';
    if (result.selectedLabel === 'Revise' || feedback.length > 0) {
      return {
        kind: 'result',
        result: {
          isError: false,
          output:
            feedback.length > 0
              ? `User rejected the plan. Feedback:\n\n${feedback}`
              : 'User requested revisions. Plan mode remains active.',
        },
      };
    }

    return {
      kind: 'result',
      result: {
        isError: true,
        stopTurn: true,
        output: 'Plan rejected by user. Plan mode remains active.',
      },
    };
  }

  private trackRejectedPlanResolution(result: ApprovalResponse): void {
    if (result.decision === 'cancelled') {
      this.trackPlanTelemetry('plan_resolved', { outcome: 'dismissed' });
      return;
    }

    if (result.selectedLabel === 'Reject and Exit') {
      this.trackPlanTelemetry('plan_resolved', { outcome: 'rejected_and_exited' });
      return;
    }

    const feedback = result.feedback ?? '';
    if (result.selectedLabel === 'Revise' || feedback.length > 0) {
      this.trackPlanTelemetry('plan_resolved', {
        outcome: 'revise',
        has_feedback: feedback.length > 0,
      });
      return;
    }

    this.trackPlanTelemetry('plan_resolved', { outcome: 'rejected' });
  }

  private trackPlanTelemetry(event: 'plan_submitted', properties: PlanSubmittedEvent): void;
  private trackPlanTelemetry(event: 'plan_resolved', properties: PlanResolvedEvent): void;
  private trackPlanTelemetry(
    event: 'plan_submitted' | 'plan_resolved',
    properties: PlanSubmittedEvent | PlanResolvedEvent,
  ): void {
    if (event === 'plan_submitted') {
      this.telemetry.track2('plan_submitted', properties as PlanSubmittedEvent);
    } else {
      this.telemetry.track2('plan_resolved', properties as PlanResolvedEvent);
    }
  }
}

function selectedExitPlanModeOption(
  options: readonly PlanReviewOption[] | undefined,
  label: string | undefined,
): PlanReviewOption | undefined {
  if (options === undefined || label === undefined) return undefined;
  return options.find((option) => option.label === label);
}