import * as z from "zod/mini";
import { generationSchema } from "./v3-generation.js";

const canonicalIdStringSchema = z.string().check(z.trim(), z.minLength(1));

export const EXPLICIT_PROJECTION_RUN_BINDING_V1_CAPABILITY =
	"explicit-projection-run-binding-v1" as const;

const commandOpenRequestMetadataSchema = z.strictObject({
	source: z.literal("command"),
	flowId: z.optional(canonicalIdStringSchema),
	requestId: canonicalIdStringSchema,
	flowHandleId: z.optional(canonicalIdStringSchema),
	hideCloseButton: z.optional(z.boolean()),
});

const targetingOpenRequestMetadataSchema = z.strictObject({
	source: z.literal("targeting"),
	flowId: canonicalIdStringSchema,
});

export const openRequestMetadataSchema = z.discriminatedUnion("source", [
	commandOpenRequestMetadataSchema,
	targetingOpenRequestMetadataSchema,
]);

export type OpenRequestMetadata = z.output<typeof openRequestMetadataSchema>;

const coreViewHostActionEnvelopeSchema = z.strictObject({
	t: z.string().check(z.startsWith("getuserfeedback:")),
	gen: generationSchema,
	viewId: z.optional(canonicalIdStringSchema),
});

// Keep this an object so enclosing unions can still discriminate by `t`.
// Production senders remain on srcdoc. Hosted enablement must account for
// independently deployed Loader/Core versions before any sender switches.
export const actionPrerenderViewSchema = z
	.extend(coreViewHostActionEnvelopeSchema, {
		t: z.literal("getuserfeedback:action:prerenderView"),
		viewId: canonicalIdStringSchema,
		flowRunId: canonicalIdStringSchema,
		srcdoc: z.optional(z.string().check(z.minLength(1))),
		hosted: z.optional(
			z.strictObject({ url: z.string().check(z.minLength(1)) }),
		),
		instanceId: canonicalIdStringSchema,
		openRequest: z.optional(openRequestMetadataSchema),
	})
	.check(
		z.refine(
			(value) => (value.srcdoc !== undefined) !== (value.hosted !== undefined),
			{
				message: "Prerender View requires exactly one of srcdoc or hosted",
			},
		),
	);

export type ActionPrerenderView = z.output<typeof actionPrerenderViewSchema>;

export type PrerenderViewDocumentSource =
	| { srcdoc: string; hosted?: never }
	| { srcdoc?: never; hosted: NonNullable<ActionPrerenderView["hosted"]> };

export const actionActivateViewSchema = z.extend(
	coreViewHostActionEnvelopeSchema,
	{
		t: z.literal("getuserfeedback:action:activateView"),
		viewId: canonicalIdStringSchema,
		flowRunId: canonicalIdStringSchema,
		instanceId: canonicalIdStringSchema,
		openRequest: z.optional(openRequestMetadataSchema),
	},
);

export type ActionActivateView = z.output<typeof actionActivateViewSchema>;

export const actionCloseViewSchema = z.extend(
	coreViewHostActionEnvelopeSchema,
	{
		t: z.literal("getuserfeedback:action:closeView"),
		viewId: canonicalIdStringSchema,
		closeAttemptId: canonicalIdStringSchema,
	},
);

export type ActionCloseView = z.output<typeof actionCloseViewSchema>;

export const coreViewHostActionSchema = z.discriminatedUnion("t", [
	actionPrerenderViewSchema,
	actionActivateViewSchema,
	actionCloseViewSchema,
]);

export type CoreViewHostAction = z.output<typeof coreViewHostActionSchema>;