import {z} from 'zod'

export type GetApiV0PlatformCosignersIdPoliciesArgs = {id: string};

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

export const action = z.enum(["approve", "reject"]);

export const inclutionOperator = z.enum(["in", "not_in"]);

export const assetIDTarget = z.object({type: z.literal("asset_id"), identifier: z.string()});

export const assetTagTarget = z.object({type: z.literal("asset_tag"), identifier: z.string()});

export const assetLabelTarget = z.object({type: z.literal("asset_label"), identifier: z.string()});

export const unknownTarget = z.object({type: z.string().optional()}).and(z.record(z.string(), z.unknown()));

export const calledAddressesRule = z.object({operator: inclutionOperator, value: z.array(z.union([assetIDTarget, assetTagTarget, assetLabelTarget, unknownTarget]))});

export const calledAddressRulesOutput = z.object({called_addresses: calledAddressesRule});

export const calledAddressPolicyResponse = z.object({type: z.literal("called_address"), rules: calledAddressRulesOutput});

export const equalityOperator = z.enum(["eq", "ne"]);

export const eip712PrimaryTypeRule = z.object({operator: z.union([inclutionOperator, equalityOperator]), value: z.union([z.array(z.string()), z.string()])});

export const eip712VerifyingContractsRule = z.object({operator: z.union([inclutionOperator, equalityOperator]), value: z.union([z.array(z.string()), z.string()])});

export const eip712SignatureRulesOutput = z.object({primary_type: eip712PrimaryTypeRule, verifying_contracts: eip712VerifyingContractsRule.nullable().optional()});

export const eip712SignaturePolicyResponse = z.object({rules: eip712SignatureRulesOutput, type: z.literal("eip_712_signature")});

export const eventName = z.object({operator: equalityOperator, value: z.string()});

export const lessThanComparisonOperator = z.enum(["lt", "lte"]);

export const greaterThanComparisonOperator = z.enum(["gt", "gte"]);

export const eventParameter = z.object({operator: z.union([equalityOperator, lessThanComparisonOperator, greaterThanComparisonOperator]), value: z.string(), parameter: z.string()});

export const eventEmittedRulesOutput = z.object({event_name: eventName, event_parameters: z.array(eventParameter).nullable().optional()});

export const missingAssetIDTarget = z.object({type: z.literal("asset_id"), identifier: z.string(), chain: z.string(), runtime: z.string()});

export const eventEmittedPolicyResponse = z.object({type: z.literal("event_emitted"), rules: eventEmittedRulesOutput, target: z.array(z.union([assetIDTarget, missingAssetIDTarget, unknownTarget]))});

export const functionName = z.object({operator: equalityOperator, value: z.string()});

export const functionParameter = z.object({operator: z.union([equalityOperator, lessThanComparisonOperator, greaterThanComparisonOperator]), value: z.string(), parameter: z.string()});

export const functionCallRulesOutput = z.object({function_name: functionName, function_parameters: z.array(functionParameter).nullable().optional()});

export const functionCallPolicyResponse = z.object({type: z.literal("function_call"), rules: functionCallRulesOutput, target: z.array(z.union([assetIDTarget, missingAssetIDTarget, unknownTarget]))});

export const approvedGainingAddresses = z.object({operator: inclutionOperator, value: z.array(z.union([assetIDTarget, assetTagTarget, assetLabelTarget, unknownTarget]))});

export const transactionFilterValue = z.enum(["all_actions", "transfers", "approvals"]);

export const transactionFilter = z.object({operator: z.literal("is"), value: transactionFilterValue});

export const ignoreThresholdRule = z.object({operator: lessThanComparisonOperator, value: z.number().int()});

export const nonApprovedGainingPercentage = z.object({operator: lessThanComparisonOperator, value: z.number()});

export const gainingAddressesRulesOutput = z.object({approved_gaining_addresses: approvedGainingAddresses, transaction_filter: transactionFilter, ignore_threshold: ignoreThresholdRule.nullable().optional(), non_approved_gaining_percentage: nonApprovedGainingPercentage.nullable().optional()});

export const gainingAddressesPolicyResponse = z.object({type: z.literal("gaining_addresses"), rules: gainingAddressesRulesOutput});

export const merklCampaignAction = z.enum(["supply_to_vault", "supply_to_specific_market", "supply_token_to_any_market", "borrow_from_specific_market", "borrow_token_from_any_market", "use_token_as_collateral_on_specific_market"]);

export const merklCampaignItem = z.object({action: merklCampaignAction, amount: z.number().gt(0), chain: z.string(), end_time_utc: z.string(), market_token_vault: z.string(), reward_token_address: z.string(), start_time_utc: z.string()});

export const merklCampaignRulesOutput = z.object({campaigns: z.array(merklCampaignItem)});

export const merklCampaignPolicyResponse = z.object({rules: merklCampaignRulesOutput, type: z.literal("merkl_campaign")});

export const movedAssetsDirectionValue = z.literal("outbound_only");

export const movedAssetsDirection = z.object({operator: z.literal("is"), value: movedAssetsDirectionValue});

export const movedAssetsRule = z.object({operator: inclutionOperator, value: z.array(z.union([assetIDTarget, assetTagTarget, assetLabelTarget, unknownTarget]))});

export const movedAssetsRulesOutput = z.object({direction: movedAssetsDirection.optional(), moved_assets: movedAssetsRule});

export const movedAssetsPolicyResponse = z.object({rules: movedAssetsRulesOutput, type: z.literal("moved_assets")});

export const riskCategory = z.enum(["sanctioned_entity", "stolen_funds", "scam_investment_fraud", "mixer", "darknet_market", "darknet_service", "child_abuse_material", "terrorism_financing", "ransomware", "enforcement_action", "government_seized_assets", "illegal_service", "high_risk_unlicensed_exchange", "gambling_service", "centralized_exchange_regulated", "crypto_atm", "p2p_exchange_regulated", "p2p_exchange_high_risk_unregulated", "defi_liquidity_pool_dex_pool", "mining_pool_miner", "online_marketplace", "custodial_wallet_service", "payment_processor", "uncategorised_service", "uncategorized_entity"]);

export const thresholdPercentage = z.object({operator: z.union([lessThanComparisonOperator, greaterThanComparisonOperator]), value: z.number().int().gte(0).lte(100)});

export const proximity = z.enum(["overall", "ownership", "counterparty", "indirect"]);

export const categoryThresholdOutput = z.object({category: riskCategory, threshold_percentage: thresholdPercentage, proximity: proximity.optional()});

export const riskExposureRulesOutput = z.object({category_thresholds: z.array(categoryThresholdOutput), proximity: proximity.optional()});

export const riskExposurePolicyResponse = z.object({rules: riskExposureRulesOutput, type: z.literal("risk_exposure")});

export const maxUsdValueRule = z.object({operator: z.enum(["lte", "gte"]), value: z.union([z.number().int(), z.number()])});

export const timeWindowScale = z.enum(["minutes", "hours", "days"]);

export const timeWindowRule = z.object({scale: timeWindowScale, value: z.number().int().gte(1)});

export const rollingUsdLimitRulesOutput = z.object({max_usd_value: maxUsdValueRule, time_window: timeWindowRule});

export const rollingUsdLimitPolicyResponse = z.object({rules: rollingUsdLimitRulesOutput, type: z.literal("rolling_usd_limit")});

export const safeConfigAction = z.enum(["THRESHOLD_CHANGE", "OWNERSHIP_CHANGE", "MODULE_ENABLED_DISABLED", "GUARD_CHANGED"]);

export const safeConfigActionRule = z.object({operator: inclutionOperator, value: z.array(safeConfigAction)});

export const safeConfigTransactionRulesOutput = z.object({config_action: safeConfigActionRule});

export const safeConfigTransactionPolicyResponse = z.object({rules: safeConfigTransactionRulesOutput, type: z.literal("safe_config_transaction")});

export const tokenSpendApprovalAmountRule = z.object({operator: z.union([lessThanComparisonOperator, greaterThanComparisonOperator, equalityOperator]), value: z.string()});

export const tokenSpendApprovalUsdValueRule = z.object({operator: z.union([lessThanComparisonOperator, greaterThanComparisonOperator, equalityOperator]), value: z.string()});

export const tokenSpendApprovalRulesOutput = z.object({approval_amount: tokenSpendApprovalAmountRule.nullable().optional(), approval_usd_value: tokenSpendApprovalUsdValueRule});

export const tokenSpendApprovalPolicyResponse = z.object({rules: tokenSpendApprovalRulesOutput, type: z.literal("token_spend_approval")});

export const transactionUSDValueRule = z.object({operator: z.union([lessThanComparisonOperator, greaterThanComparisonOperator, equalityOperator]), value: z.string()});

export const transactionUSDValueRulesOutput = z.object({transaction_usd_value: transactionUSDValueRule});

export const transactionUSDValuePolicyResponse = z.object({type: z.literal("transaction_usd_value"), rules: transactionUSDValueRulesOutput});

export const baseCompositePolicyResponse = z.object({type: z.literal("composite").optional(), operator: z.enum(["and", "or"]), rules: z.array(z.unknown())});

export const unknownPolicyResponse = z.object({type: z.string(), rules: z.object({}).nullable().optional(), target: z.object({}).nullable().optional()}).and(z.record(z.string(), z.unknown()));

export const eVMPolicyResponse = z.object({name: z.string(), action: action, policy: z.union([calledAddressPolicyResponse, eip712SignaturePolicyResponse, eventEmittedPolicyResponse, functionCallPolicyResponse, gainingAddressesPolicyResponse, merklCampaignPolicyResponse, movedAssetsPolicyResponse, riskExposurePolicyResponse, rollingUsdLimitPolicyResponse, safeConfigTransactionPolicyResponse, tokenSpendApprovalPolicyResponse, transactionUSDValuePolicyResponse, baseCompositePolicyResponse, unknownPolicyResponse])});

export const squadsConfigAction = z.enum(["changeThreshold", "addMember", "removeMember", "changeTimelock"]);

export const configActionRule = z.object({operator: inclutionOperator, value: z.array(squadsConfigAction)});

export const squadsConfigTransactionRulesOutput = z.object({squads_config_action: configActionRule});

export const squadsConfigTransactionPolicyResponse = z.object({rules: squadsConfigTransactionRulesOutput, type: z.literal("squads_config_transaction")});

export const solanaPolicyResponse = z.object({name: z.string(), action: action, policy: z.union([functionCallPolicyResponse, gainingAddressesPolicyResponse, squadsConfigTransactionPolicyResponse, transactionUSDValuePolicyResponse, rollingUsdLimitPolicyResponse, baseCompositePolicyResponse, unknownPolicyResponse])});

export const bitcoinPolicyResponse = z.object({name: z.string(), action: action, policy: z.union([gainingAddressesPolicyResponse, transactionUSDValuePolicyResponse, baseCompositePolicyResponse, unknownPolicyResponse])});

export const suiPolicyResponse = z.object({name: z.string(), action: action, policy: z.union([gainingAddressesPolicyResponse, transactionUSDValuePolicyResponse, rollingUsdLimitPolicyResponse, baseCompositePolicyResponse, unknownPolicyResponse])});

export const unsupportedChainPolicyResponse = z.object({type: z.literal("unsupported_chain")});

export const otherChainPolicyResponse = z.object({name: z.string(), action: action, policy: unsupportedChainPolicyResponse});

export const policiesResponse = z.object({evm: z.array(eVMPolicyResponse).nullable().optional(), solana: z.array(solanaPolicyResponse).nullable().optional(), bitcoin: z.array(bitcoinPolicyResponse).nullable().optional(), sui: z.array(suiPolicyResponse).nullable().optional(), other: z.array(otherChainPolicyResponse).nullable().optional()});

export const getPoliciesResponse = z.object({policies: policiesResponse});

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 Cosigner Policies Route
 * 
 * GET /v0/platform/cosigners/{id}/policies/
 */
export const getApiV0PlatformCosignersIdPolicies = async (args: GetApiV0PlatformCosignersIdPoliciesArgs, options?: GetApiV0PlatformCosignersIdPoliciesOptions) => {
const {baseUrl = "https://api.blockaid.io", fetch: fetchFn = fetch} = options ?? {}

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

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