import {z} from 'zod'

export type GetApiPlanIdArgs = {plan_id: string, includeDocument?: boolean | undefined, currentPage?: number | undefined, pageSize?: number | undefined};

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

export const matchType = z.enum(["unknown", "screen_view", "custom_event", "user_attributes", "user_identities", "product_action", "promotion_action", "product_impression"]);

export const screenViewEventCriteria = z.object({screen_name: z.string()});

export const customEventCriteria = z.object({event_name: z.string(), custom_event_type: z.enum(["unknown", "navigation", "location", "search", "transaction", "user_content", "user_preference", "social", "other", "media"])});

export const userAttributeCriteria = z.object({});

export const productAction = z.enum(["add_to_cart", "remove_from_cart", "checkout", "checkout_option", "click", "view_detail", "purchase", "refund", "add_to_wishlist", "remove_from_wish_list"]);

export const promotionAction = z.enum(["view", "click"]);

export const commerceActionEventCriteria = z.object({action: z.union([productAction, promotionAction]).optional()});

export const criteria = z.union([screenViewEventCriteria, customEventCriteria, userAttributeCriteria, commerceActionEventCriteria]);

export const dataPointMatch = z.object({type: matchType, criteria: criteria});

export const dataPointValidator = z.object({type: z.literal("json_schema"), definition: z.object({})});

export const dataPoint = z.object({description: z.string().optional(), match: dataPointMatch, validator: dataPointValidator});

export const schemaKeyword = z.enum(["none", "additionalItems", "additionalProperties", "allOf", "anyOf", "const", "contains", "contentEncoding", "contentMediaType", "default", "definitions", "dependencies", "dependentRequired", "dependentSchemas", "else", "enum", "exclusiveMaximum", "exclusiveMinimum", "format", "id", "if", "items", "maxContains", "maximum", "maximum", "maxLength", "maxProperties", "minContains", "minimum", "minItems", "minLength", "minProperties", "multipleOf", "not", "oneOf", "pattern", "patternProperties", "properties", "propertyNames", "readOnly", "required", "then", "type", "unevaluatedItems", "unevaluatedProperties", "uniqueItems", "writeOnly", "$anchor", "$defs", "$id", "$recursiveAnchor", "$recursiveRef", "$ref", "$schema", "$vocabulary", "timeLimit", "$comment", "description", "examples", "title"]);

export const dataPlanPatch = z.object({op: z.enum(["unknown", "add", "remove", "replace", "copy", "move", "test"]).optional(), from: z.string().optional(), path: z.string().optional(), value: z.string().optional()});

export const dataPlanTransformation = z.object({transformation_id: z.number().optional(), transformation_name: z.string().optional(), error_pointer: z.string().optional(), validation_error_types: z.array(z.enum(["unknown", "unplanned", "missing_required", "invalid_value"])).optional(), schema_keywords: z.array(schemaKeyword).optional(), json_patch: z.array(dataPlanPatch).optional(), description: z.string().optional()});

export const versionDocument = z.object({data_points: z.array(dataPoint).optional(), active_transformation_ids: z.array(z.number()).optional(), transformations: dataPlanTransformation.optional()});

export const activatedEnvironment = z.enum(["none", "development", "production"]);

export const dataPlanVersion = z.object({version: z.number().int().optional(), version_description: z.string().optional(), created_on: z.string().optional(), created_by: z.string().optional(), last_modified_on: z.string().optional(), last_modified_by: z.string().optional(), version_document: versionDocument.optional(), activated_environment: activatedEnvironment.optional(), data_plan_id: z.string().optional(), quarantine_feed_id: z.number().nullable().optional()});

export const dataPlanVersionList = z.array(dataPlanVersion);

export const dataPlan = z.object({data_plan_id: z.string().optional(), data_plan_name: z.string().optional(), data_plan_description: z.string().optional(), data_plan_versions: dataPlanVersionList.optional(), created_on: z.string().optional(), created_by: z.string().optional(), last_modified_on: z.string().optional(), last_modified_by: z.string().optional()});

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 a Single Plan
 * 
 * GET /{plan_id}
 */
export const getApiPlanId = async (args: GetApiPlanIdArgs, options?: GetApiPlanIdOptions) => {
const {baseUrl = "https://api.mparticle.com/platform/v2/workspaces/0/plans", fetch: fetchFn = fetch, bearerAuth} = options ?? {}

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

if (args.includeDocument != null) query.append("includeDocument", String(args.includeDocument))
if (args.currentPage != null) query.append("currentPage", String(args.currentPage))
if (args.pageSize != null) query.append("pageSize", String(args.pageSize))
if (bearerAuth !== undefined) headers.set('authorization', `Bearer ${bearerAuth}`)

const url = `${baseUrl.replace(/\/+$/, '')}/${encodeURIComponent(String(args.plan_id))}${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(dataPlan, await res.json())
};