import {z} from 'zod'

export type ActivatedEnvironment = 'none' | 'development' | 'production';

export type MatchType = 'unknown' | 'screen_view' | 'custom_event' | 'user_attributes' | 'user_identities' | 'product_action' | 'promotion_action' | 'product_impression';

export type ScreenViewEventCriteria = {screen_name: string};

export type CustomEventCriteria = {event_name: string, custom_event_type: 'unknown' | 'navigation' | 'location' | 'search' | 'transaction' | 'user_content' | 'user_preference' | 'social' | 'other' | 'media'};

export type UserAttributeCriteria = Record<string, never>;

export type ProductAction = 'add_to_cart' | 'remove_from_cart' | 'checkout' | 'checkout_option' | 'click' | 'view_detail' | 'purchase' | 'refund' | 'add_to_wishlist' | 'remove_from_wish_list';

export type PromotionAction = 'view' | 'click';

export type CommerceActionEventCriteria = {action?: (ProductAction | PromotionAction) | undefined};

export type Criteria = ScreenViewEventCriteria | CustomEventCriteria | UserAttributeCriteria | CommerceActionEventCriteria;

export type DataPointMatch = {type: MatchType, criteria: Criteria};

export type DataPointValidator = {type: 'json_schema', definition: Record<string, never>};

export type DataPoint = {description?: string | undefined, match: DataPointMatch, validator: DataPointValidator};

export type SchemaKeyword = '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 type DataPlanPatch = {op?: ('unknown' | 'add' | 'remove' | 'replace' | 'copy' | 'move' | 'test') | undefined, from?: string | undefined, path?: string | undefined, value?: string | undefined};

export type DataPlanTransformation = {transformation_id?: number | undefined, transformation_name?: string | undefined, error_pointer?: string | undefined, validation_error_types?: (Array<'unknown' | 'unplanned' | 'missing_required' | 'invalid_value'>) | undefined, schema_keywords?: Array<SchemaKeyword> | undefined, json_patch?: Array<DataPlanPatch> | undefined, description?: string | undefined};

export type VersionDocument = {data_points?: Array<DataPoint> | undefined, active_transformation_ids?: Array<number> | undefined, transformations?: DataPlanTransformation | undefined};

export type PatchApiPlanIdVersionsPlanVersionArgs = {plan_id: string, plan_version: number, body: {activated_environment?: ActivatedEnvironment | undefined, version_description?: string | undefined, version_document?: VersionDocument | undefined, quarantine_feed_id?: number | undefined}};

export type PatchApiPlanIdVersionsPlanVersionOptions = {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 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
};

/**
 * Update Data Plan Version
 * 
 * PATCH /{plan_id}/versions/{plan_version}
 */
export const patchApiPlanIdVersionsPlanVersion = async (args: PatchApiPlanIdVersionsPlanVersionArgs, options?: PatchApiPlanIdVersionsPlanVersionOptions) => {
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('content-type', "application/json")
headers.set('accept', "application/json")

if (bearerAuth !== undefined) headers.set('authorization', `Bearer ${bearerAuth}`)

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

const res = await fetchFn(url, {method: "PATCH", headers, body: JSON.stringify(args.body)})

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

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