import * as z from "zod/mini";
import {
	appEventCapabilitySchema,
	appEventExternalIdSchema,
	appEventFlagSchema,
} from "./app-event.js";
import { clientMetaSchema } from "./client-meta.js";
import { DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS } from "./defaults.js";
import { runtimeEndpointsSchema } from "./runtime-endpoints.js";
import { scopeIdSchema } from "./scopes.js";

const colorSchemeValueSchema = z.enum(["light", "dark", "system"]);

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

export const colorSchemeConfigInputSchema = z.union([
	z.strictObject({
		autoDetectColorScheme: autoDetectColorSchemeArraySchema,
	}),
	colorSchemeValueSchema,
]);

export type ColorSchemeConfigInput = z.output<
	typeof colorSchemeConfigInputSchema
>;

export const telemetryConfigInputSchema = z.object({
	enabled: z.optional(z.boolean()),
});

export type TelemetryConfigInput = z.output<typeof telemetryConfigInputSchema>;

export const consentConfigInputSchema = z.union([
	z.enum(["granted", "denied", "pending", "revoked"]),
	z.array(scopeIdSchema),
]);

export type ConsentConfigInput = z.output<typeof consentConfigInputSchema>;

export const debugInputSchema = z.union([
	z.boolean(),
	z.string(),
	z.array(z.string()),
]);

export type DebugConfigInput = z.output<typeof debugInputSchema>;

export const authJwtConfigInputSchema = z.object({
	token: z.string().check(z.trim(), z.minLength(1)),
});

export type AuthJwtConfigInput = z.output<typeof authJwtConfigInputSchema>;

export const authConfigInputSchema = z.object({
	jwt: z.optional(z.union([authJwtConfigInputSchema, z.null()])),
});

export type AuthConfigInput = z.output<typeof authConfigInputSchema>;

export const identityConfigInputSchema = z.object({
	anonymousId: z.optional(z.string().check(z.trim(), z.minLength(1))),
	userId: z.optional(z.string().check(z.trim(), z.minLength(1))),
	traits: z.optional(z.record(z.string(), z.unknown())),
	externalIds: z.optional(
		z.array(appEventExternalIdSchema).check(z.maxLength(20)),
	),
});

export type IdentityConfigInput = z.output<typeof identityConfigInputSchema>;

export const flagsConfigInputSchema = z.array(appEventFlagSchema);

export type FlagsConfigInput = z.output<typeof flagsConfigInputSchema>;

export const hostCapabilitiesConfigInputSchema = z.array(
	appEventCapabilitySchema,
);

export type HostCapabilitiesConfigInput = z.output<
	typeof hostCapabilitiesConfigInputSchema
>;

export const hostActionDefinitionSchema = z.strictObject({
	key: z.string().check(z.trim(), z.minLength(1)),
	version: z
		.number()
		.check(z.int(), z.positive(), z.maximum(Number.MAX_SAFE_INTEGER)),
});

export type HostActionDefinition = z.output<typeof hostActionDefinitionSchema>;

export const hostActionsConfigInputSchema = z.array(hostActionDefinitionSchema);

export const capabilitiesConfigInputSchema = z.array(
	z.union([
		z.string().check(z.trim(), z.minLength(1)),
		appEventCapabilitySchema,
	]),
);

export type CapabilitiesConfigInput = z.output<
	typeof capabilitiesConfigInputSchema
>;

export const configureOptionsSchema = z.strictObject({
	colorScheme: z.optional(colorSchemeConfigInputSchema),
	consent: z.optional(consentConfigInputSchema),
	auth: z.optional(authConfigInputSchema),
	capabilities: z.optional(capabilitiesConfigInputSchema),
});

export type ConfigureOptions = z.output<typeof configureOptionsSchema>;

export const initOptionsSchema = z.strictObject({
	apiKey: z.string().check(z.trim(), z.minLength(1)),
	colorScheme: z.optional(colorSchemeConfigInputSchema),
	disableTelemetry: z.optional(z.boolean()),
	enableDebug: z.optional(debugInputSchema),
	defaultConsent: z.optional(consentConfigInputSchema),
	clientMeta: z.optional(clientMetaSchema),
	capabilities: z.optional(z.array(z.string())),
	flags: z.optional(flagsConfigInputSchema),
	hostCapabilities: z.optional(hostCapabilitiesConfigInputSchema),
	hostActions: z.optional(hostActionsConfigInputSchema),
	runtimeEndpoints: z.optional(runtimeEndpointsSchema),
});

export type InitOptions = z.output<typeof initOptionsSchema>;

export const DEFAULT_COLOR_SCHEME_CONFIG: ColorSchemeConfigInput = {
	autoDetectColorScheme: [...DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS],
};

/**
 * Schema for the subset of instance config that can be updated via merge (any source).
 * Telemetry, enableDebug, clientMeta, SDK protocol capabilities, and customer
 * flags are set at registration only.
 */
export const instanceUpdateableConfigSchema = z.strictObject({
	colorScheme: z.optional(colorSchemeConfigInputSchema),
	consent: z.optional(consentConfigInputSchema),
	auth: z.optional(authConfigInputSchema),
	identity: z.optional(identityConfigInputSchema),
	hostCapabilities: z.optional(hostCapabilitiesConfigInputSchema),
});

export type InstanceUpdateableConfig = z.output<
	typeof instanceUpdateableConfigSchema
>;

/** Keys that may be merged into instance config (updatable subset). */
export const INSTANCE_CONFIG_UPDATE_KEYS: (keyof InstanceUpdateableConfig)[] = [
	"colorScheme",
	"consent",
	"auth",
	"identity",
	"hostCapabilities",
];

/**
 * Schema for resolved instance config state. Used when producing or validating
 * stored config (e.g. after register or merge). Defaults are applied here so
 * state always has a full shape; parse partial input with this schema to get
 * resolved state. For update shape use InstanceUpdateableConfig. Configure
 * command opts are in widget-commands (widgetConfigUpdateSchema).
 */
export const coreInstanceConfigSchema = z.strictObject({
	colorScheme: z._default(z.optional(colorSchemeConfigInputSchema), {
		autoDetectColorScheme: [...DEFAULT_AUTO_DETECT_COLOR_SCHEME_ATTRS],
	}),
	disableTelemetry: z._default(z.optional(z.boolean()), false),
	enableDebug: z._default(z.optional(debugInputSchema), false),
	consent: z.optional(consentConfigInputSchema),
	auth: z.optional(authConfigInputSchema),
	identity: z.optional(identityConfigInputSchema),
	apiKey: z.string().check(z.trim(), z.minLength(1)),
	clientMeta: z.optional(clientMetaSchema),
	capabilities: z.optional(z.array(z.string())),
	flags: z.optional(flagsConfigInputSchema),
	hostCapabilities: z.optional(hostCapabilitiesConfigInputSchema),
	hostActions: z.optional(hostActionsConfigInputSchema),
	runtimeEndpoints: z.optional(runtimeEndpointsSchema),
});

/** Input shape for instance config (partial; used for register/merge). */
export type CoreInstanceConfigInput = z.input<typeof coreInstanceConfigSchema>;

/** Resolved instance config state (defaults applied). */
export type CoreInstanceConfig = z.output<typeof coreInstanceConfigSchema>;