import {z} from 'zod'

export type CreateApiV2LoyaltiesEarningRulesEarningRuleIdActivateOptions = {baseUrl?: string | undefined, XAppId?: string | undefined, XAppToken?: string | undefined, fetch?: typeof fetch | undefined};

export const earningRuleRulesGroup = z.object({logic: z.string()});

export const loyaltyV2ActivityEarningRuleTierRulesAnyOfEntry = z.object({tier_structure_id: z.string(), tier_ids: z.array(z.string())});

export const earningRuleTierRules = z.object({type: z.enum(["NO_REQUIREMENTS", "ANY_OF"]), any_of: z.array(loyaltyV2ActivityEarningRuleTierRulesAnyOfEntry).nullable().optional()});

export const loyaltyV2ActivityEarningRuleEffectPointsExpirationRollingExpirationPeriod = z.object({unit: z.enum(["DAY", "MONTH", "YEAR"]), value: z.number().int().gte(1)});

export const loyaltyV2ActivityEarningRuleEffectPointsExpirationRollingExpirationRounding = z.object({type: z.enum(["END_OF_MONTH", "END_OF_QUARTER", "END_OF_HALF_YEAR", "END_OF_YEAR", "END_OF_PARTICULAR_MONTH"]), value: z.number().int().gte(1).lte(12).nullable().optional()});

export const earningRuleEffectPointsExpirationRollingExpiration = z.object({period: loyaltyV2ActivityEarningRuleEffectPointsExpirationRollingExpirationPeriod, rounding: loyaltyV2ActivityEarningRuleEffectPointsExpirationRollingExpirationRounding.nullable().optional()});

export const loyaltyV2ActivityEarningRuleEffectPointsExpirationCalendarExpirationDate = z.object({day: z.number().int().gte(1).lte(31), month: z.number().int().gte(1).lte(12)});

export const earningRuleEffectPointsExpirationCalendarExpiration = z.object({expiration_dates: z.array(loyaltyV2ActivityEarningRuleEffectPointsExpirationCalendarExpirationDate)});

export const loyaltyV2ActivityEarningRuleEffectPointsExpirationSlidingExpirationPeriod = z.object({value: z.number().int().gte(1), unit: z.enum(["DAY", "MONTH", "YEAR"])});

export const earningRuleEffectPointsExpirationSlidingExpiration = z.object({earning_activity: z.boolean(), period: loyaltyV2ActivityEarningRuleEffectPointsExpirationSlidingExpirationPeriod});

export const earningRuleEffectPointsExpiration = z.object({type: z.enum(["NO_EXPIRATION", "ROLLING_EXPIRATION", "CALENDAR_EXPIRATION", "SLIDING_EXPIRATION"]), rolling_expiration: earningRuleEffectPointsExpirationRollingExpiration.nullable().optional(), calendar_expiration: earningRuleEffectPointsExpirationCalendarExpiration.nullable().optional(), sliding_expiration: earningRuleEffectPointsExpirationSlidingExpiration.nullable().optional()});

export const earningRuleEffectPoints = z.object({value: z.number().int().gte(0).lte(9007199254740991), card_definition_id: z.string(), points_expiration: earningRuleEffectPointsExpiration.nullable().optional()});

export const loyaltyV2ActivityEarningRulePointsProportionalEvery = z.object({every: z.number().int().gte(1).lte(9007199254740991), value: z.number().gte(0).lte(9007199254740991)});

export const loyaltyV2ActivityEarningRulePointsProportionalMetadata = z.object({every: z.number().int().gte(1).lte(9007199254740991), value: z.number().gte(0).lte(9007199254740991), property: z.string().min(1)});

export const earningRulePointsProportionalOrder = z.object({amount: loyaltyV2ActivityEarningRulePointsProportionalEvery.optional(), total_amount: loyaltyV2ActivityEarningRulePointsProportionalEvery.optional(), metadata: loyaltyV2ActivityEarningRulePointsProportionalMetadata.optional()});

export const earningRulePointsProportionalCustomer = z.object({metadata: loyaltyV2ActivityEarningRulePointsProportionalMetadata});

export const earningRulePointsProportionalCustomEvent = z.object({metadata: loyaltyV2ActivityEarningRulePointsProportionalMetadata});

export const loyaltyV2ActivityEarningRulePointsProportionalApplicableToProduct = z.object({id: z.string()});

export const loyaltyV2ActivityEarningRulePointsProportionalApplicableToSku = z.object({id: z.string()});

export const loyaltyV2ActivityEarningRulePointsProportionalApplicableToProductsCollection = z.object({id: z.string()});

export const earningRulePointsProportionalApplicableTo = z.object({type: z.enum(["product", "sku", "products_collection"]), product: loyaltyV2ActivityEarningRulePointsProportionalApplicableToProduct.optional(), sku: loyaltyV2ActivityEarningRulePointsProportionalApplicableToSku.optional(), products_collection: loyaltyV2ActivityEarningRulePointsProportionalApplicableToProductsCollection.optional()});

export const earningRulePointsProportionalOrderItemsCalculation = z.object({every: z.number().int().gte(1).lte(9007199254740991), value: z.number().gte(0).lte(9007199254740991), applicable_to: z.array(earningRulePointsProportionalApplicableTo)});

export const earningRulePointsProportionalOrderItems = z.object({amount: earningRulePointsProportionalOrderItemsCalculation.optional(), subtotal_amount: earningRulePointsProportionalOrderItemsCalculation.optional(), quantity: earningRulePointsProportionalOrderItemsCalculation.optional()});

export const earningRuleEffectPointsProportional = z.object({calculation_type: z.enum(["PRE_DISCOUNT_ORDER_AMOUNT", "POST_DISCOUNT_ORDER_AMOUNT", "PRE_DISCOUNT_ORDER_ITEMS_AMOUNT", "POST_DISCOUNT_ORDER_ITEMS_AMOUNT", "ORDER_ITEMS_QUANTITY", "ORDER_METADATA_VALUE", "CUSTOMER_METADATA_VALUE", "CUSTOM_EVENT_METADATA_VALUE"]), card_definition_id: z.string(), points_expiration: earningRuleEffectPointsExpiration.nullable().optional(), order: earningRulePointsProportionalOrder.optional(), customer: earningRulePointsProportionalCustomer.optional(), custom_event: earningRulePointsProportionalCustomEvent.optional(), order_items: earningRulePointsProportionalOrderItems.optional()});

export const loyaltyV2ActivityEarningRuleEffectBenefit = z.object({id: z.string()});

export const earningRuleEffect = z.object({type: z.enum(["POINTS", "POINTS_PROPORTIONAL", "BENEFIT"]), points: earningRuleEffectPoints.optional(), points_proportional: earningRuleEffectPointsProportional.optional(), benefit: loyaltyV2ActivityEarningRuleEffectBenefit.optional()});

export const earningRuleEarning = z.object({id: z.string(), name: z.string().max(200).nullable().optional(), rules: earningRuleRulesGroup.optional(), tier_rules: earningRuleTierRules, effects: z.array(earningRuleEffect)});

export const loyaltyV2ActivityEarningRuleTriggerCustomEvent = z.object({schema_id: z.string()});

export const loyaltyV2ActivityEarningRuleTriggerSegment = z.object({id: z.string()});

export const earningRuleTrigger = z.object({event: z.enum(["customer.order.paid", "customer.custom_event", "customer.segment.entered"]), custom_event: loyaltyV2ActivityEarningRuleTriggerCustomEvent.nullable().optional(), segment: loyaltyV2ActivityEarningRuleTriggerSegment.nullable().optional()});

export const loyaltyV2ActivityEarningRuleError = z.object({message: z.string().min(1).max(200)});

export const loyaltyV2ActivityEarningRuleValidityDailyHours = z.object({days_of_week: z.array(z.number().int().gte(0).lte(6)), start_time: z.string(), end_time: z.string()});

export const earningRuleValidityHours = z.object({type: z.enum(["DAILY", "ANY_TIME"]), daily: z.array(loyaltyV2ActivityEarningRuleValidityDailyHours).nullable().optional()});

export const loyaltyV2ActivityEarningRuleTriggerLimitsCooldownFixedCooldownPeriod = z.object({value: z.number().int().gte(1), unit: z.enum(["HOUR", "DAY", "WEEK", "MONTH", "YEAR"])});

export const earningRuleTriggerLimitsCooldownFixedCooldown = z.object({period: loyaltyV2ActivityEarningRuleTriggerLimitsCooldownFixedCooldownPeriod});

export const loyaltyV2ActivityEarningRuleTriggerLimitsFrequencyLimitTimeBasedCurrentPeriod = z.object({unit: z.enum(["DAY", "WEEK", "MONTH", "QUARTER", "YEAR"])});

export const earningRuleTriggerLimitsFrequencyLimitTimeBasedPeriod = z.object({type: z.literal("CURRENT_PERIOD"), current_period: loyaltyV2ActivityEarningRuleTriggerLimitsFrequencyLimitTimeBasedCurrentPeriod.nullable().optional()});

export const loyaltyV2ActivityEarningRuleTriggerLimitsFrequencyLimitTimeBasedTriggers = z.object({max: z.number().int().gte(1)});

export const earningRuleTriggerLimitsFrequencyLimit = z.object({type: z.literal("TIME_BASED"), period: earningRuleTriggerLimitsFrequencyLimitTimeBasedPeriod, triggers: loyaltyV2ActivityEarningRuleTriggerLimitsFrequencyLimitTimeBasedTriggers});

export const loyaltyV2ActivityEarningRuleEarningLimitsGlobalTimeBasedCurrentPeriod = z.object({unit: z.enum(["DAY", "WEEK", "MONTH", "QUARTER", "YEAR"])});

export const loyaltyV2ActivityEarningRuleEarningLimitsGlobalTimeBasedPeriod = z.object({type: z.literal("CURRENT_PERIOD"), current_period: loyaltyV2ActivityEarningRuleEarningLimitsGlobalTimeBasedCurrentPeriod.nullable().optional()});

export const loyaltyV2ActivityEarningRuleEarningLimitsGlobalTimeBasedPoints = z.object({max: z.number().int().gte(1)});

export const loyaltyV2ActivityEarningRuleEarningLimitsGlobalLimit = z.object({type: z.literal("TIME_BASED"), period: loyaltyV2ActivityEarningRuleEarningLimitsGlobalTimeBasedPeriod, points: loyaltyV2ActivityEarningRuleEarningLimitsGlobalTimeBasedPoints});

export const loyaltyV2ActivityEarningRuleEarningLimitsGlobal = z.object({type: z.enum(["NO_LIMIT", "LIMITED"]), limits: z.array(loyaltyV2ActivityEarningRuleEarningLimitsGlobalLimit).optional()});

export const loyaltyV2ActivityEarningRuleEarningLimits = z.object({global: loyaltyV2ActivityEarningRuleEarningLimitsGlobal});

export const loyaltyV2ActivityMetadata = z.record(z.string(), z.unknown());

export const v2LoyaltiesEarningRulesActivateResponseBody = z.object({id: z.string(), name: z.string().max(200), status: z.enum(["DRAFT", "ACTIVE", "INACTIVE"]), earnings: z.array(earningRuleEarning), trigger: earningRuleTrigger, error: loyaltyV2ActivityEarningRuleError.optional(), validity_hours: earningRuleValidityHours, start_date: z.string().nullable(), end_date: z.string().nullable(), trigger_limits: z.object({cooldown: z.object({type: z.enum(["NO_COOLDOWN", "FIXED_COOLDOWN"]), fixed_cooldown: earningRuleTriggerLimitsCooldownFixedCooldown.nullable().optional()}).nullable(), frequency: z.object({type: z.enum(["NO_LIMIT", "LIMITED"]), limits: z.array(earningRuleTriggerLimitsFrequencyLimit).nullable().optional()}).nullable()}), earning_limits: loyaltyV2ActivityEarningRuleEarningLimits, metadata: loyaltyV2ActivityMetadata, created_at: z.string(), updated_at: z.string().nullable(), object: z.literal("earning_rule")});

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
};

/**
 * Activate earning rule
 * 
 * POST /v2/loyalties/earning-rules/{earningRuleId}/activate
 * 
 * Also accepts auth: bearerAuth
 */
export const createApiV2LoyaltiesEarningRulesEarningRuleIdActivate = async (options?: CreateApiV2LoyaltiesEarningRulesEarningRuleIdActivateOptions) => {
const {baseUrl = "https://api.voucherify.io", fetch: fetchFn = fetch, XAppId, XAppToken} = options ?? {}

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

if (XAppId !== undefined) headers.set("X-App-Id", XAppId)
if (XAppToken !== undefined) headers.set("X-App-Token", XAppToken)

const url = `${baseUrl.replace(/\/+$/, '')}/v2/loyalties/earning-rules/${encodeURIComponent(String(args.earningRuleId))}/activate${query.size > 0 ? `?${query}` : ''}`

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

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

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