import {z} from 'zod'

export type ApiDispatchNoneThresholds = {count?: number | undefined, window_seconds?: number | undefined};

export type ApiFiringOftenThresholds = {transitions?: number | undefined, window_seconds?: number | undefined};

export type ApiSilencedLongThresholds = {count?: number | undefined, window_seconds?: number | undefined};

export type ApiStuckRaisedThresholds = {duration_seconds?: number | undefined};

export type ApiMisconfiguredAlertsThresholds = {dispatch_none?: ApiDispatchNoneThresholds | undefined, firing_often?: ApiFiringOftenThresholds | undefined, silenced_long?: ApiSilencedLongThresholds | undefined, stuck_raised?: ApiStuckRaisedThresholds | undefined};

export type ApiMisconfiguredAlertsRequest = {categories?: (Array<'firing_often' | 'stuck_raised' | 'silenced_long' | 'dispatch_none'>) | undefined, thresholds?: ApiMisconfiguredAlertsThresholds | undefined};

export type CreateApiApiV2SpacesSpaceIDRoomsRoomIDAlertsMisconfiguredArgs = {spaceID: string, roomID: string, body: ApiMisconfiguredAlertsRequest};

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

export const apiDispatchNoneAlert = z.object({chart: z.string().optional(), context: z.string().optional(), name: z.string().optional()});

export const apiMisconfiguredNode = z.object({id: z.string().optional(), name: z.string().optional()});

export const apiDispatchNoneItem = z.object({alert: apiDispatchNoneAlert.optional(), count: z.number().int().optional(), first: z.number().int().optional(), last: z.number().int().optional(), node: apiMisconfiguredNode.optional()});

export const apiDispatchNoneTotals = z.object({count: z.number().int().optional(), items: z.number().int().optional()});

export const apiDispatchNoneResponse = z.object({items: z.array(apiDispatchNoneItem).optional(), totals: apiDispatchNoneTotals.optional()});

export const apiFiringOftenAlert = z.object({chart: z.string().optional(), context: z.string().optional(), name: z.string().optional()});

export const apiFiringOftenItem = z.object({alert: apiFiringOftenAlert.optional(), node: apiMisconfiguredNode.optional(), transitions: z.number().int().optional()});

export const apiFiringOftenTotals = z.object({items: z.number().int().optional(), transitions: z.number().int().optional()});

export const apiFiringOftenResponse = z.object({items: z.array(apiFiringOftenItem).optional(), totals: apiFiringOftenTotals.optional()});

export const apiSilencedLongAlert = z.object({chart: z.string().optional(), context: z.string().optional(), name: z.string().optional()});

export const apiSilencedLongItem = z.object({alert: apiSilencedLongAlert.optional(), count: z.number().int().optional(), first_silenced: z.number().int().optional(), last_silenced: z.number().int().optional(), node: apiMisconfiguredNode.optional()});

export const apiSilencedLongTotals = z.object({count: z.number().int().optional(), items: z.number().int().optional()});

export const apiSilencedLongResponse = z.object({items: z.array(apiSilencedLongItem).optional(), totals: apiSilencedLongTotals.optional()});

export const apiStuckRaisedAlert = z.object({chart: z.string().optional(), context: z.string().optional(), duration_seconds: z.number().int().optional(), name: z.string().optional(), status: z.enum(["critical", "warning"]).optional(), triggered_at: z.number().int().optional(), units: z.string().optional(), value: z.number().optional()});

export const apiStuckRaisedItem = z.object({alert: apiStuckRaisedAlert.optional(), node: apiMisconfiguredNode.optional()});

export const apiStuckRaisedStatusTotal = z.object({duration_seconds: z.number().int().optional(), items: z.number().int().optional()});

export const apiStuckRaisedTotals = z.object({critical: apiStuckRaisedStatusTotal.optional(), duration_seconds: z.number().int().optional(), items: z.number().int().optional(), warning: apiStuckRaisedStatusTotal.optional()});

export const apiStuckRaisedResponse = z.object({items: z.array(apiStuckRaisedItem).optional(), totals: apiStuckRaisedTotals.optional()});

export const apiDispatchNoneThresholds = z.object({count: z.number().int().optional(), window_seconds: z.number().int().optional()});

export const apiFiringOftenThresholds = z.object({transitions: z.number().int().optional(), window_seconds: z.number().int().optional()});

export const apiSilencedLongThresholds = z.object({count: z.number().int().optional(), window_seconds: z.number().int().optional()});

export const apiStuckRaisedThresholds = z.object({duration_seconds: z.number().int().optional()});

export const apiMisconfiguredAlertsThresholds = z.object({dispatch_none: apiDispatchNoneThresholds.optional(), firing_often: apiFiringOftenThresholds.optional(), silenced_long: apiSilencedLongThresholds.optional(), stuck_raised: apiStuckRaisedThresholds.optional()});

export const apiMisconfiguredAlertsResponse = z.object({dispatch_none: apiDispatchNoneResponse.optional(), firing_often: apiFiringOftenResponse.optional(), silenced_long: apiSilencedLongResponse.optional(), stuck_raised: apiStuckRaisedResponse.optional(), thresholds: apiMisconfiguredAlertsThresholds.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
};

/**
 * Get misconfigured alerts for a room
 * 
 * POST /api/v2/spaces/{spaceID}/rooms/{roomID}/alerts:misconfigured
 */
export const createApiApiV2SpacesSpaceIDRoomsRoomIDAlertsMisconfigured = async (args: CreateApiApiV2SpacesSpaceIDRoomsRoomIDAlertsMisconfiguredArgs, options: CreateApiApiV2SpacesSpaceIDRoomsRoomIDAlertsMisconfiguredOptions) => {
const {baseUrl, fetch: fetchFn = fetch, Bearer} = options ?? {}

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

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

const url = `${baseUrl.replace(/\/+$/, '')}/api/v2/spaces/${encodeURIComponent(String(args.spaceID))}/rooms/${encodeURIComponent(String(args.roomID))}/alerts:misconfigured${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(apiMisconfiguredAlertsResponse, await res.json())
};