import * as z from "zod/mini";
import { previewConnectionPairResponseSchema } from "./preview-connection.js";

export const PREVIEW_PAIRING_TRANSPORT_SOURCE = "getuserfeedback.preview";

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

export const previewPairingHostRequestSchema = z.object({
	source: z.literal(PREVIEW_PAIRING_TRANSPORT_SOURCE),
	type: z.literal("preview.connection.pair.request"),
	requestId: nonEmptyStringSchema,
	previewToken: nonEmptyStringSchema,
	expectedRevision: z.number().check(z.int(), z.positive()),
	capabilities: z.array(nonEmptyStringSchema),
});

const previewPairingErrorSchema = z.object({
	message: nonEmptyStringSchema,
	code: z.optional(nonEmptyStringSchema),
});

export const previewPairingHostAckSchema = z.object({
	source: z.literal(PREVIEW_PAIRING_TRANSPORT_SOURCE),
	type: z.literal("preview.connection.pair.ack"),
	requestId: nonEmptyStringSchema,
});

export const previewConnectionHostContextUpdatedSchema = z.strictObject({
	source: z.literal(PREVIEW_PAIRING_TRANSPORT_SOURCE),
	type: z.literal("preview.connection.host-context.updated"),
	url: z.url(),
});

export const previewConnectionPairingStatusRequestSchema = z.strictObject({
	source: z.literal(PREVIEW_PAIRING_TRANSPORT_SOURCE),
	type: z.literal("preview.connection.pairing-status.request"),
	requestId: nonEmptyStringSchema,
	appId: nonEmptyStringSchema,
});

export const previewConnectionPairingStatusResultSchema = z.strictObject({
	source: z.literal(PREVIEW_PAIRING_TRANSPORT_SOURCE),
	type: z.literal("preview.connection.pairing-status.result"),
	requestId: nonEmptyStringSchema,
	paired: z.boolean(),
});

export const previewConnectionUnpairRequestSchema = z.strictObject({
	source: z.literal(PREVIEW_PAIRING_TRANSPORT_SOURCE),
	type: z.literal("preview.connection.unpair.request"),
});

export const previewConnectionUnpairedSchema = z.strictObject({
	source: z.literal(PREVIEW_PAIRING_TRANSPORT_SOURCE),
	type: z.literal("preview.connection.unpaired"),
	reason: z.literal("superseded"),
});

const previewPairingHostResultSuccessSchema = z.object({
	source: z.literal(PREVIEW_PAIRING_TRANSPORT_SOURCE),
	type: z.literal("preview.connection.pair.result"),
	requestId: nonEmptyStringSchema,
	ok: z.literal(true),
	result: previewConnectionPairResponseSchema,
});

const previewPairingHostResultErrorSchema = z.object({
	source: z.literal(PREVIEW_PAIRING_TRANSPORT_SOURCE),
	type: z.literal("preview.connection.pair.result"),
	requestId: nonEmptyStringSchema,
	ok: z.literal(false),
	error: previewPairingErrorSchema,
});

export const previewPairingHostResultSchema = z.discriminatedUnion("ok", [
	previewPairingHostResultSuccessSchema,
	previewPairingHostResultErrorSchema,
]);

export type PreviewPairingHostRequest = z.output<
	typeof previewPairingHostRequestSchema
>;
export type PreviewPairingHostAck = z.output<
	typeof previewPairingHostAckSchema
>;
export type PreviewPairingHostResult = z.output<
	typeof previewPairingHostResultSchema
>;
export type PreviewConnectionHostContextUpdated = z.output<
	typeof previewConnectionHostContextUpdatedSchema
>;
export type PreviewConnectionPairingStatusRequest = z.output<
	typeof previewConnectionPairingStatusRequestSchema
>;
export type PreviewConnectionPairingStatusResult = z.output<
	typeof previewConnectionPairingStatusResultSchema
>;
export type PreviewConnectionUnpairRequest = z.output<
	typeof previewConnectionUnpairRequestSchema
>;
export type PreviewConnectionUnpaired = z.output<
	typeof previewConnectionUnpairedSchema
>;