import { z } from 'zod';
import { matchListItemSchema } from './match.schema';

/**
 * Zod schemas for API responses and error handling
 */

/** APIError schema */
export const apiErrorSchema = z.object({
	error: z.string(),
	message: z.string(),
	status_code: z.number().int(),
	timestamp: z.string().datetime().optional()
});

/** Generic APIResponse schema */
export const apiResponseSchema = <T extends z.ZodTypeAny>(dataSchema: T) =>
	z.object({
		data: dataSchema,
		success: z.boolean(),
		error: apiErrorSchema.optional()
	});

/** MatchParseResponse schema */
export const matchParseResponseSchema = z.object({
	match_id: z.string().min(1), // uint64 as string to preserve precision
	status: z.enum(['parsing', 'queued', 'completed', 'error']),
	message: z.string(),
	estimated_time: z.number().int().positive().optional()
});

/** MatchParseStatus schema */
export const matchParseStatusSchema = z.object({
	match_id: z.string().min(1), // uint64 as string to preserve precision
	status: z.enum(['pending', 'parsing', 'completed', 'error']),
	progress: z.number().int().min(0).max(100).optional(),
	error_message: z.string().optional()
});

/** MatchesListResponse schema */
export const matchesListResponseSchema = z.object({
	matches: z.array(matchListItemSchema),
	next_page_time: z.number().int().optional(),
	has_more: z.boolean(),
	total_count: z.number().int().nonnegative().optional()
});

/** MatchesQueryParams schema */
export const matchesQueryParamsSchema = z.object({
	limit: z.number().int().min(1).max(100).optional(),
	map: z.string().optional(),
	player_id: z.number().positive().optional(),
	before_time: z.number().int().positive().optional()
});

/** TrackPlayerResponse schema */
export const trackPlayerResponseSchema = z.object({
	success: z.boolean(),
	message: z.string()
});

/** Parser functions */
export const parseAPIError = (data: unknown) => apiErrorSchema.parse(data);
export const parseMatchParseResponse = (data: unknown) => matchParseResponseSchema.parse(data);
export const parseMatchesList = (data: unknown) => matchesListResponseSchema.parse(data);
export const parseMatchesQueryParams = (data: unknown) => matchesQueryParamsSchema.parse(data);
export const parseTrackPlayerResponse = (data: unknown) => trackPlayerResponseSchema.parse(data);

/** Safe parser functions */
export const parseMatchesListSafe = (data: unknown) => matchesListResponseSchema.safeParse(data);
export const parseAPIErrorSafe = (data: unknown) => apiErrorSchema.safeParse(data);

/** Infer TypeScript types */
export type APIErrorSchema = z.infer<typeof apiErrorSchema>;
export type MatchParseResponseSchema = z.infer<typeof matchParseResponseSchema>;
export type MatchParseStatusSchema = z.infer<typeof matchParseStatusSchema>;
export type MatchesListResponseSchema = z.infer<typeof matchesListResponseSchema>;
export type MatchesQueryParamsSchema = z.infer<typeof matchesQueryParamsSchema>;
export type TrackPlayerResponseSchema = z.infer<typeof trackPlayerResponseSchema>;