import {z} from 'zod'

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

export const branchState = z.string();

export const branchRestoreStatus = z.string();

export const branchRestrictedAction = z.object({name: z.string(), reason: z.string()});

export const branchRecoveryInfo = z.object({deleted_at: z.string(), recoverable_until: z.string(), deletion_method: z.enum(["user", "ttl"])});

export const branch = z.object({id: z.string(), project_id: z.string(), parent_id: z.string().optional(), parent_lsn: z.string().optional(), parent_timestamp: z.string().optional(), name: z.string(), current_state: branchState, pending_state: branchState.optional(), state_changed_at: z.string(), logical_size: z.number().int().optional(), creation_source: z.string(), primary: z.boolean().optional(), default: z.boolean(), protected: z.boolean(), cpu_used_sec: z.number().int(), compute_time_seconds: z.number().int(), active_time_seconds: z.number().int(), written_data_bytes: z.number().int(), data_transfer_bytes: z.number().int(), created_at: z.string(), updated_at: z.string(), ttl_interval_seconds: z.number().int().optional(), expires_at: z.string().optional(), last_reset_at: z.string().optional(), created_by: z.object({name: z.string().optional(), image: z.string().optional()}).optional(), init_source: z.string().optional(), restore_status: branchRestoreStatus.optional(), restored_from: z.string().optional(), restored_as: z.string().optional(), restricted_actions: z.array(branchRestrictedAction).optional(), recovery: branchRecoveryInfo.optional()});

export const computeUnit = z.number().gte(0.25);

export const endpointType = z.enum(["read_only", "read_write"]);

export const endpointState = z.enum(["init", "active", "idle"]);

export const pgSettingsData = z.record(z.string(), z.string());

export const pgbouncerSettingsData = z.record(z.string(), z.string());

export const preloadLibraries = z.object({use_defaults: z.boolean().optional(), enabled_libraries: z.array(z.string()).optional()});

export const endpointSettingsData = z.object({pg_settings: pgSettingsData.optional(), pgbouncer_settings: pgbouncerSettingsData.optional(), preload_libraries: preloadLibraries.optional()});

export const endpointPoolerMode = z.literal("transaction");

export const suspendTimeoutSeconds = z.number().int().gte(-1).lte(604800);

export const provisioner = z.string();

export const endpoint = z.object({host: z.string(), id: z.string(), name: z.string().optional(), project_id: z.string(), branch_id: z.string(), autoscaling_limit_min_cu: computeUnit, autoscaling_limit_max_cu: computeUnit, region_id: z.string(), type: endpointType, current_state: endpointState, pending_state: endpointState.optional(), settings: endpointSettingsData, pooler_enabled: z.boolean(), pooler_mode: endpointPoolerMode, disabled: z.boolean(), passwordless_access: z.boolean(), last_active: z.string().optional(), creation_source: z.string(), created_at: z.string(), updated_at: z.string(), started_at: z.string().optional(), suspended_at: z.string().optional(), proxy_host: z.string(), suspend_timeout_seconds: suspendTimeoutSeconds, provisioner: provisioner, compute_release_version: z.string().optional()});

export const branchRecoverResponse = z.object({branch: branch, endpoints: z.array(endpoint).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
};

/**
 * Recover a deleted branch
 * 
 * POST /projects/{project_id}/branches/{branch_id}/recover
 * 
 * Also accepts auth: CookieAuth, TokenCookieAuth
 */
export const createApiProjectsProjectIdBranchesBranchIdRecover = async (options?: CreateApiProjectsProjectIdBranchesBranchIdRecoverOptions) => {
const {baseUrl = "https://console.neon.tech/api/v2", 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(/\/+$/, '')}/projects/${encodeURIComponent(String(args.project_id))}/branches/${encodeURIComponent(String(args.branch_id))}/recover${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(branchRecoverResponse, await res.json())
};