import {z} from 'zod'

export type GetApiV1DashboardsDashboardIdArgs = {dashboardId: string};

export type GetApiV1DashboardsDashboardIdOptions = {baseUrl?: string | undefined, fetch?: typeof fetch | undefined};

export const dashboardWidgetType = z.enum(["LINE", "AREA", "BAR", "STACKED_BAR", "TABLE", "BIG_NUMBER"]);

export const dashboardWidgetUnit = z.enum(["COUNT", "PERCENT", "SCORE", "SECONDS", "USD", "MILLISECONDS"]);

export const dashboardWidgetMode = z.enum(["TIME_SERIES", "DIMENSION_SERIES"]);

export const dashboardWidgetBucketMode = z.enum(["SERIES", "RANGE"]);

export const dashboardDimension = z.enum(["project", "trace_name", "span_name", "model", "type", "thread_id", "test_case_id", "test_run_id", "end_user", "source", "annotator", "name", "error", "prompt_alias", "tag", "label", "evaluation_model", "prompt_version", "prompt_label", "prompt_commit_hash", "metadata", "classifier"]);

export const dashboardTopKOrderBy = z.enum(["count", "avg_latency", "p50_latency", "p90_latency", "p99_latency", "error_rate", "pass_rate", "failure_rate", "input_cost", "output_cost", "total_cost", "avg_cost", "input_tokens", "output_tokens", "total_tokens", "count_distinct_endUserId", "count_distinct_threadId", "count_distinct_model", "count_distinct_projectId", "count_distinct_error", "count_distinct_metadata", "error_count", "avg_score", "stddev_score", "avg_rating", "created_at", "start_time", "dimension"]);

export const dashboardTopKDirection = z.enum(["asc", "desc"]);

export const dashboardTopK = z.object({limit: z.number().int().optional(), orderBy: dashboardTopKOrderBy.optional(), direction: dashboardTopKDirection.optional()});

export const dashboardLayout = z.object({x: z.number().optional(), y: z.number().optional(), w: z.number().optional(), h: z.number().optional()});

export const dashboardLineColor = z.enum(["AMBER", "VIOLET", "EMERALD", "BLUE", "PINK", "CYAN", "ROSE", "LIME", "TEAL", "ORANGE"]);

export const dashboardDataModel = z.enum(["TRACE", "SPAN", "LLM_SPAN", "AGENT_SPAN", "RETRIEVER_SPAN", "TOOL_SPAN", "CUSTOM_SPAN", "THREAD", "END_USER", "METRIC_DATA", "ANNOTATION"]);

export const dashboardAggregation = z.enum(["COUNT", "ERROR_RATE", "PASS_RATE", "UNIQUE_END_USERS", "UNIQUE_THREADS", "UNIQUE_USERS", "UNIQUE_METADATA_VALUES", "AVG_LATENCY", "P50_LATENCY", "P90_LATENCY", "P99_LATENCY", "TOTAL_COST", "AVG_COST", "INPUT_COST", "OUTPUT_COST", "AVG_COST_PER_USER", "INPUT_TOKENS", "OUTPUT_TOKENS", "TOTAL_TOKENS", "ERROR_COUNT", "NEW_USERS", "RETENTION", "AVG_SCORE", "FAILURE_RATE", "AVG_RATING"]);

export const dashboardFilterOperator = z.enum(["AND", "OR"]);

export const dashboardFilterCategory = z.string();

export const dashboardFilterCondition = z.enum(["Is", "Is not", "Is equal to", "Does not equal", "Is less than", "Is equal or less than", "Is greater than", "Is equal or greater than", "Has", "Has not", "Contains", "Contains only", "Does not contain", "Has increased by more than", "Has increased by less than", "Has decreased by more than", "Has decreased by less than", "Has changed from"]);

export const dashboardFilterRow = z.object({category: dashboardFilterCategory, condition: dashboardFilterCondition, value: z.union([z.string(), z.number(), z.array(z.string())]), key: z.string().optional()});

export const dashboardFilterGroup = z.object({operator: dashboardFilterOperator, filters: z.array(dashboardFilterRow)});

export const dashboardFilterSet = z.object({operator: dashboardFilterOperator, groups: z.array(dashboardFilterGroup)});

export const dashboardLineExtraQueryParams = z.object({spanType: z.enum(["LLM", "AGENT", "RETRIEVER", "TOOL", "CUSTOM"]).optional(), metricMetadataKey: z.string().optional(), category: z.enum(["SINGLE_TURN", "MULTI_TURN", "TEST_RUN", "TRACE", "SPAN", "LLM_SPAN", "AGENT_SPAN", "RETRIEVER_SPAN", "TOOL_SPAN", "CUSTOM_SPAN", "THREAD"]).optional(), metricName: z.string().optional(), dataType: z.enum(["Traces", "Spans", "Threads"]).optional(), source: z.enum(["User", "Reviewer"]).optional()}).and(z.record(z.string(), z.string())).nullable();

export const dashboardLine = z.object({id: z.string().optional(), name: z.string().optional(), color: dashboardLineColor.optional(), dataModel: dashboardDataModel.optional(), aggregation: dashboardAggregation.optional(), filters: dashboardFilterSet.optional(), extraQueryParams: dashboardLineExtraQueryParams.optional()});

export const dashboardWidget = z.object({id: z.string().optional(), name: z.string().optional(), description: z.string().nullable().optional(), type: dashboardWidgetType.optional(), unit: dashboardWidgetUnit.optional(), mode: dashboardWidgetMode.optional(), bucketMode: dashboardWidgetBucketMode.optional(), dimension: dashboardDimension.optional(), topK: dashboardTopK.optional(), startTime: z.string().nullable().optional(), endTime: z.string().nullable().optional(), layout: dashboardLayout.optional(), lines: z.array(dashboardLine).optional()});

export const dashboard = z.object({id: z.string().optional(), name: z.string().optional(), description: z.string().nullable().optional(), private: z.boolean().optional(), projectId: z.string().optional(), userId: z.string().nullable().optional(), createdAt: z.string().optional(), updatedAt: z.string().optional(), widgets: z.array(dashboardWidget).optional()});

export const dashboardObjectResponse = z.object({success: z.boolean(), data: z.object({dashboard: dashboard}), deprecated: z.boolean()});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * Get Dashboard
 * 
 * GET /v1/dashboards/{dashboardId}
 */
export const getApiV1DashboardsDashboardId = async (args: GetApiV1DashboardsDashboardIdArgs, options?: GetApiV1DashboardsDashboardIdOptions) => {
const {baseUrl = "https://api.confident-ai.com", fetch: fetchFn = fetch} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

const url = `${baseUrl.replace(/\/+$/, '')}/v1/dashboards/${encodeURIComponent(String(args.dashboardId))}${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(dashboardObjectResponse, await res.json())
};