import {z} from 'zod'

export type CreateApiV1OrgsOrgIdIntegrationsSlackCallbackArgs = {orgId: string, Authorization?: string | undefined, body: {code: string, state: string}};

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

export const createApiV1OrgsOrgIdIntegrationsSlackCallbackResponse = z.object({links: z.object({self: z.string()}), data: z.object({id: z.string(), type: z.literal("integration"), attributes: z.object({type: z.literal("slack-app"), installedBy: z.string(), connectionData: z.object({slackTeamId: z.string(), slackAppId: z.string(), botUserId: z.string()}), metadata: z.object({slackTeamName: z.string().optional()}), createdAt: z.string(), updatedAt: z.string()})})});

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

/**
 * Completes connecting a Slack workspace to the organization with the `code` and `state` Slack sent to the redirect URI, and returns the connection. Returns 400 when the state was not issued to the caller for this organization or has expired, or when Slack refuses the code. Connecting a Slack workspace the organization already holds for the same app replaces the earlier connection. Returns 503 when this instance cannot connect Slack workspaces.
 * 
 * POST /v1/orgs/{orgId}/integrations/slack/callback
 */
export const createApiV1OrgsOrgIdIntegrationsSlackCallback = async (args: CreateApiV1OrgsOrgIdIntegrationsSlackCallbackArgs, options?: CreateApiV1OrgsOrgIdIntegrationsSlackCallbackOptions) => {
const {baseUrl = "https://api.tessl.io", fetch: fetchFn = fetch} = options ?? {}

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

if (args.Authorization != null) headers.set("Authorization", String(args.Authorization))

const url = `${baseUrl.replace(/\/+$/, '')}/v1/orgs/${encodeURIComponent(String(args.orgId))}/integrations/slack/callback${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(createApiV1OrgsOrgIdIntegrationsSlackCallbackResponse, await res.json())
};