TJWaterFrontend_Refine/src/lib/analysisRuns.ts

import { api } from "@/lib/api";

export type AnalysisRun = {
  run_id: string;
  name: string;
  run_type: string;
  created_by: string;
  created_at: string;
  started_at: string;
  status: string;
  parameters: Record<string, unknown>;
};

export type AnalysisHistoryContext = {
  simulationRunId?: string;
  eventRange: { start: string; end: string } | null;
};

const SIMULATION_RUN_TYPES = new Set([
  "burst_analysis",
  "flushing_analysis",
  "contaminant_analysis",
  "valve_close_analysis",
  "pressure_regulation",
]);

export const getAnalysisHistoryContext = (
  run: AnalysisRun,
): AnalysisHistoryContext => {
  const parameters = normalizeParameters(run.parameters);
  if (SIMULATION_RUN_TYPES.has(run.run_type)) {
    const start = Date.parse(run.started_at);
    const duration = parameters.modify_total_duration ?? parameters.duration;
    const end = new Date(
      typeof duration === "number" ? start + duration * 1000 : NaN,
    ).getTime();
    return {
      simulationRunId: run.run_id,
      eventRange:
        Number.isFinite(start) && Number.isFinite(end) && end > start
          ? {
              start: new Date(start).toISOString(),
              end: new Date(end).toISOString(),
            }
          : null,
    };
  }

  const payload = normalizeParameters(parameters.result_payload);
  const window = normalizeParameters(
    parameters.scada_window ?? payload.scada_window,
  );
  const start = window.burst_start ?? window.start ?? parameters.scada_start;
  const end = window.burst_end ?? window.end ?? parameters.scada_end;
  const simulation = normalizeParameters(
    payload.simulation_run ?? payload.simulation_scheme,
  );
  const simulationRunId = parameters.simulation_run_id ?? simulation.run_id;
  return {
    simulationRunId:
      typeof simulationRunId === "string" && simulationRunId.trim()
        ? simulationRunId.trim()
        : undefined,
    eventRange:
      typeof start === "string" &&
      typeof end === "string" &&
      Number.isFinite(Date.parse(start)) &&
      Date.parse(end) > Date.parse(start)
        ? { start, end }
        : null,
  };
};

export type AnalysisResult = {
  result_id: string;
  run_id: string;
  result_type: string;
  node_id?: string | null;
  link_id?: string | null;
  payload: Record<string, unknown>;
  created_at: string;
};

type AnalysisRunListResponse = {
  success: boolean;
  data: AnalysisRun[];
  count: number;
};

export type AnalysisSchemeRecord = AnalysisRun & {
  id: string;
  scheme_id: string;
  scheme_name: string;
  scheme_type: string;
  username: string;
  create_time: string;
  scheme_start_time: string;
  scheme_detail: Record<string, unknown>;
  schemeName: string;
  type: string;
  startTime: string;
  schemeDetail: Record<string, unknown>;
};

const normalizeParameters = (value: unknown): Record<string, unknown> =>
  value && typeof value === "object" && !Array.isArray(value)
    ? (value as Record<string, unknown>)
    : {};

export const toAnalysisSchemeRecord = (run: AnalysisRun): AnalysisSchemeRecord => {
  const parameters = normalizeParameters(run.parameters);
  return {
    ...run,
    parameters,
    id: run.run_id,
    scheme_id: run.run_id,
    scheme_name: run.name,
    scheme_type: run.run_type,
    username: run.created_by,
    create_time: run.created_at,
    scheme_start_time: run.started_at,
    scheme_detail: parameters,
    schemeName: run.name,
    type: run.run_type,
    startTime: run.started_at,
    schemeDetail: parameters,
  };
};

export const listAnalysisSchemes = async ({
  runType,
  queryDate,
}: {
  runType?: string;
  queryDate?: string;
} = {}): Promise<AnalysisSchemeRecord[]> => {
  const response = await api.get<AnalysisRunListResponse>(
    "/api/v1/analysis/runs",
  );
  const runs = Array.isArray(response.data.data) ? response.data.data : [];
  return runs
    .filter((run) => !runType || run.run_type === runType)
    .filter((run) => !queryDate || run.created_at.slice(0, 10) === queryDate)
    .map(toAnalysisSchemeRecord);
};

export const getAnalysisScheme = async (
  runId: string,
): Promise<AnalysisSchemeRecord> => {
  const response = await api.get<AnalysisRun>(
    `/api/v1/analysis/runs/${encodeURIComponent(runId)}`,
  );
  return toAnalysisSchemeRecord(response.data);
};

export const getAnalysisResults = async (
  runId: string,
  resultType?: string,
): Promise<AnalysisResult[]> => {
  const response = await api.get<AnalysisResult[]>(
    `/api/v1/analysis/runs/${encodeURIComponent(runId)}/results`,
    { params: resultType ? { result_type: resultType } : undefined },
  );
  return Array.isArray(response.data) ? response.data : [];
};