import {z} from 'zod'

export type GetApiApiProjectIdRawDataProjectMetadataArgs = {projectId: number, datasetVersionId?: number | undefined, truncateLabels?: boolean | undefined, includeDisabled?: ('both' | 'enabled') | undefined};

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

export const projectDatasetMetadataRatioCount = z.object({training: z.number().int(), testing: z.number().int(), validation: z.number().int()});

export const projectDatasetMetadataRatioNoRatio = z.object({type: z.literal("no-ratio"), hasValidationCategory: z.boolean(), count: projectDatasetMetadataRatioCount});

export const projectDatasetMetadataRatioClass = z.object({trainingRatio: z.number(), testingRatio: z.number(), validationRatio: z.number(), label: z.string(), total: z.number(), totalTraining: z.number(), totalTesting: z.number(), totalValidation: z.number(), totalTrainingStr: z.string(), totalTestingStr: z.string(), totalValidationStr: z.string()});

export const rawDataCategory = z.enum(["training", "testing", "validation", "post-processing"]);

export const projectDatasetMetadataCategoryData = z.object({length: z.number(), category: rawDataCategory, label: z.string()});

export const projectDatasetMetadataRatioClasses = z.object({type: z.literal("classes"), hasValidationCategory: z.boolean(), trainingRatio: z.number(), testingRatio: z.number(), validationRatio: z.number(), showImbalanceTooltip: z.boolean(), showRebalanceDataset: z.boolean(), showTrainTestSplit: z.boolean(), invalidRatioClasses: z.array(projectDatasetMetadataRatioClass).optional(), allRatioClasses: z.array(projectDatasetMetadataRatioClass).optional(), categoryData: z.array(projectDatasetMetadataCategoryData), count: projectDatasetMetadataRatioCount});

export const projectDatasetMetadataRatioRegression = z.object({type: z.literal("regression"), hasValidationCategory: z.boolean(), trainingRatio: z.number(), testingRatio: z.number(), validationRatio: z.number(), categoryData: z.array(projectDatasetMetadataCategoryData), count: projectDatasetMetadataRatioCount});

export const metadataFilterOptions = z.object({totalCount: z.number().int(), count: z.number().int(), optionsList: z.array(z.object({key: z.string(), options: z.array(z.string())}))});

export const rawDataLabelDistributionLabel = z.object({label: z.string(), totalLength: z.number().int(), totalLengthStr: z.string(), dataCount: z.number().int()});

export const projectDatasetMetadataClassesCategory = z.object({type: z.literal("classes"), totalLength: z.string(), totalLengthNumber: z.number().int(), maxLengthMs: z.number().int(), minLengthMs: z.number().int(), minFrequency: z.number().int(), maxFrequency: z.number().int(), itemCount: z.number().int(), isTimeseries: z.boolean(), isFeatures: z.boolean(), metadataFilterOptions: metadataFilterOptions, metadataKeys: z.array(z.string()), changeActionCounts: z.object({insert: z.number().optional(), update: z.number().optional(), delete: z.number().optional()}).optional(), fullLabelCount: z.number().int(), labels: z.array(rawDataLabelDistributionLabel)});

export const projectDatasetMetadataClasses = z.object({ratio: z.discriminatedUnion("type", [projectDatasetMetadataRatioNoRatio, projectDatasetMetadataRatioClasses, projectDatasetMetadataRatioRegression]), labelQueueCount: z.number().int(), totalItemCount: z.number().int(), type: z.literal("classes"), training: projectDatasetMetadataClassesCategory, testing: projectDatasetMetadataClassesCategory, validation: projectDatasetMetadataClassesCategory, postProcessing: projectDatasetMetadataClassesCategory, all: projectDatasetMetadataClassesCategory});

export const rawDataLabelDistributionRegressionValueGroup = z.object({groupMin: z.number(), groupMax: z.number(), totalLength: z.number().int(), totalLengthStr: z.string(), dataCount: z.number().int()});

export const rawDataLabelDistributionRegressionValueGroupsPerKey = z.object({minLabel: z.number(), maxLabel: z.number(), valueGroupsGlobalScale: z.array(rawDataLabelDistributionRegressionValueGroup), valueGroupsLocalScale: z.array(rawDataLabelDistributionRegressionValueGroup)});

export const projectDatasetMetadataRegressionCategory = z.object({type: z.literal("regression"), totalLength: z.string(), totalLengthNumber: z.number().int(), maxLengthMs: z.number().int(), minLengthMs: z.number().int(), minFrequency: z.number().int(), maxFrequency: z.number().int(), itemCount: z.number().int(), isTimeseries: z.boolean(), isFeatures: z.boolean(), metadataFilterOptions: metadataFilterOptions, metadataKeys: z.array(z.string()), changeActionCounts: z.object({insert: z.number().optional(), update: z.number().optional(), delete: z.number().optional()}).optional(), labelsCount: z.number().int(), minLabel: z.number(), maxLabel: z.number(), valueGroups: z.array(rawDataLabelDistributionRegressionValueGroup), groupsPerLabelMapKey: z.record(z.string(), rawDataLabelDistributionRegressionValueGroupsPerKey).optional(), fullLabelCount: z.number().int(), fullLabelMax: z.number().optional(), fullLabelMin: z.number().optional(), fullLabelMean: z.number().optional()});

export const projectDatasetMetadataRegression = z.object({ratio: z.discriminatedUnion("type", [projectDatasetMetadataRatioNoRatio, projectDatasetMetadataRatioClasses, projectDatasetMetadataRatioRegression]), labelQueueCount: z.number().int(), totalItemCount: z.number().int(), type: z.literal("regression"), training: projectDatasetMetadataRegressionCategory, testing: projectDatasetMetadataRegressionCategory, validation: projectDatasetMetadataRegressionCategory, postProcessing: projectDatasetMetadataRegressionCategory, all: projectDatasetMetadataRegressionCategory});

export const getRawDataProjectMetadataResponse = z.object({success: z.boolean(), error: z.string().optional(), metadata: z.discriminatedUnion("type", [projectDatasetMetadataClasses, projectDatasetMetadataRegression])});

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 project dataset metadata
 * 
 * GET /api/{projectId}/raw-data/project-metadata
 * 
 * Also accepts auth: JWTAuthentication, JWTHttpHeaderAuthentication, OAuth2
 */
export const getApiApiProjectIdRawDataProjectMetadata = async (args: GetApiApiProjectIdRawDataProjectMetadataArgs, options?: GetApiApiProjectIdRawDataProjectMetadataOptions) => {
const {baseUrl = "https://studio.edgeimpulse.com/v1", fetch: fetchFn = fetch, ApiKeyAuthentication} = options ?? {}

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

if (args.datasetVersionId != null) query.append("datasetVersionId", String(args.datasetVersionId))
if (args.truncateLabels != null) query.append("truncateLabels", String(args.truncateLabels))
if (args.includeDisabled != null) query.append("includeDisabled", String(args.includeDisabled))
if (ApiKeyAuthentication !== undefined) headers.set("x-api-key", ApiKeyAuthentication)

const url = `${baseUrl.replace(/\/+$/, '')}/api/${encodeURIComponent(String(args.projectId))}/raw-data/project-metadata${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(getRawDataProjectMetadataResponse, await res.json())
};