import * as z from "zod/mini";
import {
	appEventCustomerOccurrenceSchema,
	appEventExternalIdSchema,
	appEventSystemTrackSchema,
} from "./app-event.js";
import { ErrorEventSchema } from "./errors.js";
import { listInstanceFeedbackMineRequestSchema } from "./instance-feedback.js";
import { coreInitOptionsSchema } from "./internal/core-init-options.js";
import { inlineFlowSchema } from "./internal/inline-flow.js";
import { instanceFeedbackInputSchema } from "./internal/instance-feedback-input.js";
import { responseMetadataInputSchema } from "./response-metadata.js";
import { configureOptionsSchema } from "./widget-config.js";

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

const identifyTraitsSchema = z.record(z.string(), z.unknown());
const identifyOptionsSchema = z.strictObject({
	externalIds: z.optional(
		z.array(appEventExternalIdSchema).check(z.maxLength(20)),
	),
});

const identifyPayloadSchema = z.union([
	z.strictObject({
		kind: z.literal("identify"),
		traits: identifyTraitsSchema,
		options: z.optional(identifyOptionsSchema),
	}),
	z.strictObject({
		kind: z.literal("identify"),
		userId: z.string().check(z.trim(), z.minLength(1)),
		traits: z.optional(identifyTraitsSchema),
		options: z.optional(identifyOptionsSchema),
	}),
]);

const legacySystemTrackPayloadSchema = z.pipe(
	z.extend(appEventSystemTrackSchema, {
		kind: z.literal("track"),
		origin: z.optional(z.literal("system")),
	}),
	z.transform(({ origin: _origin, ...rest }) => ({
		...rest,
		origin: "system" as const,
	})),
);

const customerOccurrencePayloadSchema = z.extend(
	appEventCustomerOccurrenceSchema,
	{
		kind: z.literal("track"),
	},
);

const trackPayloadSchema = z.union([
	legacySystemTrackPayloadSchema,
	customerOccurrencePayloadSchema,
]);

const prefetchPayloadSchema = z.strictObject({
	kind: z.literal("prefetch"),
	flowId: flowIdSchema,
	flowHandleId: z.optional(flowHandleIdSchema),
});

const prefetchInlinePayloadSchema = z.strictObject({
	kind: z.literal("prefetch"),
	flow: inlineFlowSchema,
	flowHandleId: z.optional(flowHandleIdSchema),
});

const openPersistedCorePayloadSchema = z.strictObject({
	kind: z.literal("open"),
	flowId: flowIdSchema,
	flowHandleId: z.optional(flowHandleIdSchema),
	metadata: z.optional(responseMetadataInputSchema),
	hideCloseButton: z.optional(z.boolean()),
});

const openInlineCorePayloadSchema = z.strictObject({
	kind: z.literal("open"),
	flow: inlineFlowSchema,
	flowHandleId: z.optional(flowHandleIdSchema),
	metadata: z.optional(responseMetadataInputSchema),
	hideCloseButton: z.optional(z.boolean()),
});

const prerenderPersistedCorePayloadSchema = z.strictObject({
	kind: z.literal("prerender"),
	flowId: flowIdSchema,
	flowHandleId: z.optional(flowHandleIdSchema),
	hideCloseButton: z.optional(z.boolean()),
});

const prerenderInlineCorePayloadSchema = z.strictObject({
	kind: z.literal("prerender"),
	flow: inlineFlowSchema,
	flowHandleId: z.optional(flowHandleIdSchema),
	hideCloseButton: z.optional(z.boolean()),
});

const closeCorePayloadSchema = z.object({
	kind: z.literal("close"),
	flowHandleId: z.optional(flowHandleIdSchema),
	reasonCode: z.optional(z.enum(["CLOSED", "RESET"])),
});

const hostContextUpdatedPayloadSchema = z.object({
	kind: z.literal("hostContextUpdated"),
	context: z.object({
		url: z.string().check(z.url()),
		env: z.optional(z.record(z.string(), z.string())),
		storage: z.optional(z.record(z.string(), z.string())),
		page: z.optional(
			z.object({
				path: z.optional(z.string()),
				referrer: z.optional(z.string()),
				search: z.optional(z.string()),
			}),
		),
	}),
});

const hostSignalPayloadSchema = z.object({
	kind: z.literal("hostSignal"),
	name: z.string(),
	data: z.optional(z.unknown()),
});

const setTargetingPlanPayloadSchema = z.object({
	kind: z.literal("setTargetingPlan"),
	plan: z.object({
		strategy: z.optional(z.enum(["firstMatch"])),
		candidates: z.array(
			z.object({
				action: z.enum(["open", "prefetch"]),
				flowId: flowIdSchema,
				rules: z.array(z.unknown()),
			}),
		),
	}),
});

const telemetryPayloadSchema = z.object({
	kind: z.literal("telemetry"),
	name: z.string(),
	props: z.optional(z.record(z.string(), z.unknown())),
});

const errorPayloadSchema = z.object({
	kind: z.literal("error"),
	event: ErrorEventSchema,
});

const configureCorePayloadSchema = z.object({
	kind: z.literal("configure"),
	opts: configureOptionsSchema,
});

const initCorePayloadSchema = z.strictObject({
	kind: z.literal("init"),
	opts: coreInitOptionsSchema,
});

const resetPayloadSchema = z.object({
	kind: z.literal("reset"),
});

const instanceFeedbackCapturePayloadSchema = z.object({
	kind: z.literal("instanceFeedback.capture"),
	payload: instanceFeedbackInputSchema,
});

const instanceFeedbackListMinePayloadSchema = z.object({
	kind: z.literal("instanceFeedback.listMine"),
	payload: listInstanceFeedbackMineRequestSchema,
});

const coreCommandPayloadWithoutIdentifySchema = z.union([
	z.union([openPersistedCorePayloadSchema, openInlineCorePayloadSchema]),
	z.union([prefetchPayloadSchema, prefetchInlinePayloadSchema]),
	z.union([
		prerenderPersistedCorePayloadSchema,
		prerenderInlineCorePayloadSchema,
	]),
	hostContextUpdatedPayloadSchema,
	hostSignalPayloadSchema,
	setTargetingPlanPayloadSchema,
	telemetryPayloadSchema,
	configureCorePayloadSchema,
	initCorePayloadSchema,
	closeCorePayloadSchema,
	resetPayloadSchema,
	instanceFeedbackCapturePayloadSchema,
	instanceFeedbackListMinePayloadSchema,
	errorPayloadSchema,
]);

export const coreCommandPayloadSchema = z.union([
	coreCommandPayloadWithoutIdentifySchema,
	identifyPayloadSchema,
	trackPayloadSchema,
]);

export type CoreCommandPayload = z.output<typeof coreCommandPayloadSchema>;