// import {
//   AcceptIncomingRecordDto,
//   AssignIncomingRecordDto,
//   ReAssignRecordDto,
// } from "@/record-management/dto/userRecords/usersDto";
// import { UserDto } from "@/record-management/dto/userRecords/userDto";
// import {
//   Seal,
//   SealDetail,
// } from "@/record-management/components/hooks/useSeals";
// import Cookies from "js-cookie";
// const API_URL = "http://iam-dev.smart.aaca.gov.et/";
// const Record_API_URL = "http://record-dev.smart.aaca.gov.et/";

// export const getOrganizationUnitId = (): string | null => {
//   const userDataString = Cookies.get("auth-user");
//   if (!userDataString) return null;

//   try {
//     const userData: UserDto = JSON.parse(userDataString);
//     return userData.employee?.[0]?.unitId || "";
//   } catch (e) {
//     console.error("Invalid JSON in localStorage userData:", e);
//     return null;
//   }
// };

// // Utility function to get cookie by name
// const getCookie = (name: string): string | null => {
//   const value = `; ${document.cookie}`;
//   const parts = value.split(`; ${name}=`);
//   if (parts.length === 2) return parts.pop()?.split(";").shift() || null;
//   return null;
// };

// // Get auth token from cookie
// const getAuthToken = (): string => {
//   const token = getCookie("auth-token");
//   if (!token) {
//     throw new Error("No auth token found in cookies");
//   }
//   return token;
// };

// const defaultHeaders = {
//   "Content-Type": "application/json",
//   get Authorization() {
//     return `Bearer ${getAuthToken()}`;
//   },
// };

// const fetchWithAuth = async (url: string, options: RequestInit = {}) => {
//   options.headers = {
//     ...defaultHeaders,
//     ...(options.headers || {}),
//   };
//   const res = await fetch(url, options);
//   if (!res.ok) {
//     console.error(
//       `Failed request: ${res.status} ${res.statusText}`,
//       await res.text()
//     );
//     const errorData = await res.json().catch(() => null);
//     const message = errorData?.message || res.statusText;
//     throw new Error(message);
//   }
//   return res;
// };

// const createWithAuth = async (url: string, data: any): Promise<any> => {
//   const res = await fetchWithAuth(url, {
//     method: "POST",
//     body: JSON.stringify(data),
//   });
//   return res.json();
// };

// export const fetchRecords = async (): Promise<any> => {
//   const res = await fetchWithAuth(`${Record_API_URL}api/records`);
//   return await res.json();
// };

// export const fetchValidOrganization = async (): Promise<any> => {
//   const res = await fetchWithAuth(
//     `${API_URL}api/organizations/record-receiving`
//   );
//   return await res.json();
// };

// export const fetchOrganizations = async (): Promise<any> => {
//   try {
//     const response = await fetch(`${API_URL}api/organizations`, {
//       method: "GET",
//       headers: {
//         Accept: "*/*",
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//     });

//     if (!response.ok) {
//       const errorText = await response.text();
//       console.error("Server response body:", errorText);
//       throw new Error(`HTTP error! status: ${response.status}`);
//     }
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error fetching organizations:", error);
//     return null;
//   }
// };

// export const fetchOrganizationById = async (
//   organizationId: string
// ): Promise<any> => {
//   const res = await fetchWithAuth(
//     `${API_URL}api/organizations/${organizationId}`
//   );
//   return await res.json();
// };

// export const fetchMyRecordById = async (recordId: string): Promise<any> => {
//   const res = await fetchWithAuth(`${Record_API_URL}api/records/${recordId}`);
//   return await res.json();
// };

// export const fetchListOfDepartments = async (
//   organizationId: string
// ): Promise<any> => {
//   try {
//     const response = await fetch(
//       `${API_URL}api/organizations/${organizationId}/departments`,
//       {
//         method: "GET",
//         headers: {
//           "Content-Type": "application/json",
//         },
//       }
//     );
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error fetching departments:", error);
//     return null;
//   }
// };

// export const getMe = async (): Promise<any> => {
//   try {
//     const response = await fetch(`${API_URL}api/me`, {
//       method: "GET",
//       headers: {
//         "Content-Type": "application/json",
//       },
//     });
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error fetching user data:", error);
//     return null;
//   }
// };

// export const getIncoming = async (
//   incomingtype?: string,
//   status?: string,
//   skip?: number,
//   take?: number
// ): Promise<{ items: any[]; count: number }> => {
//   try {
//     const skdip = skip || 0;
//     const takde = take || 10;

//     const url = new URL(`${Record_API_URL}api/incoming-instances/get-my`);
//     if (incomingtype) {
//       url.searchParams.append("recordType", incomingtype);
//     }
//     if (status) {
//       url.searchParams.append("status", status);
//     }
//     url.searchParams.append("skip", skdip.toString());
//     url.searchParams.append("take", takde.toString());

//     const response = await fetchWithAuth(url.toString());

//     if (!response.ok) throw new Error("Network response was not ok");

//     const data = await response.json();

//     return {
//       items: data.items || [],
//       count: data.count || 0,
//     };
//   } catch (error) {
//     console.error("Error fetching incoming records:", error);
//     return { items: [], count: 0 };
//   }
// };

// export const getCCIncoming = async (
//   skip?: number,
//   take?: number
// ): Promise<any> => {
//   const res = await fetchWithAuth(
//     `${Record_API_URL}api/incoming-instances/get-my-cc`,
//     {
//       method: "POST",
//       body: JSON.stringify({
//         skip: skip || 0,
//         take: take || 10,
//       }),
//     }
//   );
//   const data = await res.json();
//   return data;
// };

// export const fetchInternalDepartments = async (): Promise<any> => {
//   try {
//     const organizationUnitId = getOrganizationUnitId();
//     const response = await fetch(
//       `${API_URL}api/positions/list/${organizationUnitId}`,
//       {
//         method: "GET",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`,
//         },
//       }
//     );
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error fetching internal departments:", error);
//     return null;
//   }
// };

// export const fetchRecordTypes = async (): Promise<any> => {
//   try {
//     const response = await fetch(`${Record_API_URL}api/record-types`, {
//       method: "GET",
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//     });
//     if (!response.ok) {
//       throw new Error(response.statusText);
//     }
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error fetching record types:", error);
//     return null;
//   }
// };

// // Utility function to validate UUID (v4)
// function isValidUUID(uuid: string): boolean {
//   return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
//     uuid
//   );
// }

// export const UploadAttachment = async (
//   file: File,
//   recordContentId: string
// ): Promise<{
//   presigned(file: File, presigned: any): unknown;
//   id(id: any, recordContentId: string, arg2: boolean): unknown;
//   uploadUrl: string;
//   attachmentId: string;
//   responseParentId?: string;
// }> => {
//   try {
//     if (!isValidUUID(recordContentId)) {
//       throw new Error("Invalid recordContentId format");
//     }
//     const requestBody = {
//       fileInfo: {
//         fileName: file.name,
//         contentType: file.type || "application/octet-stream",
//         originalname: file.name,
//       },
//       name: {
//         am: file.name,
//         en: file.name,
//       },
//       recordContentId,
//     };

//     const response = await fetch(`${Record_API_URL}api/record-attachments`, {
//       method: "POST",
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//       body: JSON.stringify(requestBody),
//     });

//     if (!response.ok) {
//       throw new Error(`HTTP error! status: ${response.status}`);
//     }

//     const data = await response.json();

//     return data;
//   } catch (error) {
//     console.error("Error adding attachment:", error);
//     throw error;
//   }
// };

// export const UploadFile = async (
//   file: File,
//   uploadUrl: string | undefined | any
// ): Promise<void> => {
//   if (!uploadUrl) {
//     throw new Error("Upload URL is undefined.");
//   }
//   const uploadResponse = await fetch(uploadUrl, {
//     method: "PUT",
//     body: file,
//     headers: {
//       "Content-Type": file.type || "application/octet-stream",
//     },
//   });
//   if (!uploadResponse.ok) {
//     throw new Error(uploadResponse.statusText);
//   }
// };

// export const fetchAttachment = async (recordId: string): Promise<any> => {
//   try {
//     const response = await fetch(
//       `${Record_API_URL}api/records-attachments/${recordId}`,
//       {
//         method: "GET",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`,
//         },
//       }
//     );
//     if (!response.ok) {
//       throw new Error(response.statusText);
//     }
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error fetching attachments:", error);
//     return null;
//   }
// };

// export const deleteAttachment = async (attachmentId: string): Promise<any> => {
//   try {
//     const response = await fetch(
//       `${Record_API_URL}api/records-attachments/${attachmentId}`,
//       {
//         method: "DELETE",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`,
//         },
//       }
//     );
//     if (!response.ok) {
//       throw new Error(response.statusText);
//     }
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error deleting attachment:", error);
//     return null;
//   }
// };

// export const EditAttachment = async (
//   attachmentId: string,
//   attachmentData: any
// ): Promise<any> => {
//   try {
//     const response = await fetch(
//       `${Record_API_URL}api/records-attachments/${attachmentId}`,
//       {
//         method: "PUT",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`,
//         },
//         body: JSON.stringify(attachmentData),
//       }
//     );
//     if (!response.ok) {
//       throw new Error(response.statusText);
//     }
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error editing attachment:", error);
//     return null;
//   }
// };

// export const updateAttachmentStatus = async (
//   attachmentId: string | undefined | any,
//   parentId: string,
//   isUploaded: boolean
// ) => {
//   const uuidRegex =
//     /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

//   if (!uuidRegex.test(attachmentId)) {
//     throw new Error(`Invalid attachmentId format: ${attachmentId}`);
//   }

//   if (!uuidRegex.test(parentId)) {
//     throw new Error(`Invalid parentId format: ${parentId}`);
//   }

//   const response = await fetch(
//     `${Record_API_URL}api/record-attachments/${attachmentId}/upload-status`,
//     {
//       method: "PATCH",
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//       body: JSON.stringify({
//         id: attachmentId,
//         parentId,
//         uploadedSuccessfully: isUploaded,
//       }),
//     }
//   );

//   if (!response.ok) {
//     const error = await response.json();
//     throw new Error(error.message || "Status update failed");
//   }
// };

// export const updateIncomingAttachmentStatus = async (
//   recordId: string,
//   isUploaded: boolean
// ) => {
//   const response = await fetch(`${Record_API_URL}api/records/upload-status`, {
//     method: "PATCH",
//     headers: {
//       "Content-Type": "application/json",
//       Authorization: `Bearer ${getAuthToken()}`,
//     },
//     body: JSON.stringify({
//       recordId,
//       uploadedSuccessfully: isUploaded,
//     }),
//   });

//   if (!response.ok) {
//     const error = await response.json();
//     throw new Error(error.message || "Status update failed");
//   }
// };

// // export const fetchMe = async (): Promise<any> => {
// //   const res = await fetchWithAuth(`${API_URL}api/auth/me`);
// //   if (!res.ok) {
// //     const errorData = await res.json().catch(() => null);
// //     const message = errorData?.message || res.statusText;
// //     throw new Error(message);
// //   }
// //   return await res.json();
// // };

// // In Recordservice.ts
// export const fetchMe = async () => {
//   try {
//     // For cookie-based auth, you often don't need to manually set headers
//     const response = await fetch(`${API_URL}api/auth/me`, {
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//     });
//     return await response.json();
//   } catch (error) {
//     console.error("Error fetching user data:", error);
//     throw error;
//   }
// };
// export const changePassword = async (data: {
//   email: string;
//   verificationCode: string;
//   newPassword: string;
//   confirmPassword: string;
// }): Promise<any> => {
//   const res = await fetchWithAuth(`${API_URL}api/auth/change-password`, {
//     method: "PATCH",
//     headers: {
//       "Content-Type": "application/json",
//     },
//     body: JSON.stringify(data),
//   });

//   if (!res.ok) {
//     const errorData = await res.json().catch(() => null);
//     const message = errorData?.message || res.statusText;
//     throw new Error(message);
//   }

//   return await res.json();
// };

// export const requestPasswordReset = async (email: string): Promise<any> => {
//   const res = await fetchWithAuth(`${API_URL}api/auth/forgot-password`, {
//     method: "POST",
//     headers: {
//       "Content-Type": "application/json",
//     },
//     body: JSON.stringify({ email }),
//   });

//   if (!res.ok) {
//     const errorData = await res.json().catch(() => null);
//     const message = errorData?.message || res.statusText;
//     throw new Error(message);
//   }

//   return await res.json();
// };

// export const submitRecord = async (
//   recordId: string,
//   delegatorId?: string
// ): Promise<void> => {
//   try {
//     const response = await fetch(
//       `${Record_API_URL}api/records/submit/${recordId}`,
//       {
//         method: "PATCH",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`,
//           ...(delegatorId && { "x-delegator-id": delegatorId }),
//         },
//       }
//     );

//     if (!response.ok) {
//       const errorText = await response.text();
//       throw new Error(
//         `Failed to submit record: ${response.status} ${errorText}`
//       );
//     }

//     // No need to process the response body if it's a PDF
//   } catch (error) {
//     console.error("Error submitting record:", error);
//     throw error;
//   }
// };

// export const sendToRO = async (recordId: string): Promise<void> => {
//   try {
//     const response = await fetch(
//       `${Record_API_URL}api/outgoing-instances/send-to-ro/${recordId}`,
//       {
//         method: "PATCH",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`,
//         },
//       }
//     );

//     if (!response.ok) {
//       const errorBody = await response.json();
//       const errorMessage = errorBody.message || response.statusText;
//       throw new Error(errorMessage);
//     }

//     // No need to process the PDF or response body
//   } catch (error) {
//     console.error("Error sending to RO:", error);
//     throw error;
//   }
// };

// export const fetchApprovalTasks = async (): Promise<any> => {
//   try {
//     const response = await fetch(
//       `${Record_API_URL}api/outgoing-instances/my-workflows`,
//       {
//         method: "GET",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`,
//         },
//       }
//     );
//     if (!response.ok) {
//       throw new Error(response.statusText);
//     }
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error fetching approval tasks:", error);
//     throw error;
//   }
// };

// export const sendBack = async (body: any): Promise<any> => {
//   try {
//     const response = await fetch(
//       `${Record_API_URL}api/outgoing-instances/send-back-to-initiator`,
//       {
//         method: "POST",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`,
//         },
//         body: JSON.stringify(body),
//       }
//     );

//     if (!response.ok) {
//       throw new Error(response.statusText);
//     }

//     // Don't attempt JSON parsing if body is empty
//     const contentLength = response.headers.get("Content-Length");
//     if (contentLength === "0" || !contentLength) {
//       return null;
//     }

//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error sending back:", error);
//     throw error;
//   }
// };

// export const goToNext = async (body: any): Promise<void> => {
//   try {
//     const response = await fetch(
//       `${Record_API_URL}api/outgoing-instances/go-to-next`,
//       {
//         method: "POST",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`,
//         },
//         body: JSON.stringify(body),
//       }
//     );

//     if (!response.ok) {
//       const contentType = response.headers.get("content-type");
//       let errorMessage = response.statusText;

//       if (contentType?.includes("application/json")) {
//         const errorBody = await response.json();
//         errorMessage = errorBody.message || errorMessage;
//       } else if (contentType?.includes("text/plain")) {
//         const textBody = await response.text();
//         errorMessage = textBody || errorMessage;
//       }

//       throw new Error(errorMessage);
//     }

//     // No need to handle response body (PDF or JSON) — treat success as enough
//   } catch (error) {
//     console.error("Error going to next:", error);
//     throw error;
//   }
// };

// export const fetchToBeDispatched = async (): Promise<any> => {
//   const url = `${Record_API_URL}api/outgoing-instances/to-be-dispatched`;
//   const res = await fetchWithAuth(url);
//   return await res.json();
// };

// export const fetchSpecificToBeDispatched = async (
//   dispatchId: string
// ): Promise<any> => {
//   try {
//     const url = `${Record_API_URL}api/records/record-pdf/${dispatchId}`;
//     const res = await fetchWithAuth(url);
//     return await res.json();
//   } catch (error) {
//     console.error("Error going to next:", error);
//     throw error; // Re-throw the error to be handled by the caller
//   }
// };

// // Recordservice.ts
// export const fetchSeal = async (id: string): Promise<{ items: Seal[] }> => {
//   try {
//     const url = `${API_URL}api/seals/list/${id}`;
//     const res = await fetchWithAuth(url);

//     if (!res.ok) {
//       throw new Error(`HTTP error! status: ${res.status}`);
//     }

//     const data = await res.json();

//     if (!data?.items) {
//       throw new Error("Invalid response structure");
//     }

//     return data;
//   } catch (error) {
//     console.error("Error fetching seals:", error);
//     throw error;
//   }
// };

// export const fetchSealById = async (sealId: string): Promise<SealDetail> => {
//   try {
//     const url = `${API_URL}api/seals/${sealId}`;
//     const res = await fetchWithAuth(url);

//     if (!res.ok) {
//       throw new Error(`HTTP error! status: ${res.status}`);
//     }

//     const data = await res.json();

//     if (!data?.id) {
//       throw new Error("Invalid seal detail response");
//     }

//     return data;
//   } catch (error) {
//     console.error("Error fetching seal details:", error);
//     throw error;
//   }
// };

// export const dispatchRecord = async (body: any): Promise<any> => {
//   const url = `${Record_API_URL}api/outgoing-instances/dispatch`;

//   try {
//     const response = await fetchWithAuth(url, {
//       method: "PATCH",
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//       body: JSON.stringify(body),
//     });

//     const contentType = response.headers.get("Content-Type");

//     if (contentType?.includes("application/pdf")) {
//       const blob = await response.blob();
//       const pdfUrl = window.URL.createObjectURL(blob);
//       window.open(pdfUrl, "_blank");
//       return;
//     } else {
//       const contentLength = response.headers.get("Content-Length");
//       if (contentLength === "0" || response.status === 204) {
//         return;
//       }

//       if (contentType?.includes("application/json")) {
//         const data = await response.json();
//         return data;
//       }

//       return;
//     }
//   } catch (error) {
//     console.error("Error going to next:", error);
//     throw error;
//   }
// };

// export const submitAndSendToRo = async (recordId: string): Promise<any> => {
//   try {
//     const url = `${Record_API_URL}api/records/submit-and-send-to-ro/${recordId}`;
//     const response = await fetchWithAuth(url, {
//       method: "PATCH",
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//     });

//     if (!response.ok) {
//       const errorBody = await response.json();
//       throw new Error(errorBody.message || "Failed to submit and send to RO.");
//     }

//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error submitting and sending to RO:", error);
//     throw error;
//   }
// };

// export const fetchCCIncomingRecord = async () => {
//   try {
//     const url = `${Record_API_URL}api/records/cc-incoming-record`;
//     await fetchWithAuth(url, {
//       method: "GET",
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//     });
//   } catch {
//     return null;
//   }
// };

// export const reassigneRecord = async (
//   body: ReAssignRecordDto
// ): Promise<any> => {
//   try {
//     const url = `${Record_API_URL}api/incoming-instances/re-assign`;
//     const response = await fetchWithAuth(url, {
//       method: "POST",
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//       body: JSON.stringify(body),
//     });
//     if (!response.ok) {
//       const errorBody = await response.json();
//       throw new Error(errorBody.message || "Failed to reassign record");
//     }
//     const data = await response.json();
//     return data;
//   } catch {
//     return null;
//   }
// };

// export const acceptRecord = async (
//   body: AcceptIncomingRecordDto
// ): Promise<any> => {
//   try {
//     const url = `${Record_API_URL}api/incoming-instances/respond`;
//     const response = await fetchWithAuth(url, {
//       method: "PATCH",
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//       body: JSON.stringify(body),
//     });
//     if (!response.ok) {
//       const errorBody = await response.json();
//       throw new Error(errorBody.message || "Failed to reassign record");
//     }
//     const data = await response.json();
//     return data;
//   } catch {
//     return null;
//   }
// };

// export const fetchCurrentDepartment = async (
//   organizationUnitId: string
// ): Promise<any> => {
//   try {
//     const url = `${API_URL}api/units/current/${organizationUnitId}/employees`;
//     const response = await fetchWithAuth(url, {
//       method: "GET",
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//     });
//     if (!response.ok) {
//       const errorBody = await response.json();
//       throw new Error(errorBody.message || "Failed to get current department");
//     }
//     const data = await response.json();
//     return data;
//   } catch {
//     return null;
//   }
// };

// export const getMovementSlip = async (recordId: string): Promise<any> => {
//   try {
//     const url = `${Record_API_URL}api/incoming-instances/movement-slip/${recordId}`;
//     const res = await fetchWithAuth(url);
//     if (!res.ok) {
//       const errorBody = await res.json();
//       throw new Error(errorBody.message || "Failed to get movement slip");
//     }
//     const data = await res.json();
//     return data;
//   } catch {
//     return null;
//   }
// };

// export const getRemarks = async (recordId: string): Promise<any> => {
//   try {
//     const url = `${Record_API_URL}api/outgoing-histories/record-outgoing-history/${recordId}`;
//     const res = await fetchWithAuth(url);
//     if (!res.ok) {
//       const errorBody = await res.json();
//       throw new Error(errorBody.message || "Failed to get remarks");
//     }
//     const data = await res.json();
//     return data;
//   } catch {
//     return null;
//   }
// };

// export const createIncoming = async (body: any): Promise<any> => {
//   try {
//     const url = `${Record_API_URL}api/records/non-smart-record-pdf`;
//     const res = await fetchWithAuth(url, {
//       method: "POST",
//       headers: {
//         "Content-Type": "application/json",
//       },
//       body: JSON.stringify(body),
//     });
//     if (!res.ok) {
//       const errorBody = await res.json();
//       throw new Error(errorBody.message || "Failed to create incoming");
//     }
//     const data = await res.json();
//     return data;
//   } catch {
//     return null;
//   }
// };

// export const getTemplate = async (unitId: string): Promise<any> => {
//   try {
//     const url = `${Record_API_URL}api/record-templates/list/${unitId}`;
//     const res = await fetchWithAuth(url);
//     if (!res.ok) {
//       const errorBody = await res.json();
//       throw new Error(errorBody.message || "Failed to get template");
//     }
//     const data = await res.json();
//     return data;
//   } catch {
//     return null;
//   }
// };

// export const getRecordIncoming = async (): Promise<any> => {
//   try {
//     const url = `${Record_API_URL}api/record-boxes/my-unit-box`;
//     const res = await fetchWithAuth(url);
//     if (!res.ok) {
//       const errorBody = await res.json();
//       throw new Error(errorBody.message || "Failed to get record incoming");
//     }
//     const data = await res.json();
//     return data;
//   } catch {
//     return null;
//   }
// };
// export const dispatchRecord2 = async (): Promise<any> => {
//   try {
//     const response = await fetch(
//       `${Record_API_URL}api/outgoing-instances/dispatched`,
//       {
//         method: "GET",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`, // Uncomment if you need to use the token
//         },
//       }
//     );
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error fetching records:", error);
//     return null;
//   }
// };
// export const incomingRecords = async (): Promise<any> => {
//   try {
//     const response = await fetch(
//       `${Record_API_URL}api/record-boxes/my-unit-box`,
//       {
//         method: "GET",
//         headers: {
//           "Content-Type": "application/json",
//           Authorization: `Bearer ${getAuthToken()}`, // Uncomment if you need to use the token
//         },
//       }
//     );
//     const data = await response.json();
//     return data;
//   } catch (error) {
//     console.error("Error fetching records:", error);
//     return null;
//   }
// };
// export const assignIncomingRecord = async (
//   body: AssignIncomingRecordDto
// ): Promise<any> => {
//   try {
//     const url = `${Record_API_URL}api/record-boxes/assign`;
//     const response = await fetchWithAuth(url, {
//       method: "POST",
//       headers: {
//         "Content-Type": "application/json",
//         Authorization: `Bearer ${getAuthToken()}`,
//       },
//       body: JSON.stringify(body),
//     });
//     if (!response.ok) {
//       const errorBody = await response.json();
//       throw new Error(errorBody.message || "Failed to reassign record");
//     }
//     const data = await response.json();
//     return data;
//   } catch {
//     return null;
//   }
// };
