import {
  AXIOM_ALERT_HISTORY_SCHEMA,
  AXIOM_EMPTY_SCHEMA,
  AXIOM_ID_SCHEMA,
  AXIOM_MONITOR_SCHEMA,
  AXIOM_MONITOR_WITH_ID_SCHEMA,
} from "@automate.ax/integration-contracts/axiom"
import * as z from "zod"
import { defineAction } from "../../../automation/actions"
import {
  AXIOM_ACCOUNT,
  AXIOM_API_TOKEN_ACCOUNT,
  axiomPath,
  getAxiomApi,
} from "../lib"

const MONITOR_ID = { monitorId: AXIOM_ID_SCHEMA }
const MONITOR_HISTORY_TIME_SCHEMA = z.iso.datetime({ offset: true })

export const listAxiomMonitors = defineAction("List Axiom monitors")
  .describe("Lists monitors visible to the connected token.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(z.object({}))
  .output(AXIOM_MONITOR_WITH_ID_SCHEMA.array())
  .retry({ replaySafety: "safe" })
  .handler(({ account }) =>
    getAxiomApi(account).request("monitors", {
      responseSchema: AXIOM_MONITOR_WITH_ID_SCHEMA.array(),
    }),
  )

export const createAxiomMonitor = defineAction("Create Axiom monitor")
  .describe("Creates a threshold, match-event, or anomaly monitor.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(AXIOM_MONITOR_SCHEMA)
  .output(AXIOM_MONITOR_WITH_ID_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(({ account, input }) =>
    getAxiomApi(account).request("monitors", {
      body: input,
      method: "POST",
      responseSchema: AXIOM_MONITOR_WITH_ID_SCHEMA,
    }),
  )

export const getAxiomMonitor = defineAction("Get Axiom monitor")
  .describe("Retrieves one Axiom monitor by ID.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(z.object(MONITOR_ID))
  .output(AXIOM_MONITOR_WITH_ID_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(({ account, input }) =>
    getAxiomApi(account).request(`monitors/${axiomPath(input.monitorId)}`, {
      responseSchema: AXIOM_MONITOR_WITH_ID_SCHEMA,
    }),
  )

export const updateAxiomMonitor = defineAction("Update Axiom monitor")
  .describe("Replaces one Axiom monitor's complete configuration.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(AXIOM_MONITOR_SCHEMA.and(z.object(MONITOR_ID)))
  .output(AXIOM_MONITOR_WITH_ID_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(({ account, input: { monitorId, ...body } }) =>
    getAxiomApi(account).request(`monitors/${axiomPath(monitorId)}`, {
      body,
      method: "PUT",
      responseSchema: AXIOM_MONITOR_WITH_ID_SCHEMA,
    }),
  )

export const deleteAxiomMonitor = defineAction("Delete Axiom monitor")
  .describe("Deletes one Axiom monitor.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(z.object(MONITOR_ID))
  .output(AXIOM_EMPTY_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(({ account, input }) =>
    getAxiomApi(account).request(`monitors/${axiomPath(input.monitorId)}`, {
      method: "DELETE",
      responseSchema: AXIOM_EMPTY_SCHEMA,
    }),
  )

export const listAxiomMonitorHistory = defineAction(
  "List Axiom monitor history",
)
  .describe("Lists open and closed alert history for one monitor.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(
    z.object({
      ...MONITOR_ID,
      endTime: MONITOR_HISTORY_TIME_SCHEMA.optional(),
      startTime: MONITOR_HISTORY_TIME_SCHEMA.optional(),
    }),
  )
  .output(AXIOM_ALERT_HISTORY_SCHEMA.array())
  .retry({ replaySafety: "safe" })
  .handler(({ account, input }) => {
    const now = new Date()
    return getAxiomApi(account).request(
      `monitors/${axiomPath(input.monitorId)}/history`,
      {
        query: {
          endTime: input.endTime ?? now.toISOString(),
          startTime:
            input.startTime ??
            new Date(now.getTime() - 30 * 60 * 1_000).toISOString(),
        },
        responseSchema: AXIOM_ALERT_HISTORY_SCHEMA.array(),
      },
    )
  })