import {z} from 'zod'

export type AggregationPreference = {taxId: string} | {npi: string};

export type EnrolledPayerInput = {id?: string | undefined, idOrAlias?: string | undefined};

export type CountryCode = 'US' | 'CA';

export type UsState = 'AA' | 'AE' | 'AK' | 'AL' | 'AP' | 'AR' | 'AS' | 'AZ' | 'CA' | 'CO' | 'CT' | 'DC' | 'DE' | 'FL' | 'FM' | 'GA' | 'GU' | 'HI' | 'IA' | 'ID' | 'IL' | 'IN' | 'KS' | 'KY' | 'LA' | 'MA' | 'MD' | 'ME' | 'MH' | 'MI' | 'MN' | 'MO' | 'MP' | 'MS' | 'MT' | 'NC' | 'ND' | 'NE' | 'NH' | 'NJ' | 'NM' | 'NV' | 'NY' | 'OH' | 'OK' | 'OR' | 'PA' | 'PR' | 'PW' | 'RI' | 'SC' | 'SD' | 'TN' | 'TX' | 'UT' | 'VT' | 'VA' | 'VI' | 'WA' | 'WV' | 'WI' | 'WY' | 'AB' | 'BC' | 'MB' | 'NB' | 'NL' | 'NS' | 'NT' | 'NU' | 'ON' | 'PE' | 'QC' | 'SK' | 'YT';

export type ProviderContact = {city: string, country?: CountryCode | undefined, email: string, firstName?: string | undefined, lastName?: string | undefined, organizationName?: string | undefined, phone: string, state: UsState, streetAddress1: string, streetAddress2?: string | undefined, zipCode: string};

export type EnrolledProviderInput = {id: string};

export type EnrollmentSource = 'API' | 'UI' | 'IMPORT' | 'AUTO_ENROLLMENT' | 'AUTOMATED_TASK';

export type EnrollmentStatus = 'DRAFT' | 'SUBMITTED' | 'PROVISIONING' | 'LIVE' | 'REJECTED' | 'CANCELED' | 'STEDI_ACTION_REQUIRED' | 'PROVIDER_ACTION_REQUIRED';

export type EnrolledTransaction = {enroll: boolean};

export type EnrolledTransactionsList = {eligibilityCheck: EnrolledTransaction} | {claimStatus: EnrolledTransaction} | {professionalClaimSubmission: EnrolledTransaction} | {institutionalClaimSubmission: EnrolledTransaction} | {dentalClaimSubmission: EnrolledTransaction} | {claimPayment: EnrolledTransaction} | {solicitedClaimAttachment: EnrolledTransaction} | {unsolicitedClaimAttachment: EnrolledTransaction};

export type UpdateEnrollmentRequestContent = {aggregationPreference?: AggregationPreference | undefined, payer: EnrolledPayerInput, primaryContact: ProviderContact, provider: EnrolledProviderInput, providerTransactionAccessNumber?: string | undefined, reason?: string | undefined, requestedEffectiveDate?: string | undefined, source?: EnrollmentSource | undefined, status?: EnrollmentStatus | undefined, transactions: EnrolledTransactionsList, userEmail: string};

export type CreateApiEnrollmentsEnrollmentIdArgs = {enrollmentId: string, body: UpdateEnrollmentRequestContent};

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

export const aggregationPreference = z.union([z.object({taxId: z.string()}), z.object({npi: z.string()})]);

export const documentStatus = z.enum(["PENDING", "UPLOADED", "FAILED", "DELETED"]);

export const enrollmentDocument = z.object({contentType: z.string().optional(), createdAt: z.string(), enrollmentId: z.string(), id: z.string(), name: z.string(), size: z.number().optional(), status: documentStatus, taskId: z.string().optional(), updatedAt: z.string()});

export const enrollmentStatus = z.enum(["DRAFT", "SUBMITTED", "PROVISIONING", "LIVE", "REJECTED", "CANCELED", "STEDI_ACTION_REQUIRED", "PROVIDER_ACTION_REQUIRED"]);

export const enrollmentHistoryChangeType = z.literal("STATUS_CHANGE");

export const enrollmentHistoryEntry = z.object({changedAt: z.string(), changedBy: z.string(), newStatus: enrollmentStatus, previousStatus: enrollmentStatus.optional(), type: enrollmentHistoryChangeType});

export const enrolledPayerOutput = z.object({name: z.string().optional(), stediPayerId: z.string(), submittedPayerIdOrAlias: z.string().optional()});

export const countryCode = z.enum(["US", "CA"]);

export const usState = z.enum(["AA", "AE", "AK", "AL", "AP", "AR", "AS", "AZ", "CA", "CO", "CT", "DC", "DE", "FL", "FM", "GA", "GU", "HI", "IA", "ID", "IL", "IN", "KS", "KY", "LA", "MA", "MD", "ME", "MH", "MI", "MN", "MO", "MP", "MS", "MT", "NC", "ND", "NE", "NH", "NJ", "NM", "NV", "NY", "OH", "OK", "OR", "PA", "PR", "PW", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "VI", "WA", "WV", "WI", "WY", "AB", "BC", "MB", "NB", "NL", "NS", "NT", "NU", "ON", "PE", "QC", "SK", "YT"]);

export const providerContact = z.object({city: z.string().min(2), country: countryCode.optional(), email: z.string().min(5), firstName: z.string().optional(), lastName: z.string().optional(), organizationName: z.string().optional(), phone: z.string(), state: usState, streetAddress1: z.string().min(1), streetAddress2: z.string().optional(), zipCode: z.string().min(5)});

export const allEnrolledProviderFields = z.object({id: z.string(), name: z.string(), npi: z.string(), taxId: z.string(), taxIdType: z.string()});

export const enrollmentSource = z.enum(["API", "UI", "IMPORT", "AUTO_ENROLLMENT", "AUTOMATED_TASK"]);

export const fieldType = z.enum(["TEXT", "DOCUMENT"]);

export const manualTaskField = z.object({description: z.string().optional(), fieldType: fieldType, key: z.string().min(1), label: z.string().min(1)});

export const taskLink = z.object({label: z.string().min(1), url: z.string().min(1)});

export const manualTask = z.object({fields: z.array(manualTaskField), instructions: z.string().min(1), links: z.array(taskLink).optional()});

export const taskDefinition = z.object({manualTask: manualTask});

export const manualTaskDocumentResponseValue = z.object({documentId: z.string()});

export const manualTaskResponseValue = z.union([z.object({text: z.string().min(1).max(5000)}), z.object({document: manualTaskDocumentResponseValue})]);

export const manualTaskResponseKeyValue = z.object({key: z.string().min(1), value: manualTaskResponseValue});

export const manualTaskResponse = z.object({values: z.array(manualTaskResponseKeyValue)});

export const taskResponseData = z.object({manualTask: manualTaskResponse});

export const responsibleParty = z.enum(["PROVIDER", "STEDI"]);

export const task = z.object({completedAt: z.string().optional(), definition: taskDefinition, id: z.string(), isComplete: z.boolean(), rank: z.number().gte(0), responseData: taskResponseData.optional(), responsibleParty: responsibleParty});

export const enrolledTransaction = z.object({enroll: z.boolean()});

export const enrolledTransactionsList = z.union([z.object({eligibilityCheck: enrolledTransaction}), z.object({claimStatus: enrolledTransaction}), z.object({professionalClaimSubmission: enrolledTransaction}), z.object({institutionalClaimSubmission: enrolledTransaction}), z.object({dentalClaimSubmission: enrolledTransaction}), z.object({claimPayment: enrolledTransaction}), z.object({solicitedClaimAttachment: enrolledTransaction}), z.object({unsolicitedClaimAttachment: enrolledTransaction})]);

export const updateEnrollmentResponseContent = z.object({aggregationPreference: aggregationPreference.optional(), createdAt: z.string(), documents: z.array(enrollmentDocument).optional(), history: z.array(enrollmentHistoryEntry).optional(), id: z.string(), lastEraReceivedAt: z.string().optional(), payer: enrolledPayerOutput, primaryContact: providerContact, provider: allEnrolledProviderFields, providerTransactionAccessNumber: z.string().min(4).max(10).optional(), reason: z.string().optional(), requestedEffectiveDate: z.string().min(8).max(8).optional(), source: enrollmentSource.optional(), status: enrollmentStatus.optional(), statusLastUpdatedAt: z.string(), submittedAt: z.string().optional(), tasks: z.array(task).optional(), transactions: enrolledTransactionsList, updatedAt: z.string(), userEmail: z.string().min(5)});

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

/**
 * Updates an existing enrollment request. Only enrollments in DRAFT status can be updated. Once an enrollment is submitted, it cannot be modified.
 * 
 * POST /enrollments/{enrollmentId}
 */
export const createApiEnrollmentsEnrollmentId = async (args: CreateApiEnrollmentsEnrollmentIdArgs, options?: CreateApiEnrollmentsEnrollmentIdOptions) => {
const {baseUrl = "https://enrollments.us.stedi.com/2024-09-01", fetch: fetchFn = fetch, httpApiKeyAuth} = options ?? {}

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

if (httpApiKeyAuth !== undefined) headers.set("Authorization", httpApiKeyAuth)

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

const res = await fetchFn(url, {method: "POST", 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(updateEnrollmentResponseContent, await res.json())
};