import {z} from 'zod'

export type GetApiGroupPolicyIntentsGroupPolicyIntentIdArgs = {group_policy_intent_id: string};

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

export const groupQuoteIntentType = z.enum(["single", "multi_level"]);

export const groupPolicyIntentStatus = z.enum(["processing", "action_required", "pending_verification", "pending_provider_approval", "policy_created", "expired", "provider_rejected", "manual_renewal_gathering_required"]);

export const costSharingType = z.enum(["member_count", "member_selection", "member_selection_percentage_based", "percentage", "policyholder_only", "family_type", "fixed_amount", "full_coverage", "pooled_member_count"]);

export const memberCountCostSharingConfigurationResponse = z.object({adults: z.number().int(), children: z.number().int()});

export const memberSelectionCostSharingConfigurationResponse = z.object({partner: z.boolean(), children: z.boolean()});

export const memberSelectionPercentageBasedCostSharingConfigurationResponse = z.object({partner: z.boolean(), children: z.boolean(), percentage: z.number().int()});

export const percentageCostSharingConfigurationResponse = z.object({percentage: z.number().int()});

export const familyCostSharingType = z.enum(["single", "couple", "single_with_children", "family"]);

export const familyTypeCostSharingConfigurationResponse = z.object({type: familyCostSharingType});

export const fixedAmountCostSharingConfigurationResponse = z.object({monthly_amount: z.number()});

export const pooledMemberCountCostSharingConfigurationResponse = z.object({dependents: z.number().int()});

export const costSharingConfigurationResponse = z.object({type: costSharingType, member_count: memberCountCostSharingConfigurationResponse.optional(), member_selection: memberSelectionCostSharingConfigurationResponse.optional(), member_selection_percentage_based: memberSelectionPercentageBasedCostSharingConfigurationResponse.optional(), percentage: percentageCostSharingConfigurationResponse.optional(), family_type: familyTypeCostSharingConfigurationResponse.optional(), fixed_amount: fixedAmountCostSharingConfigurationResponse.optional(), pooled_member_count: pooledMemberCountCostSharingConfigurationResponse.optional()});

export const benefitType = z.enum(["health_insurance", "life_assurance"]);

export const selectedOptionResponse: z.ZodType<SelectedOptionResponse> = z.object({option_id: z.string(), sub_options: z.array(z.lazy(() => selectedOptionResponse)).nullable().optional()});

export const planCoverageOptionSelectionResponse = z.object({configuration_id: z.string(), options: z.array(selectedOptionResponse)});

export const groupQuoteIntentLevelResponse = z.object({group_id: z.string(), plan_id: z.string(), cost_sharing: costSharingConfigurationResponse.optional(), coverage_selections: z.array(planCoverageOptionSelectionResponse).nullable().optional()});

export const groupQuoteIntentItemResponse = z.object({benefit_type: benefitType, ref: z.string().nullable().optional(), levels: z.array(groupQuoteIntentLevelResponse)});

export const intentActionType = z.enum(["provide_dependant_information", "provide_beneficiary_information", "provide_missing_information"]);

export const groupPolicyIntentActionRequiredResponse = z.object({code: intentActionType, reason: z.string(), reason_description: z.string(), due_by: z.string()});

export const disclosureCategory = z.enum(["regulatory", "provider", "intermediary"]);

export const disclosureType = z.enum(["intermediary_role", "intermediary_commission", "underwriter_disclaimer", "anti_selection_notice", "statement_of_needs", "product_information", "pre_existing_conditions", "statutory_warning", "privacy_policy", "terms_of_business"]);

export const disclosureLinkResponse = z.object({token: z.string(), type: disclosureType, label: z.string(), url: z.string(), version: z.string()});

export const disclosureResponse = z.object({category: disclosureCategory, type: disclosureType, title: z.string(), text: z.string(), links: z.array(disclosureLinkResponse)});

export const groupPolicyIntentResponse = z.object({id: z.string(), type: groupQuoteIntentType.optional(), group_id: z.string().nullable(), plan_id: z.string().nullable(), quote_intent_id: z.string(), status: groupPolicyIntentStatus, due_date: z.string().nullable().optional(), cost_sharing: costSharingConfigurationResponse.optional(), items: z.array(groupQuoteIntentItemResponse), group_policy_ids: z.array(z.string()), action_required: groupPolicyIntentActionRequiredResponse.optional(), disclosures: z.array(disclosureResponse), object: 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
};

/**
 * Retrieve a group policy intent
 * 
 * GET /group_policy_intents/{group_policy_intent_id}
 */
export const getApiGroupPolicyIntentsGroupPolicyIntentId = async (args: GetApiGroupPolicyIntentsGroupPolicyIntentIdArgs, options?: GetApiGroupPolicyIntentsGroupPolicyIntentIdOptions) => {
const {baseUrl = "https://test.api.kota.io", fetch: fetchFn = fetch, bearerAuth} = options ?? {}

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

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

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