import { RedactedDBKey, VirtualKey } from "@/lib/types/governance";
import {
	CostHistogramResponse,
	LatencyHistogramResponse,
	LogEntry,
	LogFilters,
	LogSessionDetailResponse,
	LogSessionSummaryResponse,
	LogsHistogramResponse,
	LogStats,
	ModelHistogramResponse,
	ModelRankingsResponse,
	Pagination,
	ProviderCostHistogramResponse,
	ProviderLatencyHistogramResponse,
	ProviderTokenHistogramResponse,
	RecalculateCostResponse,
	TokenHistogramResponse,
} from "@/lib/types/logs";
import { baseApi } from "./baseApi";
import { RoutingRule } from "@/lib/types/routingRules";

// Helper function to build filter params
function buildFilterParams(filters: LogFilters): Record<string, string | number> {
	const params: Record<string, string | number> = {};

	if (filters.parent_request_id) {
		params.parent_request_id = filters.parent_request_id;
	}
	if (filters.providers && filters.providers.length > 0) {
		params.providers = filters.providers.join(",");
	}
	if (filters.models && filters.models.length > 0) {
		params.models = filters.models.join(",");
	}
	if (filters.aliases && filters.aliases.length > 0) {
		params.aliases = filters.aliases.join(",");
	}
	if (filters.status && filters.status.length > 0) {
		params.status = filters.status.join(",");
	}
	if (filters.objects && filters.objects.length > 0) {
		params.objects = filters.objects.join(",");
	}
	if (filters.selected_key_ids && filters.selected_key_ids.length > 0) {
		params.selected_key_ids = filters.selected_key_ids.join(",");
	}
	if (filters.virtual_key_ids && filters.virtual_key_ids.length > 0) {
		params.virtual_key_ids = filters.virtual_key_ids.join(",");
	}
	if (filters.routing_rule_ids && filters.routing_rule_ids.length > 0) {
		params.routing_rule_ids = filters.routing_rule_ids.join(",");
	}
	if (filters.routing_engine_used && filters.routing_engine_used.length > 0) {
		params.routing_engine_used = filters.routing_engine_used.join(",");
	}
	if (filters.start_time) params.start_time = filters.start_time;
	if (filters.end_time) params.end_time = filters.end_time;
	if (filters.min_latency !== undefined) params.min_latency = filters.min_latency;
	if (filters.max_latency !== undefined) params.max_latency = filters.max_latency;
	if (filters.min_tokens !== undefined) params.min_tokens = filters.min_tokens;
	if (filters.max_tokens !== undefined) params.max_tokens = filters.max_tokens;
	if (filters.missing_cost_only) params.missing_cost_only = "true";
	if (filters.content_search) params.content_search = filters.content_search;
	if (filters.user_ids && filters.user_ids.length > 0) {
		params.user_ids = filters.user_ids.join(",");
	}
	if (filters.team_ids && filters.team_ids.length > 0) {
		params.team_ids = filters.team_ids.join(",");
	}
	if (filters.customer_ids && filters.customer_ids.length > 0) {
		params.customer_ids = filters.customer_ids.join(",");
	}
	if (filters.business_unit_ids && filters.business_unit_ids.length > 0) {
		params.business_unit_ids = filters.business_unit_ids.join(",");
	}
	if (filters.metadata_filters) {
		for (const [key, value] of Object.entries(filters.metadata_filters)) {
			params[`metadata_${key}`] = value;
		}
	}

	return params;
}

export const logsApi = baseApi.injectEndpoints({
	endpoints: (builder) => ({
		// Get logs with filters and pagination
		getLogs: builder.query<
			{
				logs: LogEntry[];
				pagination: Pagination;
				stats: LogStats;
				has_logs: boolean;
			},
			{
				filters: LogFilters;
				pagination: Pagination;
			}
		>({
			query: ({ filters, pagination }) => ({
				url: "/logs",
				params: {
					limit: pagination.limit,
					offset: pagination.offset,
					sort_by: pagination.sort_by,
					order: pagination.order,
					...buildFilterParams(filters),
				},
			}),
			providesTags: ["Logs"],
		}),

		getLogSessionById: builder.query<
			LogSessionDetailResponse,
			{
				sessionId: string;
				pagination: Pick<Pagination, "limit" | "offset" | "order">;
			}
		>({
			query: ({ sessionId, pagination }) => ({
				url: `/logs/sessions/${encodeURIComponent(sessionId)}`,
				params: {
					limit: pagination.limit,
					offset: pagination.offset,
					order: pagination.order,
				},
			}),
			providesTags: ["Logs"],
		}),

		getLogSessionSummaryById: builder.query<LogSessionSummaryResponse, string>({
			query: (sessionId) => ({
				url: `/logs/sessions/${encodeURIComponent(sessionId)}/summary`,
			}),
			providesTags: ["Logs"],
		}),

		// Get logs statistics with filters
		getLogsStats: builder.query<
			LogStats,
			{
				filters: LogFilters;
			}
		>({
			query: ({ filters }) => ({
				url: "/logs/stats",
				params: buildFilterParams(filters),
			}),
			providesTags: ["Logs"],
		}),

		// Get logs histogram with filters
		getLogsHistogram: builder.query<
			LogsHistogramResponse,
			{
				filters: LogFilters;
			}
		>({
			query: ({ filters }) => ({
				url: "/logs/histogram",
				params: buildFilterParams(filters),
			}),
			providesTags: ["Logs"],
		}),

		// Get token usage histogram with filters
		getLogsTokenHistogram: builder.query<
			TokenHistogramResponse,
			{
				filters: LogFilters;
			}
		>({
			query: ({ filters }) => ({
				url: "/logs/histogram/tokens",
				params: buildFilterParams(filters),
			}),
			providesTags: ["Logs"],
		}),

		// Get cost histogram with filters and model breakdown
		getLogsCostHistogram: builder.query<
			CostHistogramResponse,
			{
				filters: LogFilters;
			}
		>({
			query: ({ filters }) => ({
				url: "/logs/histogram/cost",
				params: buildFilterParams(filters),
			}),
			providesTags: ["Logs"],
		}),

		// Get model usage histogram with filters
		getLogsModelHistogram: builder.query<
			ModelHistogramResponse,
			{
				filters: LogFilters;
			}
		>({
			query: ({ filters }) => ({
				url: "/logs/histogram/models",
				params: buildFilterParams(filters),
			}),
			providesTags: ["Logs"],
		}),

		// Get latency histogram with percentiles
		getLogsLatencyHistogram: builder.query<
			LatencyHistogramResponse,
			{
				filters: LogFilters;
			}
		>({
			query: ({ filters }) => ({
				url: "/logs/histogram/latency",
				params: buildFilterParams(filters),
			}),
			providesTags: ["Logs"],
		}),

		// Get provider cost histogram with provider breakdown
		getLogsProviderCostHistogram: builder.query<
			ProviderCostHistogramResponse,
			{
				filters: LogFilters;
			}
		>({
			query: ({ filters }) => ({
				url: "/logs/histogram/cost/by-provider",
				params: buildFilterParams(filters),
			}),
			providesTags: ["Logs"],
		}),

		// Get provider token histogram with provider breakdown
		getLogsProviderTokenHistogram: builder.query<
			ProviderTokenHistogramResponse,
			{
				filters: LogFilters;
			}
		>({
			query: ({ filters }) => ({
				url: "/logs/histogram/tokens/by-provider",
				params: buildFilterParams(filters),
			}),
			providesTags: ["Logs"],
		}),

		// Get provider latency histogram with provider breakdown
		getLogsProviderLatencyHistogram: builder.query<
			ProviderLatencyHistogramResponse,
			{
				filters: LogFilters;
			}
		>({
			query: ({ filters }) => ({
				url: "/logs/histogram/latency/by-provider",
				params: buildFilterParams(filters),
			}),
			providesTags: ["Logs"],
		}),

		// Get model rankings with trends
		getModelRankings: builder.query<
			ModelRankingsResponse,
			{
				filters: LogFilters;
			}
		>({
			query: ({ filters }) => ({
				url: "/logs/rankings",
				params: buildFilterParams(filters),
			}),
			providesTags: ["Logs"],
		}),

		// Get dropped requests count
		getDroppedRequests: builder.query<{ dropped_requests: number }, void>({
			query: () => "/logs/dropped",
			providesTags: ["Logs"],
		}),

		// Get available models
		getAvailableFilterData: builder.query<
			{
				models: string[];
				aliases: string[];
				selected_keys: RedactedDBKey[];
				virtual_keys: VirtualKey[];
				routing_rules: RoutingRule[];
				routing_engines: string[];
				metadata_keys: Record<string, string[]>;
			},
			void
		>({
			query: () => "/logs/filterdata",
			providesTags: ["Logs"],
		}),

		// Delete logs by their IDs
		deleteLogs: builder.mutation<void, { ids: string[] }>({
			query: ({ ids }) => ({
				url: "/logs",
				method: "DELETE",
				body: { ids },
			}),
			invalidatesTags: ["Logs"],
		}),

		recalculateLogCosts: builder.mutation<RecalculateCostResponse, { filters: LogFilters; limit?: number }>({
			query: ({ filters, limit }) => ({
				url: "/logs/recalculate-cost",
				method: "POST",
				body: { filters, limit },
			}),
			invalidatesTags: ["Logs"],
		}),

		// Get a single log entry by ID (includes raw_request and raw_response)
		getLogById: builder.query<LogEntry, string>({
			query: (id) => `/logs/${encodeURIComponent(id)}`,
			providesTags: (result, error, id) => [{ type: "Logs", id }],
		}),
	}),
});

export const {
	useGetLogsQuery,
	useGetLogsStatsQuery,
	useGetLogsHistogramQuery,
	useGetLogsTokenHistogramQuery,
	useGetLogsCostHistogramQuery,
	useGetLogsModelHistogramQuery,
	useGetLogsLatencyHistogramQuery,
	useGetLogsProviderCostHistogramQuery,
	useGetLogsProviderTokenHistogramQuery,
	useGetLogsProviderLatencyHistogramQuery,
	useGetLogSessionSummaryByIdQuery,
	useGetDroppedRequestsQuery,
	useGetAvailableFilterDataQuery,
	useLazyGetLogSessionByIdQuery,
	useLazyGetLogsQuery,
	useLazyGetLogsStatsQuery,
	useLazyGetLogsHistogramQuery,
	useLazyGetLogsTokenHistogramQuery,
	useLazyGetLogsCostHistogramQuery,
	useLazyGetLogsModelHistogramQuery,
	useLazyGetLogsLatencyHistogramQuery,
	useLazyGetLogsProviderCostHistogramQuery,
	useLazyGetLogsProviderTokenHistogramQuery,
	useLazyGetLogsProviderLatencyHistogramQuery,
	useLazyGetModelRankingsQuery,
	useLazyGetDroppedRequestsQuery,
	useLazyGetAvailableFilterDataQuery,
	useDeleteLogsMutation,
	useRecalculateLogCostsMutation,
	useLazyGetLogByIdQuery,
	useGetLogByIdQuery,
} = logsApi;