import { encodableSchema } from "@automate.ax/codec"
import {
  AXIOM_DASHBOARD_DOCUMENT_SCHEMA,
  AXIOM_DASHBOARD_RESOURCE_SCHEMA,
  AXIOM_DASHBOARD_VERSION_SCHEMA,
  AXIOM_DASHBOARD_WRITE_SCHEMA,
  AXIOM_EMPTY_SCHEMA,
  AXIOM_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 DASHBOARD_UID = { dashboardUid: AXIOM_ID_SCHEMA }
const WRITE_OPTIONS = {
  message: z.string().optional(),
  overwrite: z.boolean().prefault(false),
  version: AXIOM_DASHBOARD_VERSION_SCHEMA.optional(),
}
const DASHBOARD_WRITE_INPUT_SCHEMA = z
  .object({
    ...DASHBOARD_UID,
    ...WRITE_OPTIONS,
    dashboard: AXIOM_DASHBOARD_DOCUMENT_SCHEMA,
  })
  .refine(({ overwrite, version }) => overwrite || version !== undefined, {
    message: "Provide version unless overwrite is true.",
  })
const DASHBOARD_CHART_PATCH_SCHEMA = z
  .record(z.string(), z.unknown())
  .transform((chart) =>
    z
      .object({ id: AXIOM_ID_SCHEMA.optional() })
      .catchall(encodableSchema)
      .parse(chart),
  )

export const listAxiomDashboards = defineAction("List Axiom dashboards")
  .describe("Lists dashboards visible to the connected token.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(
    z.object({
      limit: z.number().int().positive().optional(),
      offset: z.number().int().nonnegative().optional(),
    }),
  )
  .output(AXIOM_DASHBOARD_RESOURCE_SCHEMA.array())
  .retry({ replaySafety: "safe" })
  .handler(({ account, input }) =>
    getAxiomApi(account).request("dashboards", {
      query: input,
      responseSchema: AXIOM_DASHBOARD_RESOURCE_SCHEMA.array(),
    }),
  )

export const createAxiomDashboard = defineAction("Create Axiom dashboard")
  .describe("Creates a version 2 Axiom dashboard.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(
    z.object({
      dashboard: AXIOM_DASHBOARD_DOCUMENT_SCHEMA,
      message: z.string().optional(),
      uid: AXIOM_ID_SCHEMA.optional(),
    }),
  )
  .output(AXIOM_DASHBOARD_WRITE_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(({ account, input }) =>
    getAxiomApi(account).request("dashboards", {
      body: input,
      method: "POST",
      responseSchema: AXIOM_DASHBOARD_WRITE_SCHEMA,
    }),
  )

export const getAxiomDashboard = defineAction("Get Axiom dashboard")
  .describe("Retrieves one Axiom dashboard by stable UID.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(z.object(DASHBOARD_UID))
  .output(AXIOM_DASHBOARD_RESOURCE_SCHEMA)
  .retry({ replaySafety: "safe" })
  .handler(({ account, input }) =>
    getAxiomApi(account).request(
      `dashboards/uid/${axiomPath(input.dashboardUid)}`,
      { responseSchema: AXIOM_DASHBOARD_RESOURCE_SCHEMA },
    ),
  )

export const updateAxiomDashboard = defineAction("Update Axiom dashboard")
  .describe("Replaces one dashboard with optimistic concurrency or overwrite.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(DASHBOARD_WRITE_INPUT_SCHEMA)
  .output(AXIOM_DASHBOARD_WRITE_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(({ account, input: { dashboardUid, dashboard, ...writeOptions } }) =>
    getAxiomApi(account).request(`dashboards/uid/${axiomPath(dashboardUid)}`, {
      body: { dashboard, ...writeOptions },
      method: "PUT",
      numericStringFields: ["version"],
      responseSchema: AXIOM_DASHBOARD_WRITE_SCHEMA,
    }),
  )

export const deleteAxiomDashboard = defineAction("Delete Axiom dashboard")
  .describe("Deletes one Axiom dashboard by stable UID.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(z.object(DASHBOARD_UID))
  .output(AXIOM_EMPTY_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(({ account, input }) =>
    getAxiomApi(account).request(
      `dashboards/uid/${axiomPath(input.dashboardUid)}`,
      { method: "DELETE", responseSchema: AXIOM_EMPTY_SCHEMA },
    ),
  )

export const updateAxiomDashboardChart = defineAction(
  "Update Axiom dashboard chart",
)
  .describe("Merge-patches one chart with optimistic concurrency or overwrite.")
  .account(AXIOM_ACCOUNT, AXIOM_API_TOKEN_ACCOUNT)
  .input(
    z
      .object({
        ...DASHBOARD_UID,
        ...WRITE_OPTIONS,
        chartId: AXIOM_ID_SCHEMA,
        chart: DASHBOARD_CHART_PATCH_SCHEMA,
      })
      .refine(
        ({ chart, chartId }) => chart.id === undefined || chart.id === chartId,
        { message: "chart.id must match chartId when provided." },
      )
      .refine(({ overwrite, version }) => overwrite || version !== undefined, {
        message: "Provide version unless overwrite is true.",
      }),
  )
  .output(AXIOM_DASHBOARD_WRITE_SCHEMA)
  .retry({ replaySafety: "unsafe" })
  .handler(
    ({ account, input: { chart, chartId, dashboardUid, ...writeOptions } }) =>
      getAxiomApi(account).request(
        `dashboards/uid/${axiomPath(dashboardUid)}/charts/${axiomPath(chartId)}`,
        {
          body: { chart, ...writeOptions },
          method: "PATCH",
          numericStringFields: ["version"],
          responseSchema: AXIOM_DASHBOARD_WRITE_SCHEMA,
        },
      ),
  )