shoc-frontend-new/src/domain/work-orders/api/work-orders-api.ts

import { API_PATHS } from "@/api/api-paths";
import { ApiError, mapHttpStatusToMessage } from "@/api/api-error";
import { api, apiDelete, apiGet, apiPost, apiPostForm, apiPut } from "@/api/api";
import { handleApiResponse, handlePaginatedResponse } from "@/api/handle-api-response";
import {
  BoardPatchConflictError,
  BoardPatchValidationError,
} from "@/domain/work-orders/errors/board-patch-errors";
import {
  mapDispatchComment,
  mapDispatchDetail,
  mapDispatchSignoff,
  mapDispatchToVendorPayload,
  mapEmployeeOptions,
  mapLocationOptions,
  mapTaskListTemplates,
  mapUpdateDispatchPayload,
  mapVendorDropdownItems,
  mapWorkOrderDetail,
  mapWorkOrderFormToCreatePayload,
  mapWorkOrderFormToUpdateFormData,
  mapWorkOrderTableRow,
  mapWorkOrderTableRows,
} from "@/domain/work-orders/mappers/work-order-mapper";
import { mapWizardDraftToBoardCreatePayload } from "@/domain/work-orders/mappers/work-order-board-mapper";
import {
  buildCompletionDocFormData,
  buildMediaFormData,
  mapBoardDetailComment,
  mapBoardDetailMediaItem,
  mapCompletion,
  mapWorkOrderBoardDetail,
  type UploadableMediaCategory,
} from "@/domain/work-orders/mappers/work-order-board-detail-mapper";
import type { WorkOrderFormSchemaValues } from "@/domain/work-orders/schemas/work-order-schema";
import type {
  DispatchDetail,
  DispatchToVendorPayload,
  EmployeeOption,
  LocationOption,
  TaskListTemplate,
  UpdateDispatchPayload,
  WorkOrderVendorUpdatePayload,
  VendorDropdownItem,
  WorkOrderComment,
  WorkOrderDetail,
  WorkOrderFormValues,
  WorkOrderUser,
} from "@/domain/work-orders/types/work-order";
import type { WorkOrderWizardDraft } from "@/domain/work-orders/types/work-order-wizard";
import type {
  WorkOrderBoardListResult,
  WorkOrderBoardPatchPayload,
  WorkOrderBoardQueryParams,
  WorkOrderBoardResponseApi,
  WorkOrderBoardSearchQueryParams,
} from "@/domain/work-orders/types/work-order-board";
import type {
  WorkOrderBoardCompletion,
  WorkOrderBoardDetail,
  WorkOrderBoardMediaItem,
} from "@/domain/work-orders/types/work-order-board-detail";
import type { WorkOrderTableRow } from "@/domain/work-orders/types/work-order-table-row";
import {
  DISPATCH_LOCATION_WO_PAGE_SIZE,
  type WorkOrdersListParams,
  type WorkOrdersListResult,
} from "@/domain/work-orders/types/work-order-list";
import { buildBoardSearchParamsRecord } from "@/domain/work-orders/utils/board-query-params";

async function readResponseJson(response: Response): Promise<unknown> {
  try {
    return await response.json();
  } catch {
    return undefined;
  }
}

function throwDocumentHttpError(response: Response, data: unknown): never {
  const record = typeof data === "object" && data !== null ? (data as Record<string, unknown>) : {};

  if (response.status === 409) {
    throw new BoardPatchConflictError(
      typeof record.message === "string"
        ? record.message
        : "The record was modified by another user. Refresh and retry.",
      null,
    );
  }

  if (response.status === 422) {
    throw new BoardPatchValidationError(
      typeof record.code === "string" ? record.code : "ValidationError",
      typeof record.message === "string" ? record.message : mapHttpStatusToMessage(422, data),
    );
  }

  throw new ApiError(mapHttpStatusToMessage(response.status, data), response.status);
}

function buildSearchParams(params: WorkOrdersListParams): Record<string, string | number> {
  const searchParams: Record<string, string | number> = {
    search: params.search ?? "",
    page: params.page ?? 1,
    pageSize: params.pageSize ?? 12,
  };

  if (params.sortBy) {
    searchParams.sortBy = params.sortBy;
  }
  if (params.sortDir) {
    searchParams.sortDir = params.sortDir;
  }
  if (params.status) {
    searchParams.status = params.status;
  }
  if (params.assignee) {
    searchParams.assignee = params.assignee;
  }
  if (params.locationId) {
    searchParams.locationId = params.locationId;
  }
  if (params.dateFrom) {
    searchParams.dateFrom = params.dateFrom;
  }
  if (params.dateTo) {
    searchParams.dateTo = params.dateTo;
  }
  if (params.type) {
    searchParams.type = params.type;
  }
  if (params.assigneeIds) {
    searchParams.assigneeIds = params.assigneeIds;
  }

  return searchParams;
}

function toUrlSearchParams(
  params: Record<string, string | number | boolean | (string | number)[]>,
): URLSearchParams {
  const sp = new URLSearchParams();
  for (const [key, value] of Object.entries(params)) {
    if (Array.isArray(value)) {
      for (const entry of value) {
        sp.append(key, String(entry));
      }
      continue;
    }
    sp.append(key, String(value));
  }
  return sp;
}

function mapUser(raw: unknown): WorkOrderUser {
  const item = (typeof raw === "object" && raw !== null ? raw : {}) as Record<string, unknown>;
  const id = item.id ?? item.Id;
  const name =
    (typeof item.name === "string" ? item.name : undefined) ??
    (typeof item.Name === "string" ? item.Name : undefined) ??
    (typeof item.userName === "string" ? item.userName : "") ??
    "";

  return {
    id: typeof id === "string" || typeof id === "number" ? id : "",
    name,
  };
}

export const workOrdersApi = {
  getList: async (params: WorkOrdersListParams = {}): Promise<WorkOrdersListResult> => {
    const searchParams = buildSearchParams(params);
    const data = await apiGet<unknown>(API_PATHS.workOrder.getList, { searchParams });
    const paginated = handlePaginatedResponse<unknown>(data, {
      page: params.page,
      pageSize: params.pageSize,
    });

    return {
      items: mapWorkOrderTableRows(paginated.items),
      totalCount: paginated.totalCount,
      page: paginated.page,
      pageSize: paginated.pageSize,
    };
  },

  getBoard: async (params: WorkOrderBoardQueryParams): Promise<WorkOrderBoardListResult> => {
    const searchParams = toUrlSearchParams(buildBoardSearchParamsRecord(params));
    const data = await apiGet<unknown>(API_PATHS.workOrder.board, { searchParams });
    const payload = (
      typeof data === "object" && data !== null ? data : {}
    ) as WorkOrderBoardResponseApi;

    const scheduled = mapWorkOrderTableRows(payload.scheduled ?? []);
    const unscheduled = mapWorkOrderTableRows(payload.unscheduled ?? []);
    const returnedCount = payload.counts?.returned ?? scheduled.length;
    const totalCount = payload.counts?.total ?? returnedCount;

    return {
      items: [...unscheduled, ...scheduled],
      scheduled,
      unscheduled,
      totalCount,
      returnedCount,
      page: 1,
      pageSize: scheduled.length + unscheduled.length,
      weekStart: payload.weekStart,
      weekEnd: payload.weekEnd,
    };
  },

  searchBoard: async (
    params: WorkOrderBoardSearchQueryParams,
  ): Promise<WorkOrderBoardListResult> => {
    const searchParams = toUrlSearchParams(buildBoardSearchParamsRecord(params));
    const data = await apiGet<unknown>(API_PATHS.workOrder.boardSearch, { searchParams });
    const paginated = handlePaginatedResponse<unknown>(data, {
      page: params.page,
      pageSize: params.pageSize,
    });
    const items = mapWorkOrderTableRows(paginated.items);

    return {
      items,
      scheduled: items.filter((row) => !!row.scheduledOn),
      unscheduled: items.filter((row) => !row.scheduledOn),
      totalCount: paginated.totalCount,
      returnedCount: items.length,
      page: paginated.page,
      pageSize: paginated.pageSize,
    };
  },

  getListByLocation: async (
    locationId: string | number,
    search = "",
  ): Promise<WorkOrdersListResult> => {
    return workOrdersApi.getList({
      locationId,
      search,
      page: 1,
      pageSize: DISPATCH_LOCATION_WO_PAGE_SIZE,
      sortBy: "number",
      sortDir: "asc",
    });
  },

  fetchUsers: async (): Promise<WorkOrderUser[]> => {
    const data = await apiGet<unknown>(API_PATHS.user.list);
    const users = handleApiResponse<unknown[]>(data);
    return Array.isArray(users) ? users.map(mapUser) : [];
  },

  fetchDispatchers: async (): Promise<WorkOrderUser[]> => {
    try {
      const data = await apiGet<unknown>(API_PATHS.workOrder.lookupsDispatchers);
      const users = handleApiResponse<unknown[]>(data);
      const mapped = Array.isArray(users) ? users.map(mapUser) : [];
      if (mapped.length > 0) {
        return mapped;
      }
    } catch {
      // Fall back to User list when lookup is unavailable.
    }

    return workOrdersApi.fetchUsers();
  },

  getById: async (id: string | number): Promise<WorkOrderDetail> => {
    const data = await apiGet<unknown>(API_PATHS.workOrder.getById, {
      searchParams: { id },
    });
    return mapWorkOrderDetail(handleApiResponse(data));
  },

  getBoardDetail: async (id: string | number): Promise<WorkOrderBoardDetail> => {
    const data = await apiGet<unknown>(API_PATHS.workOrder.boardDetail(id));
    return mapWorkOrderBoardDetail(handleApiResponse(data));
  },

  create: async (
    values: WorkOrderFormSchemaValues | WorkOrderFormValues,
  ): Promise<WorkOrderDetail> => {
    const payload = mapWorkOrderFormToCreatePayload(values);
    const data = await apiPost<unknown>(API_PATHS.workOrder.addWorkorder, payload);
    return mapWorkOrderDetail(handleApiResponse(data));
  },

  createFromBoard: async (draft: WorkOrderWizardDraft): Promise<WorkOrderDetail> => {
    const payload = mapWizardDraftToBoardCreatePayload(draft);
    const data = await apiPost<unknown>(API_PATHS.workOrder.boardCreate, payload);
    return mapWorkOrderDetail(handleApiResponse(data));
  },

  patchBoardField: async (
    id: string | number,
    payload: WorkOrderBoardPatchPayload,
  ): Promise<WorkOrderTableRow> => {
    const response = await api.patch(API_PATHS.workOrder.boardPatch(id), {
      json: payload,
      throwHttpErrors: false,
    });

    let data: unknown;
    try {
      data = await response.json();
    } catch {
      data = undefined;
    }

    if (response.ok) {
      return mapWorkOrderTableRow(data);
    }

    const record =
      typeof data === "object" && data !== null ? (data as Record<string, unknown>) : {};

    if (response.status === 409) {
      const currentStateRaw = record.currentState ?? record.CurrentState;
      const currentState = currentStateRaw != null ? mapWorkOrderTableRow(currentStateRaw) : null;
      throw new BoardPatchConflictError(
        typeof record.message === "string"
          ? record.message
          : "The record was modified by another user. Refresh and retry.",
        currentState,
      );
    }

    if (response.status === 422) {
      throw new BoardPatchValidationError(
        typeof record.code === "string" ? record.code : "ValidationError",
        typeof record.message === "string" ? record.message : mapHttpStatusToMessage(422, data),
      );
    }

    throw new ApiError(mapHttpStatusToMessage(response.status, data), response.status);
  },

  update: async (
    id: string | number,
    values: WorkOrderFormSchemaValues | WorkOrderFormValues,
  ): Promise<void> => {
    const formData = mapWorkOrderFormToUpdateFormData(id, values);
    await apiPostForm<{ message?: string; status?: string }>(
      API_PATHS.workOrder.editWorkorder,
      formData,
    );
  },

  delete: async (id: string | number): Promise<void> => {
    await apiDelete(API_PATHS.workOrder.deleteWorkorder, {
      json: { Id: Number(id) },
    });
  },

  listComments: async (workOrderId: string | number): Promise<WorkOrderComment[]> => {
    const data = await apiGet<unknown>(API_PATHS.workOrder.comments(workOrderId));
    const items = handleApiResponse<unknown[]>(data);
    return Array.isArray(items) ? items.map(mapBoardDetailComment) : [];
  },

  createComment: async (workOrderId: string | number, text: string): Promise<WorkOrderComment> => {
    const data = await apiPost<unknown>(API_PATHS.workOrder.comments(workOrderId), { text });
    return mapBoardDetailComment(handleApiResponse(data));
  },

  updateComment: async (
    workOrderId: string | number,
    commentId: string | number,
    text: string,
  ): Promise<WorkOrderComment> => {
    const response = await api.patch(API_PATHS.workOrder.commentItem(workOrderId, commentId), {
      json: { text },
      throwHttpErrors: false,
    });
    const data = await readResponseJson(response);

    if (response.ok) {
      if (response.status === 204 || data == null) {
        return mapBoardDetailComment({ id: commentId, text });
      }
      return mapBoardDetailComment(handleApiResponse(data) ?? data);
    }

    throwDocumentHttpError(response, data);
  },

  /** @deprecated Prefer createComment — modern board endpoint. */
  addComment: async (
    workOrderId: string | number,
    text: string,
    _commentType?: string,
  ): Promise<WorkOrderComment> => {
    return workOrdersApi.createComment(workOrderId, text);
  },

  listMedia: async (workOrderId: string | number): Promise<WorkOrderBoardMediaItem[]> => {
    const data = await apiGet<unknown>(API_PATHS.workOrder.media(workOrderId));
    const items = handleApiResponse<unknown[]>(data);
    return Array.isArray(items) ? items.map(mapBoardDetailMediaItem) : [];
  },

  uploadMedia: async (
    workOrderId: string | number,
    file: File,
    category: UploadableMediaCategory,
  ): Promise<WorkOrderBoardMediaItem> => {
    const formData = buildMediaFormData(file, category);
    const response = await api.post(API_PATHS.workOrder.media(workOrderId), {
      body: formData,
      throwHttpErrors: false,
    });
    const data = await readResponseJson(response);
    if (response.ok) {
      return mapBoardDetailMediaItem(handleApiResponse(data) ?? data);
    }
    throwDocumentHttpError(response, data);
  },

  deleteMedia: async (workOrderId: string | number, mediaId: string | number): Promise<void> => {
    const numericId = typeof mediaId === "number" ? mediaId : Number(mediaId);
    if (!Number.isFinite(numericId) || numericId <= 0) {
      throw new BoardPatchValidationError(
        "InvalidMedia",
        "Legacy media cannot be deleted via this endpoint.",
      );
    }

    const response = await api.delete(API_PATHS.workOrder.mediaItem(workOrderId, numericId), {
      throwHttpErrors: false,
    });

    if (response.status === 204) {
      return;
    }

    const data = await readResponseJson(response);
    if (response.ok) {
      return;
    }
    throwDocumentHttpError(response, data);
  },

  uploadCompletionDoc: async (
    workOrderId: string | number,
    params: {
      file: File;
      workOrderVersion: string;
      signOffName?: string;
      signOffSignature?: string;
    },
  ): Promise<WorkOrderBoardCompletion> => {
    if (!params.workOrderVersion) {
      throw new BoardPatchValidationError(
        "WorkOrderVersionRequired",
        "workOrderVersion is required to upload a completion document.",
      );
    }

    const formData = buildCompletionDocFormData(params);
    const response = await api.post(API_PATHS.workOrder.completionDoc(workOrderId), {
      body: formData,
      throwHttpErrors: false,
    });
    const data = await readResponseJson(response);
    if (response.ok) {
      return mapCompletion(handleApiResponse(data) ?? data);
    }
    throwDocumentHttpError(response, data);
  },

  changeStatus: async (id: string | number, status: string): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.changeStatus, undefined, {
      searchParams: { id, status },
    });
  },

  changeAssignment: async (id: string | number, assignTo: string | number): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.changeAssignment, undefined, {
      searchParams: { id, assignTo: assignTo || "" },
    });
  },

  fetchLocations: async (): Promise<LocationOption[]> => {
    const data = await apiGet<unknown>(API_PATHS.contact.getLocations);
    const items = handleApiResponse<unknown[]>(data);
    return Array.isArray(items) ? mapLocationOptions(items) : [];
  },

  fetchEmployeesDropdown: async (): Promise<EmployeeOption[]> => {
    const data = await apiGet<unknown>(API_PATHS.employee.dropdown);
    const items = handleApiResponse<unknown[]>(data);
    return Array.isArray(items) ? mapEmployeeOptions(items) : [];
  },

  fetchVendorsDropdown: async (trade?: string, siteZip?: string): Promise<VendorDropdownItem[]> => {
    const searchParams: Record<string, string> = {};
    if (trade) {
      searchParams.trade = trade;
    }
    if (siteZip) {
      searchParams.siteZip = siteZip;
    }

    const data = await apiGet<unknown>(API_PATHS.vendor.dropdown, {
      searchParams: Object.keys(searchParams).length > 0 ? searchParams : undefined,
    });
    const items = handleApiResponse<unknown[]>(data);
    return Array.isArray(items) ? mapVendorDropdownItems(items) : [];
  },

  fetchTaskTemplates: async (): Promise<TaskListTemplate[]> => {
    const data = await apiGet<unknown>(API_PATHS.taskListTemplate.list);
    const items = handleApiResponse<unknown[]>(data);
    return Array.isArray(items) ? mapTaskListTemplates(items) : [];
  },

  dispatchToVendor: async (payload: DispatchToVendorPayload): Promise<void> => {
    await apiPost<unknown>(
      API_PATHS.workOrder.dispatchToVendor,
      mapDispatchToVendorPayload(payload),
    );
  },

  getDispatchById: async (id: string | number): Promise<DispatchDetail> => {
    const data = await apiGet<unknown>(`${API_PATHS.workOrder.getDispatch}/${id}`);
    return mapDispatchDetail(handleApiResponse(data));
  },

  updateDispatch: async (payload: UpdateDispatchPayload): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.updateDispatch, mapUpdateDispatchPayload(payload));
  },

  updateVendorFromWorkOrder: async (
    vendorId: string | number,
    payload: WorkOrderVendorUpdatePayload,
  ): Promise<void> => {
    await apiPut<unknown>(`${API_PATHS.rest.vendors}/${vendorId}/work-order-update`, payload);
  },

  addDispatchComment: async (
    dispatchId: string | number,
    text: string,
    sendEmail = true,
  ): Promise<DispatchDetail["comments"][number]> => {
    const data = await apiPost<unknown>(API_PATHS.workOrder.addDispatchComment, {
      DispatchId: dispatchId,
      Text: text,
      SendEmail: sendEmail,
    });
    return mapDispatchComment(handleApiResponse(data));
  },

  updateChecklistItem: async (
    id: string | number,
    isCompleted: boolean,
    completedBy: string,
  ): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.updateChecklistItem, {
      Id: id,
      IsCompleted: isCompleted,
      CompletedBy: completedBy,
    });
  },

  addChecklistItem: async (dispatchId: string | number, itemText: string): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.addChecklistItem, {
      DispatchId: dispatchId,
      ItemText: itemText,
    });
  },

  addDispatchSignoff: async (
    dispatchId: string | number,
    signoffType: string,
    name: string,
    signature: string,
    signatureMethod: string,
  ): Promise<DispatchDetail["signoffs"][number]> => {
    const data = await apiPost<unknown>(API_PATHS.workOrder.addDispatchSignoff, {
      DispatchId: dispatchId,
      SignoffType: signoffType,
      Name: name,
      Signature: signature,
      SignatureMethod: signatureMethod,
    });
    return mapDispatchSignoff(handleApiResponse(data));
  },

  verifyDispatch: async (dispatchId: string | number): Promise<void> => {
    await apiPost<unknown>(API_PATHS.workOrder.verifyDispatch, undefined, {
      searchParams: { dispatchId },
    });
  },
};