import { z } from "zod";

export const providerKindSchema = z.enum(["codex", "claudeCode"]);

export const providerApprovalPolicySchema = z.enum([
  "untrusted",
  "on-failure",
  "on-request",
  "never",
]);

export const providerSandboxModeSchema = z.enum([
  "read-only",
  "workspace-write",
  "danger-full-access",
]);

export const providerRequestKindSchema = z.enum(["command", "file-change"]);

export const providerApprovalDecisionSchema = z.enum([
  "accept",
  "acceptForSession",
  "decline",
  "cancel",
]);

export const providerSessionStatusSchema = z.enum([
  "connecting",
  "ready",
  "running",
  "error",
  "closed",
]);

export const providerSessionSchema = z.object({
  sessionId: z.string().min(1),
  provider: providerKindSchema,
  status: providerSessionStatusSchema,
  cwd: z.string().min(1).optional(),
  model: z.string().min(1).optional(),
  threadId: z.string().min(1).optional(),
  activeTurnId: z.string().min(1).optional(),
  createdAt: z.string().datetime(),
  updatedAt: z.string().datetime(),
  lastError: z.string().min(1).optional(),
});

export const providerSessionStartInputSchema = z.object({
  uiThreadId: z.string().trim().min(1).optional(),
  provider: providerKindSchema.default("codex"),
  cwd: z.string().min(1).optional(),
  model: z.string().trim().min(1).optional(),
  resumeThreadId: z.string().trim().min(1).optional(),
  codexBinaryPath: z.string().trim().min(1).optional(),
  codexHomePath: z.string().trim().min(1).optional(),
  approvalPolicy: providerApprovalPolicySchema.default("never"),
  sandboxMode: providerSandboxModeSchema.default("workspace-write"),
});

export const PROVIDER_SEND_TURN_MAX_INPUT_CHARS = 120_000;
export const PROVIDER_SEND_TURN_MAX_ATTACHMENTS = 8;
export const PROVIDER_SEND_TURN_MAX_IMAGE_BYTES = 10 * 1024 * 1024;
export const PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS = 14_000_000;

export const providerSendTurnImageAttachmentSchema = z.object({
  type: z.literal("image"),
  name: z.string().trim().min(1).max(255),
  mimeType: z
    .string()
    .trim()
    .min(1)
    .max(100)
    .regex(/^image\//i, "mimeType must be an image/* MIME type"),
  sizeBytes: z.number().int().min(1).max(PROVIDER_SEND_TURN_MAX_IMAGE_BYTES),
  dataUrl: z.string().trim().min(1).max(PROVIDER_SEND_TURN_MAX_IMAGE_DATA_URL_CHARS),
});

export const providerSendTurnAttachmentInputSchema = z.discriminatedUnion("type", [
  providerSendTurnImageAttachmentSchema,
]);

export const providerSendTurnInputSchema = z
  .object({
    uiThreadId: z.string().trim().min(1).optional(),
    sessionId: z.string().min(1),
    input: z.string().trim().min(1).max(PROVIDER_SEND_TURN_MAX_INPUT_CHARS).optional(),
    attachments: z
      .array(providerSendTurnAttachmentInputSchema)
      .max(PROVIDER_SEND_TURN_MAX_ATTACHMENTS)
      .default([]),
    model: z.string().trim().min(1).optional(),
    effort: z.string().trim().min(1).optional(),
  })
  .superRefine((value, ctx) => {
    if (!value.input && value.attachments.length === 0) {
      ctx.addIssue({
        code: z.ZodIssueCode.custom,
        message: "Either input text or at least one attachment is required",
        path: ["input"],
      });
    }
  });

export const providerTurnStartResultSchema = z.object({
  threadId: z.string().min(1),
  turnId: z.string().min(1),
});

export const providerInterruptTurnInputSchema = z.object({
  sessionId: z.string().min(1),
  turnId: z.string().min(1).optional(),
});

export const providerStopSessionInputSchema = z.object({
  sessionId: z.string().min(1),
});

export const providerListCheckpointsInputSchema = z.object({
  sessionId: z.string().min(1),
});

export const providerCheckpointSchema = z.object({
  id: z.string().min(1),
  turnCount: z.number().int().min(0),
  messageCount: z.number().int().min(0),
  label: z.string().min(1),
  preview: z.string().min(1).optional(),
  isCurrent: z.boolean(),
});

export const providerListCheckpointsResultSchema = z.object({
  threadId: z.string().min(1),
  checkpoints: z.array(providerCheckpointSchema),
});

export const providerRevertToCheckpointInputSchema = z.object({
  sessionId: z.string().min(1),
  turnCount: z.number().int().min(0),
});

export const providerRevertToCheckpointResultSchema = z.object({
  threadId: z.string().min(1),
  turnCount: z.number().int().min(0),
  messageCount: z.number().int().min(0),
  rolledBackTurns: z.number().int().min(0),
  checkpoints: z.array(providerCheckpointSchema),
});

export const providerGetCheckpointDiffInputSchema = z
  .object({
    sessionId: z.string().min(1),
    fromTurnCount: z.number().int().min(0),
    toTurnCount: z.number().int().min(0),
  })
  .superRefine((value, ctx) => {
    if (value.fromTurnCount > value.toTurnCount) {
      ctx.addIssue({
        code: z.ZodIssueCode.custom,
        message: "fromTurnCount must be less than or equal to toTurnCount",
        path: ["fromTurnCount"],
      });
    }
  });

export const providerGetCheckpointDiffResultSchema = z.object({
  threadId: z.string().min(1),
  fromTurnCount: z.number().int().min(0),
  toTurnCount: z.number().int().min(0),
  diff: z.string(),
});

export const providerRespondToRequestInputSchema = z.object({
  sessionId: z.string().min(1),
  requestId: z.string().min(1),
  decision: providerApprovalDecisionSchema,
});

export const providerEventKindSchema = z.enum(["session", "notification", "request", "error"]);

export const providerEventSchema = z.object({
  id: z.string().min(1),
  kind: providerEventKindSchema,
  provider: providerKindSchema,
  sessionId: z.string().min(1),
  createdAt: z.string().datetime(),
  method: z.string().min(1),
  message: z.string().min(1).optional(),
  threadId: z.string().min(1).optional(),
  turnId: z.string().min(1).optional(),
  itemId: z.string().min(1).optional(),
  requestId: z.string().min(1).optional(),
  requestKind: providerRequestKindSchema.optional(),
  textDelta: z.string().optional(),
  payload: z.unknown().optional(),
});

export type ProviderKind = z.infer<typeof providerKindSchema>;
export type ProviderApprovalPolicy = z.infer<typeof providerApprovalPolicySchema>;
export type ProviderSandboxMode = z.infer<typeof providerSandboxModeSchema>;
export type ProviderRequestKind = z.infer<typeof providerRequestKindSchema>;
export type ProviderApprovalDecision = z.infer<typeof providerApprovalDecisionSchema>;
export type ProviderSessionStatus = z.infer<typeof providerSessionStatusSchema>;
export type ProviderSession = z.infer<typeof providerSessionSchema>;
export type ProviderSessionStartInput = z.input<typeof providerSessionStartInputSchema>;
export type ProviderSendTurnImageAttachment = z.infer<typeof providerSendTurnImageAttachmentSchema>;
export type ProviderSendTurnAttachment = z.infer<typeof providerSendTurnAttachmentInputSchema>;
export type ProviderSendTurnAttachmentInput = z.input<typeof providerSendTurnAttachmentInputSchema>;
export type ProviderSendTurnInput = z.input<typeof providerSendTurnInputSchema>;
export type ProviderTurnStartResult = z.infer<typeof providerTurnStartResultSchema>;
export type ProviderInterruptTurnInput = z.input<typeof providerInterruptTurnInputSchema>;
export type ProviderStopSessionInput = z.input<typeof providerStopSessionInputSchema>;
export type ProviderListCheckpointsInput = z.input<typeof providerListCheckpointsInputSchema>;
export type ProviderCheckpoint = z.infer<typeof providerCheckpointSchema>;
export type ProviderListCheckpointsResult = z.infer<typeof providerListCheckpointsResultSchema>;
export type ProviderRevertToCheckpointInput = z.input<typeof providerRevertToCheckpointInputSchema>;
export type ProviderRevertToCheckpointResult = z.infer<
  typeof providerRevertToCheckpointResultSchema
>;
export type ProviderGetCheckpointDiffInput = z.input<typeof providerGetCheckpointDiffInputSchema>;
export type ProviderGetCheckpointDiffResult = z.infer<typeof providerGetCheckpointDiffResultSchema>;
export type ProviderRespondToRequestInput = z.input<typeof providerRespondToRequestInputSchema>;
export type ProviderEventKind = z.infer<typeof providerEventKindSchema>;
export type ProviderEvent = z.infer<typeof providerEventSchema>;