import { z } from "zod";

/**
 * Transport types supported by the MCP server
 */
export type TransportType = "stdio" | "streamable-http";

/**
 * Session configuration for Streamable HTTP transport
 */
export interface SessionConfig {
	/**
	 * Enable session management (default: true)
	 */
	enabled: boolean;

	/**
	 * Session TTL in milliseconds (default: 1 hour)
	 */
	ttl?: number;

	/**
	 * Interval for session cleanup in milliseconds (default: 5 minutes)
	 */
	cleanupInterval?: number;
}

/**
 * Configuration for stdio transport
 */
export interface StdioTransportConfig {
	type: "stdio";
}

/**
 * Configuration for Streamable HTTP transport
 */
export interface StreamableHttpTransportConfig {
	type: "streamable-http";

	/**
	 * Port to bind the HTTP server to
	 */
	port: number;

	/**
	 * Host address to bind the HTTP server to (default: '127.0.0.1')
	 */
	host: string;

	/**
	 * MCP endpoint path (default: '/mcp')
	 */
	endpoint: string;

	/**
	 * Session management configuration
	 */
	sessionConfig?: SessionConfig;

	/**
	 * Retry interval in milliseconds for SSE polling behavior (optional)
	 * When set, the server will send a retry field in SSE priming events
	 */
	retryInterval?: number;
}

/**
 * Union type for all transport configurations
 */
export type TransportConfig =
	| StdioTransportConfig
	| StreamableHttpTransportConfig;

/**
 * Zod schema for SessionConfig validation
 */
const SessionConfigSchema = z
	.object({
		cleanupInterval: z.number().int().positive().optional(),
		enabled: z.boolean(),
		ttl: z.number().int().positive().optional(),
	})
	.strict();

/**
 * Zod schema for StdioTransportConfig validation
 */
const StdioTransportConfigSchema = z
	.object({
		type: z.literal("stdio"),
	})
	.strict();

/**
 * Zod schema for StreamableHttpTransportConfig validation
 */
const StreamableHttpTransportConfigSchema = z
	.object({
		endpoint: z
			.string()
			.min(1, "Endpoint cannot be empty")
			.regex(/^\//, "Endpoint must start with /"),
		host: z.string().min(1, "Host cannot be empty"),
		port: z
			.number()
			.int()
			.positive()
			.min(1)
			.max(65535, "Port must be between 1 and 65535"),
		retryInterval: z.number().int().positive().optional(),
		sessionConfig: SessionConfigSchema.optional(),
		type: z.literal("streamable-http"),
	})
	.strict();

/**
 * Zod schema for TransportConfig validation (discriminated union)
 */
export const TransportConfigSchema = z.discriminatedUnion("type", [
	StdioTransportConfigSchema,
	StreamableHttpTransportConfigSchema,
]);

/**
 * Type guard to check if config is StdioTransportConfig
 */
export function isStdioTransportConfig(
	config: TransportConfig,
): config is StdioTransportConfig {
	return config.type === "stdio";
}

/**
 * Type guard to check if config is StreamableHttpTransportConfig
 */
export function isStreamableHttpTransportConfig(
	config: TransportConfig,
): config is StreamableHttpTransportConfig {
	return config.type === "streamable-http";
}

/**
 * Default values for SessionConfig
 */
export const DEFAULT_SESSION_CONFIG: Required<SessionConfig> = {
	cleanupInterval: 5 * 60 * 1000, // 5 minutes
	enabled: true,
	ttl: 60 * 60 * 1000, // 1 hour
};

/**
 * Default values for StreamableHttpTransportConfig (excluding required fields)
 */
export const DEFAULT_HTTP_CONFIG = {
	endpoint: "/mcp",
	host: "127.0.0.1",
	sessionConfig: DEFAULT_SESSION_CONFIG,
} as const;