import {z} from 'zod'

export type DashboardChartPatchDocument = {[key: string]: unknown};

export type DashboardChartPatchRequest = {chart: DashboardChartPatchDocument, message?: string | undefined, overwrite?: boolean | undefined, version?: number | undefined};

export type PatchApiDashboardsUidUidChartsChartIdArgs = {uid: string, chartId: string, body: DashboardChartPatchRequest};

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

export const owner = z.string();

export const chartId = z.string().min(1).max(200);

export const sectionId = z.string();

export const aplString = z.string().min(1).max(500000);

export const booleanString = z.enum(["true", "false", ""]);

export const timeSeriesQueryOptions = z.object({displayNull: z.enum(["auto", "null", "span", "zero", ""]).optional(), overlayCharts: booleanString.optional(), shownColumns: z.string().max(10000).optional(), timeSeriesVariant: z.enum(["area", "bars", "line", "lines", ""]).optional(), timeSeriesView: z.enum(["charts", "resultsTable", "charts|resultsTable", ""]).optional()});

export const timeSeriesNonMetricsAplQuery = z.object({apl: aplString, queryOptions: timeSeriesQueryOptions.optional()});

export const mplString = z.string().min(1).max(500000);

export const timeSeriesNativeMplQuery = z.object({mpl: mplString, queryOptions: timeSeriesQueryOptions.optional()});

export const timeSeriesChartQuery = z.union([timeSeriesNonMetricsAplQuery, timeSeriesNativeMplQuery]);

export const timeSeriesChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("TimeSeries"), name: z.string().min(1).max(500).optional(), query: timeSeriesChartQuery});

export const heatmapQueryOptions = z.object({timeSeriesView: z.enum(["charts", "resultsTable", "charts|resultsTable", ""]).optional()});

export const heatmapNonMetricsAplQuery = z.object({apl: aplString, queryOptions: heatmapQueryOptions.optional()});

export const heatmapNativeMplQuery = z.object({mpl: mplString, queryOptions: heatmapQueryOptions.optional()});

export const heatmapChartQuery = z.union([heatmapNonMetricsAplQuery, heatmapNativeMplQuery]);

export const heatmapChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Heatmap"), name: z.string().min(1).max(500).optional(), query: heatmapChartQuery, colorScheme: z.enum(["Blue", "Orange", "Red", "Purple", "Teal", "Yellow", "Green", "Pink", "Grey", "Brown"]).optional()});

export const simpleNonMetricsAplQuery = z.object({apl: aplString});

export const simpleNativeMplQuery = z.object({mpl: mplString});

export const simpleChartQuery = z.union([simpleNonMetricsAplQuery, simpleNativeMplQuery]);

export const advancedColumnSetting = z.object({name: z.string().max(500), width: z.number().int().gt(0).lte(9007199254740991).optional()});

export const columnSetting = z.union([z.string().max(500), advancedColumnSetting]);

export const datasetStreamSettings = z.object({fontSize: z.string().max(20).optional(), highlightSeverity: z.boolean().optional(), showRaw: z.boolean().optional(), showEvent: z.boolean().optional(), showTimestamp: z.boolean().optional(), wrapLines: z.boolean().optional(), hideNulls: z.boolean().optional(), fitColumns: z.boolean().optional()});

export const tableSettings = z.object({columns: z.array(columnSetting).optional(), settings: datasetStreamSettings.optional()});

export const logStreamChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("LogStream"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery, tableSettings: tableSettings.optional()});

export const pieChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Pie"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery});

export const scatterChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Scatter"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery});

export const tableChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Table"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery, tableSettings: tableSettings.optional()});

export const topKChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("TopK"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery});

export const cssColor = z.string().max(200);

export const statisticChartColorProps = z.object({background: cssColor.optional(), chartFillColor: cssColor.optional(), labelColor: cssColor.optional(), textColor: cssColor.optional()});

export const statisticChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Statistic"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery, colorScheme: z.enum(["Blue", "Orange", "Red", "Purple", "Teal", "Yellow", "Green", "Pink", "Grey", "Brown"]).optional(), customUnits: z.string().max(200).optional(), showChart: z.union([z.boolean(), z.string()]).optional(), hideValue: z.boolean().optional(), chartHeight: z.union([z.string().max(100), z.number()]).optional(), errorThreshold: z.enum(["Above", "AboveOrEqual", "Below", "BelowOrEqual", "AboveOrBelow"]).optional(), errorThresholdValue: z.string().max(100).optional(), warningThreshold: z.enum(["Above", "AboveOrEqual", "Below", "BelowOrEqual", "AboveOrBelow"]).optional(), warningThresholdValue: z.string().max(100).optional(), roundTo: z.number().int().gte(0).lte(10).optional(), invertTheme: z.boolean().optional(), background: cssColor.optional(), textColor: cssColor.optional(), labelColor: cssColor.optional(), chartFillColor: cssColor.optional(), okColorProps: statisticChartColorProps.optional(), warningColorProps: statisticChartColorProps.optional(), errorColorProps: statisticChartColorProps.optional()});

export const gaugeChartSegment = z.object({from: z.number(), to: z.number()});

export const gaugeChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Gauge"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery, segments: z.array(gaugeChartSegment), colorScale: z.enum(["green-to-red", "red-to-green"]).optional(), showRing: z.boolean().optional(), labelMode: z.enum(["none", "boundaries", "intervals"]).optional(), showSparkline: z.boolean().optional(), scaleToTimeRange: z.boolean().optional(), scaleBaseDurationMs: z.number().gt(0).optional(), customUnits: z.string().max(200).optional()});

export const noteChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Note"), text: z.string().min(1).max(100000), variant: z.enum(["", "default", "plain"]).nullable().optional()});

export const monitorListColumns = z.object({status: z.boolean(), history: z.boolean(), dataset: z.boolean(), type: z.boolean(), notifiers: z.boolean()});

export const monitorListChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("MonitorList"), name: z.string().min(1).max(500).optional(), selectedMonitors: z.array(z.string().min(1).max(200)), columns: monitorListColumns});

export const smartFilterId = z.string().max(200);

export const smartFilterName = z.string().max(200);

export const smartFilterActive = z.boolean();

export const smartFilterSearch = z.object({id: smartFilterId, name: smartFilterName, active: smartFilterActive.optional(), type: z.literal("search")});

export const smartFilterOption = z.object({key: z.string().max(500), value: z.string().max(10000), default: z.boolean().optional(), unset: z.boolean().optional()});

export const smartFilterOptions = z.union([z.array(smartFilterOption), z.unknown(), z.literal("").nullable()]);

export const smartFilterSelectList = z.object({id: smartFilterId, name: smartFilterName, active: smartFilterActive.optional(), options: smartFilterOptions.optional(), type: z.literal("select"), selectType: z.literal("list")});

export const smartFilterAplQuery = z.object({apl: z.string().min(1).max(500000)});

export const smartFilterNativeMplQuery = z.object({mpl: z.string().min(1).max(500000)});

export const smartFilterQuery = z.union([smartFilterAplQuery, smartFilterNativeMplQuery]);

export const smartFilterSelectQuery = z.object({id: smartFilterId, name: smartFilterName, active: smartFilterActive.optional(), options: z.union([z.array(smartFilterOption), z.unknown(), z.literal("").nullable()]).optional(), type: z.literal("select"), selectType: z.literal("query"), query: smartFilterQuery.optional()});

export const smartFilterSelect = z.union([smartFilterSelectList, smartFilterSelectQuery]);

export const smartFilterConfig = z.union([smartFilterSearch, smartFilterSelect]);

export const logoUrl = z.string().max(2000);

export const smartFilterChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("SmartFilter"), name: z.string().min(1).max(500).optional(), filters: z.array(smartFilterConfig), logo: logoUrl.optional(), logoDark: logoUrl.optional()});

export const spacerChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Spacer"), name: z.string().min(1).max(500).optional(), variant: z.enum(["transparent", "dashed", "solid"]).optional()});

export const visualizeConfigurationVersion = z.literal(1);

export const visualizeAxisFieldType = z.enum(["datetime", "integer", "float"]);

export const visualizeAxisColumnRef = z.object({name: z.string().min(1).max(500), type: visualizeAxisFieldType});

export const visualizeNumericFieldType = z.enum(["integer", "float"]);

export const visualizeNumericColumnRef = z.object({name: z.string().min(1).max(500), type: visualizeNumericFieldType});

export const visualizeCategoricalFieldType = z.enum(["string", "boolean"]);

export const visualizeCategoricalColumnRef = z.object({name: z.string().min(1).max(500), type: visualizeCategoricalFieldType});

export const scatterVisualizationBindings = z.object({x: visualizeAxisColumnRef, y: visualizeNumericColumnRef, series: visualizeCategoricalColumnRef.optional()});

export const visualizeColorSettings = z.object({palette: z.enum(["axiom", "polychrome"]), assignment: z.enum(["series-name", "series-order"])});

export const visualizeAxisSettings = z.object({scale: z.enum(["linear", "log"]), range: z.enum(["fit", "includeZero"])});

export const visualizeLegendSettings = z.object({position: z.enum(["none", "bottom", "right"])});

export const scatterVisualizationSettings = z.object({colors: visualizeColorSettings.optional(), xAxis: visualizeAxisSettings.optional(), yAxis: visualizeAxisSettings.optional(), legend: visualizeLegendSettings.optional()});

export const scatterVisualization = z.object({version: visualizeConfigurationVersion, type: z.literal("scatter"), bindings: scatterVisualizationBindings, settings: scatterVisualizationSettings});

export const barVisualizationBindings = z.object({category: visualizeCategoricalColumnRef, value: visualizeNumericColumnRef, series: visualizeCategoricalColumnRef.optional()});

export const visualizeStandardAggregation = z.enum(["avg", "sum", "count", "min", "max"]);

export const visualizeCategoryLimit = z.number().int().gte(1).lte(100);

export const visualizeStandardAggregationSettings = z.object({aggregation: visualizeStandardAggregation, categoryLimit: visualizeCategoryLimit, colors: visualizeColorSettings.optional(), yAxis: visualizeAxisSettings.optional(), legend: visualizeLegendSettings.optional()});

export const visualizePercentile = z.number().gte(0).lte(100);

export const visualizePercentileAggregationSettings = z.object({aggregation: z.literal("percentile"), percentile: visualizePercentile, categoryLimit: visualizeCategoryLimit, colors: visualizeColorSettings.optional(), yAxis: visualizeAxisSettings.optional(), legend: visualizeLegendSettings.optional()});

export const visualizeBarSettings = z.union([visualizeStandardAggregationSettings, visualizePercentileAggregationSettings]);

export const barVisualization = z.object({version: visualizeConfigurationVersion, type: z.literal("bar"), bindings: barVisualizationBindings, settings: visualizeBarSettings});

export const horizontalBarVisualizationBindings = z.object({category: visualizeCategoricalColumnRef, value: visualizeNumericColumnRef, series: visualizeCategoricalColumnRef.optional()});

export const horizontalBarVisualization = z.object({version: visualizeConfigurationVersion, type: z.literal("horizontalBar"), bindings: horizontalBarVisualizationBindings, settings: visualizeBarSettings});

export const histogramVisualizationBindings = z.object({value: visualizeNumericColumnRef});

export const visualizeBinCount = z.number().int().gte(1).lte(200);

export const histogramVisualizationSettings = z.object({binCount: visualizeBinCount, colors: visualizeColorSettings.optional(), yAxis: visualizeAxisSettings.optional()});

export const histogramVisualization = z.object({version: visualizeConfigurationVersion, type: z.literal("histogram"), bindings: histogramVisualizationBindings, settings: histogramVisualizationSettings});

export const frequencyBarVisualizationBindings = z.object({category: visualizeCategoricalColumnRef});

export const frequencyBarVisualizationSettings = z.object({categoryLimit: visualizeCategoryLimit, colors: visualizeColorSettings.optional(), yAxis: visualizeAxisSettings.optional()});

export const frequencyBarVisualization = z.object({version: visualizeConfigurationVersion, type: z.literal("frequencyBar"), bindings: frequencyBarVisualizationBindings, settings: frequencyBarVisualizationSettings});

export const visualizeHeatmapBindings = z.object({x: visualizeCategoricalColumnRef, y: visualizeCategoricalColumnRef});

export const visualizeHeatmapSettings = z.object({categoryLimit: visualizeCategoryLimit});

export const visualizeHeatmap = z.object({version: visualizeConfigurationVersion, type: z.literal("heatmap"), bindings: visualizeHeatmapBindings, settings: visualizeHeatmapSettings});

export const visualizeConfiguration = z.union([scatterVisualization, barVisualization, horizontalBarVisualization, histogramVisualization, frequencyBarVisualization, visualizeHeatmap]);

export const visualizeChart = z.object({id: chartId, sectionId: sectionId.optional(), type: z.literal("Visualize"), name: z.string().min(1).max(500).optional(), query: simpleChartQuery, visualization: visualizeConfiguration});

export const chart = z.union([timeSeriesChart, heatmapChart, logStreamChart, pieChart, scatterChart, tableChart, topKChart, statisticChart, gaugeChart, noteChart, monitorListChart, smartFilterChart, spacerChart, visualizeChart]);

export const layoutItem = z.object({i: chartId, x: z.number().int().gte(0).lte(11), y: z.number().gte(0).nullable(), w: z.number().int().gte(1).lte(12), h: z.number().gte(0.5).lte(100), minW: z.number().int().gte(1).lte(12).optional(), minH: z.number().gte(0.5).lte(100).optional(), maxW: z.number().int().gte(1).lte(12).optional(), maxH: z.number().int().gte(1).lte(100).optional(), static: z.boolean().optional()});

export const section = z.object({id: sectionId, title: z.string().min(1).max(200), defaultCollapsed: z.boolean().optional()});

export const schemaVersion = z.literal(2);

export const datetimeString = z.string().max(100);

export const timeWindowStart = z.string().min(1).max(100);

export const timeWindowEnd = z.string().min(1).max(100);

export const dashboardUID = z.string();

export const dashboardDocument = z.object({name: z.string().min(1).max(100), owner: owner, description: z.string().max(1000).optional(), charts: z.array(chart), layout: z.array(layoutItem), sections: z.array(section).optional(), refreshTime: z.union([z.literal(0), z.literal(15), z.literal(60), z.literal(300)]), schemaVersion: schemaVersion, against: z.enum(["-1h", "-3h", "-6h", "-12h", "-1d", "-3d", "-7d", "-1w", "-2w", "-3w", "-30d", "-60d", "-90d"]).optional(), againstTimestamp: datetimeString.optional(), timeWindowStart: timeWindowStart, timeWindowEnd: timeWindowEnd, uid: dashboardUID.optional()});

export const labelID = z.string();

export const labelColor = z.object({name: z.enum(["red", "coral", "orange", "amber", "yellow", "lime", "green", "teal", "blue", "iris", "purple", "pink"]), type: z.literal("palette")});

export const label = z.object({color: labelColor, description: z.string().nullable().optional(), id: labelID, name: z.string()});

export const dashboardResource = z.object({createdAt: z.string().nullable().optional(), createdBy: z.string().nullable().optional(), dashboard: dashboardDocument, id: z.string(), labelIds: z.array(labelID), labelNames: z.array(z.string()).optional(), labels: z.array(label).optional(), type: z.enum(["managed", "integration"]), uid: z.string(), updatedAt: z.string().nullable().optional(), updatedBy: z.string().nullable().optional(), updatedByAgent: z.boolean().optional(), version: z.number().int().nullable().optional()});

export const dashboardWriteResponse = z.object({dashboard: dashboardResource, overwritten: z.boolean().optional(), status: z.enum(["created", "updated"])});

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

/**
 * Patch dashboard chart
 * 
 * PATCH /dashboards/uid/{uid}/charts/{chartId}
 */
export const patchApiDashboardsUidUidChartsChartId = async (args: PatchApiDashboardsUidUidChartsChartIdArgs, options?: PatchApiDashboardsUidUidChartsChartIdOptions) => {
const {baseUrl = "https://api.axiom.co/v2", fetch: fetchFn = fetch, bearerAuth} = options ?? {}

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

if (bearerAuth !== undefined) headers.set('authorization', `Bearer ${bearerAuth}`)

const url = `${baseUrl.replace(/\/+$/, '')}/dashboards/uid/${encodeURIComponent(String(args.uid))}/charts/${encodeURIComponent(String(args.chartId))}${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "PATCH", 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(dashboardWriteResponse, await res.json())
};