import { getAxiosClient } from "./client";
import axios from "axios";
import { UseAccessToken } from "@/utils/conditions/getAccessToken";
const IP_BASE_URL = process.env.NEXT_PUBLIC_API_BASE_URL;
export const apiUrl = `${process.env.NEXT_PUBLIC_API_BASE_URL}/api/v1/carriers/records`;
type PasswordResetLink = {
  port_id: any;
  lat: any;
  lng: any;
  email: string;
  user_type: string;
};
export async function sendResetPasswordLink(payload: PasswordResetLink) {
  try {
    const client = getAxiosClient(null);
    const response = await client.post("/api/v1/forget-password", {
      email: payload.email,
      user_type: payload.user_type,
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function sslPost(payload: any,token) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/ssl/create", {
      name: payload?.sslName,
      ssac_code: payload?.ssacCode,
      abbreviation: payload?.abbreviatedName
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

export async function MarketPost(payload: any, token:any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/market/create", {
      state_id: payload?.stateId,
      country_id: payload?.countryId,
      name: payload?.city,
      zip: payload?.zip,
      lat: payload?.latitude,
      lng: payload?.longitude
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function UpdateMarket(payload: any, token: any) {
  
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/market/update", {
      id: payload?.id,
      state_id: payload?.stateId,
      country_id: payload?.countryId,
      name: payload?.city,
      zip: payload?.zip,
      lat: payload?.latitude,
      lng: payload?.longitude
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}


export async function TerminalPost(payload: any, token: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/terminal/create/or/update", {
      id: payload?.id || [], 
      country_id: payload?.country_id || [],
      state_id: payload?.state_id|| [],
      port_id: payload?.port_id || [],
      name: payload?.name || [],
      type: payload?.type || [],
      lat: payload?.lat || [],
      lon: payload?.lon || [],
      address: payload?.Address || [],
      zip_code: payload?.zip|| []
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}



export async function sslEditPost(payload: any, token) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/ssl/update", {
      name: payload?.sslName,
      ssac_code: payload?.ssacCode,
      abbreviation: payload?.abbreviatedName,
      id:payload?.id,
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function inActivePost(payload: any, token:any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/ssl/mass/status/change", {
      id: payload?.id,
      status: payload?.status,
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function inActivePostMarket(payload: any, token: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/market/mass/status/change", {
      id: payload?.id,
      status: payload?.status,
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function FallBackUpload(token:any,payload: PasswordResetLink) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/fallback/create/or/update",payload);
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
//FallBack Table Delete
export async function FallBackDelete(token: any, payload: PasswordResetLink) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/fallback/delete", payload);
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

export async function  FallBack(token: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = "/api/v1/fallback/index";
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
  
}

export async function CountryListing(token: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = "/api/v1/country/listing";
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }

}
export async function StateListing(countryId: number, token: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = `/api/v1/state/listing?country_id=${countryId}`;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function MarketListing(stateId: number, token: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = `/api/v1/market/listing?state_id=${stateId}`;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}




export async function CloseRateData(id: PasswordResetLink, accessToken:any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/basic/customer/rate/close", {
      rate_id: id,
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function GetAccesorCustomerAmount(
  token,
  code: PasswordResetLink,
  carrierId: any,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/accessorial-amount", {
      accessorial_charges_code: [code],
      carrier_id: [carrierId],
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function CheckOut(
  token:any,
  plan:any
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/checkout", {
      plan_name: plan,
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

export async function GetallAccesorCustomerAmount(
  token,
  code: PasswordResetLink,
  carrierId: any,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/accessorial-amount", {
      accessorial_charges_code: code,
      carrier_id: [carrierId],
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

type ResetPassword = {
  password: string;
  reset_token: string;
  user_type: string;
  username: string;
  password_confirmation: string;
  confirm_password: string;
};
export async function resetPassword(payload: ResetPassword) {
  try {
    const client = getAxiosClient(null);
    const response = await client.post("/api/v1/reset-password", {
      password: payload.password,
      token: payload.reset_token,
      user_type: payload.user_type,
      username: payload.username,
      password_confirmation: payload.confirm_password,
    });
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

export async function addCost(
  token: token,
  payload,
  ids: ids,
  accessorials: accessorials,
  accessorial_others: any,
  customerNotes: any,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);

    const response = await client.post(
      `/api/v1/customers/add-accessorial-charge/${ids}`,
      {
        rate_id: payload.rate_id,
        linehaul: payload?.linehaul,
        fsc: payload?.fuelSurcharge,
        chassis: payload?.chassiss,
        accessorials: accessorials,
        email: payload?.emailsArray,
        lead: payload?.lead,
        estimated_total: payload?.estimatedCost,
        gross_margin: payload?.grossValue,
        accessorial_others: accessorial_others,
        customer_notes: customerNotes
      },
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

type CustomerSignUp = {
  from_state: any;
  parent_id: any;
  FormState: any;
  FormCity: any;
  business_phone: any;
  state: any;
  city: any;
  company_name: string;
  first_name: string;
  last_name: string;
  email: string;
  dot_number: number;
  billing_address: string;
  current_address: string;
  password: string;
};
type ClientCreate = {
  name: any;
  zip_code: any;
  from_state: any;
  client_type: any;
  invite_client_email: any;
  parent_id: any;
  FormState: any;
  FormCity: any;
  business_phone: any;
  state: any;
  city: any;
  company_name: string;
  first_name: string;
  last_name: string;
  email: string;
  dot_number: number;
  billing_address: string;
  current_address: string;
  password: string;
};
export async function customerSignUp(payload: CustomerSignUp) {
  
  try {
    const client = getAxiosClient(null);
    const response = await client.post("/api/v1/register-customer", {
      company_name: payload.company_name,
      first_name: payload.first_name,
      last_name: payload.last_name,
      email: payload.email,
      dot_number: payload.dot_number,
      billing_address: payload.billing_address,
      current_address: payload.current_address,
      password: payload.password,
      business_phone: payload.business_phone,
      state: payload.state,
      city: payload.city,
      parent_id: payload?.parent_id,
      from_state: payload?.from_state,
      city: payload?.city,
    });
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function clientCreate(payload: ClientCreate) {  
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/client/create", {
      company_name: payload.company_name,
      name: payload.name,
      zip_code: payload.zip_code,
      email: payload.email,
      dot_number: payload.dot_number,
      billing_address: payload.billing_address,
      current_address: payload.current_address,
      password: payload.password,
      mc_number: payload?.mc_number,
      business_phone: payload.business_phone,
      address: payload.address,
      phone: payload.phone,
      state: payload.state,
      scac_code: payload.scac_code,
      website: payload.website,
      city: payload.city,
      market: payload.market,
      state: payload.state,
      terminal_id: payload.terminal_id,
      parent_id: payload?.parent_id,
      from_state: payload?.from_state,
      city: payload?.city,
      client_type: payload?.client_type,
      invite_client_email: payload?.invite_client_email,
      fmcsa_data: payload?.fmcsa_data
    });
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function clientCreate1(payload: ClientCreate) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/client/create", {
      company_name: payload.company_name,
      first_name: payload.first_name,
      last_name: payload.last_name,
      email: payload.email,
      dot_number: payload.dot_number,
      billing_address: payload.billing_address,
      current_address: payload.current_address,
      password: payload.password,
      business_phone: payload.business_phone,
      state: payload.state,
      website: payload.company_website,
      city: payload.city,
      parent_id: payload?.parent_id,
      from_state: payload?.from_state,
      city: payload?.city,
      client_type: payload?.client_type,
      invite_client_email: payload?.invite_client_email,

    });
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
type EmailVerificationPayload = {
  token: string;
};
export async function verifyEmailAddress(payload: EmailVerificationPayload) {
  try {
    const client = getAxiosClient(null);
    const endpoint = "/api/v1/account/verify/" + payload.token;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function CsvData(payload: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = `/api/v1/carrier-accessorials/${payload}`;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function carrierSignUp(payload: any) {
  try {
    const client = getAxiosClient(null);
    const response = await client.post("/api/v1/register-carrier", payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

type TokenType = string | null | undefined;
type PAYLOAD = any;
export async function getAuthUser(token: TokenType) {
  try {
    const client = axios.create({
      baseURL: IP_BASE_URL,
    });
    client.interceptors.request.use((config: any) => {
      config.headers["Content-Type"] = "application/json";
      config.headers["Accept"] = "application/json";
      config.headers["Authorization"] = `Bearer ${token}`;
      return config;
    });
    const STAGING_PATH = process.env.NEXT_STAGING_DIR_PATH || '';
    const response = await client.get(
      `${STAGING_PATH}/api/v1/get_auth_user`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}


export async function getCarrierIds(Token: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      "/api/v1/customers/my_favorite/carrier_ids",
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getPermissions(Token: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      "/api/v1/user/all/permission",
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getStates() {
  try {
    const client = getAxiosClient(null);
    const response = await client.get("/api/v1/us-and-canada-states");
    if (Array.isArray(response?.data?.data)) {
        response.data.data.sort((a: { state_name: string }, b: { state_name: string }) => 
            a.state_name.localeCompare(b.state_name)
        );
    } else {
        throw new Error("Invalid response format: Expected an array of states.");
    }
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getArrMarket() {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get("/api/v1/all/market");
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function UpdateCordinatesstate(state_code: STATE_CODE) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `api/v1/find-ports?state_code=${state_code}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function UpdateCordinatesstatePorts(
  state_code: STATE_CODE,
  port_id: getiddata,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `api/v1/find-ports?state_code=${state_code}&port_name=${port_id}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function dotVerify(dotNumber: undefined) {
  try {
    const client = getAxiosClient(null);
    const response = await client.get(
      `${process.env.NEXT_PUBLIC_FMGCA}/carriers/${dotNumber}?webKey=${process.env.NEXT_PUBLIC_RMS_WEB_KEY}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function McVerify(dotNumber: undefined) {
  try {
    const client = getAxiosClient(null);
    const response = await client.get(
      `${process.env.NEXT_PUBLIC_FMGCA}/carriers/docket-number/${dotNumber}?webKey=${process.env.NEXT_PUBLIC_RMS_WEB_KEY}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function McFmcVerify(dotNumber: undefined) {
  try {
    const client = getAxiosClient(null);
    const response = await client.get(
      `${process.env.NEXT_PUBLIC_FMGCA}/carriers/${dotNumber}/docket-numbers?webKey=${process.env.NEXT_PUBLIC_RMS_WEB_KEY}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getGlobalCoordinates() {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`api/v1/carriers/records`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getCountries() {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get("/api/v1/countries");
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getCities(state: string) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/carrier-cities?state_code=${state}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getCarries(token: any, pageno: any, query: string,state:any,market:any) {
 
  let p = {
    "state": state?state:[], "market": market?market:[]
  }
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`api/v1/carriers/records?page=${pageno}&${query}`, {
      params: p
    });
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getSsl(token: any, pageno: any, query: string, event:any) {
  
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`api/v1/ssl?status=${event}&page=${pageno}&${query}`, );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getManagedMarket(token: any, pageno: any, query: string, event: any) {

  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/market/index?status=${event}&page=${pageno}&${query}`,);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getCarriesList(token: any, pageno: any, query: string) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `api/v1/carriers/customer/listing?page=${pageno}&${query}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getprofiletrack(token: any, pageno: any, query: string, item: any) {

  
  if (item) {
    try {
      const accessToken = await UseAccessToken();
      const client = getAxiosClient(accessToken);
      const response = await client.get(
        `/api/v1/blocked/or/favorite/${item}?page=${pageno}&${query}`
      );
      return response.data;
    } catch (error: any) {
      return {
        ...error.response?.data,
        status_code: error.response?.status,
      };
    }
  }
  else {
    try {
      const accessToken = await UseAccessToken();
      const client = getAxiosClient(accessToken);
      const response = await client.get(
        `api/v1/track/profile?page=${pageno}&${query}`,
      );
      return response.data;
    } catch (error: any) {
      return {
        ...error.response?.data,
        status_code: error.response?.status,
      };
    }
  }
}
export async function getCarriesFav(token: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/carriers/records?page=1&carrier_name=&state=%20&market=&terminal=&haz=&bonded=&chassis=&transload=&parking=&size=&height=&my_carrier_list=${1}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function CarriesCordinates() {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get("api/v1/find-ports");
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getPortQuotes(access_token: string) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/carriers/find-ports`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getTerminals(payload: string) {
  try {
    const client = getAxiosClient(payload);
    const response = await client.post(`/api/v1/terminals`, payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function MapFilter(payload: string) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`/api/v1/carrier/map/filter`, {
      state: payload,
    });
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function DownloadRecord(token: string,payload:any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`/api/v1/carrier/download`, {
      userIds: payload, 
    });
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}


export async function adminUser(payload: string,token:any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`/api/v1/make/admin`, payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getDashboardTerminals(token: string, payload: string) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`/api/v1/terminals`, payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getDashboardCreateTerminals(token: any, payload: any) {
  try {

    if (Array.isArray(payload?.market) && payload.market.length === 0) {
      return {
        status: "error",
      };
    }

    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`/api/v1/terminals?status=${1}`, payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function voidRates(access_token: string, id: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.delete(`/api/v1/delete-quote/${id}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getPortupdateQuotesMarket(
  access_token: string,
  name: null,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/find-ports?market=${name}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getcarrierbyid(access_token: TokenType, id: any) {
  try {
    if (!id) {
      return {
        status: "error"
      }
    }
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/carriers/details/${id}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function updateRate(token: TokenType, payload: PAYLOAD, id: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.put(
      `/api/v1/update-drayage-quote/${id}`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function storeViewlog(token: TokenType, load: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`/api/v1/carrier/log/store`, load);

    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}


export async function powerUnitUpdate(token: TokenType, load: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`/api/v1/driver/powerunit/update`, load);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getPorts() {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get("/api/v1/ports");
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getCreatePorts() {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/ports?status=${1}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getDrayageSpotRateQuotes(access_token: any, id: any) {
  try {
    if (id === null || id === undefined || id === '') {
      return {
        status: "error"
      };
    }
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/get-drayage-spot-rate-quotes/${id}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

export async function SpotRateQuoteDetails(
  token: TokenType,
  id: any,
  payload: PAYLOAD,
) {
  try {
    if (id === null || id === undefined || id === '' || payload === null || payload === undefined || payload === '') {
      return {
        status: "error"
      };
    }
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/spot-rate-quotes-details/${id}`,
      {
        rate_id: payload,
      },
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function DeleteRate(token: TokenType, id: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`/api/v1/delete/rate`, {
      rate_id: id,
    });
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getPortsby(code: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/ports?state_code=${code}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function deleteid(token: any, id: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response =
      await client.delete(`/api/v1/customers/delete/accessorial/${id}
`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getMarket(payload: any) {
  try {
    if (
        !payload?.state_code ||
        !Array.isArray(payload.state_code) ||
        payload.state_code.length === 0 ||
        (Array.isArray(payload.state_code[0]) && payload.state_code[0].length === 0)
      ) {
        return {
          status: "error"
        };
    }
    const client = getAxiosClient(null);
    const response = await client.post("/api/v1/market", payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function MarketingGet(payload: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get("/api/v1/market/listing", payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getMapCarriers(
  token: TokenType,
  dot: any,
  market: any,
  terminal: any,
) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/carriers-for-map?search=${dot}&market=${market}&terminal_id=${terminal}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function ratesServices(token: TokenType) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get("api/v1/accessorial-charges");
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getChildCustomer(
  access_token: string,
  pageno: any,
  query: string,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/customers/child/listing?page=${pageno}&${query}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getChildAssociateCustomer(
  access_token: string,
  pageno: any,
  query: string,
  id
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/child/user/listing?page=${pageno}&${query}`, id,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function updateActive(
  access_token: string,
  id:any
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/user/status/change`, id,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function updateUserName(
  access_token: string,
  id: any
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/send/username`, id,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function updatePassword(
  access_token: string,
  id: any
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/password/reset/link`, id,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function AllClient(
  access_token: string,
  pageno: any,
  query: string,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/all/client?page=${pageno}&${query}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getRateQuotes(
  access_token: string,
  pageno: any,
  query: string,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/get-drayage-quotes?page=${pageno}&${query}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function CarrierTableAll(
  access_token: string,
  pageno: any,
  query: string,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/find-rates?page=${pageno}&${query}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function CarrierTableFindAll(
  access_token: string,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/quote/ids/exculde`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function CustomerTableAll(
  access_token: string,
  pageno: any,
  query: string,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/carriers/customer/listing`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function updateTheme(
  token: TokenType,
  payload: { theme: string },
) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/users/update-theme", {
      theme: payload.theme,
    });
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function CustomerAddToMyFavroutes(token: any, id: any,key:any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/customers/add-to-carriers", {
      carrier_id: id,
      is_favorite:key,
    });
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function CustomerRemoveBlock(token: any, id: any) {
  try {
    const carrier_id = id;
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const payload = {
      carrier_id: carrier_id,
    };

    const response = await client.post(
      `/api/v1/customers/carrier/block`,
      payload,
    );
    return response.data;
  } catch (error) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function AddRatesNotificationCarrier(token: TokenType, payload: PAYLOAD) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      "/api/v1/add/or/select/rate/notification",
      payload,
      
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function AddRatesNotification(token: TokenType, payload: PAYLOAD) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      "/api/v1/add/rate/notification",
      payload,
      
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
//
export async function AddSpotRates(token: TokenType, payload: PAYLOAD) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      "/api/v1/add-carrier-spot-rate",

      {
        carrier_name: payload.carrier_name,
        carrier_id: payload.carrier_id,
        quote_id: payload.quote_id,
        linehaul: payload.linehaul,
        fsc: payload.fsc,
        chassis: payload.chassis,
        accessorial_name: payload.accessorial_name,
        accessorial_cost: payload.accessorial_cost,
        accessorial_charges_code: payload.accessorial_charges_code,
        per_day: payload?.per_day,
        required_for_move: payload.required_for_move,
        has_capacity: payload?.has_capacity,
        earliest_capacity: payload?.earliest_capacity,
        rate_notes: payload?.rate_notes,
        accessorial_others: payload?.others
      },
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function FindPorts(token: TokenType, state_code: PAYLOAD) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `draydex_rms_api/public/api/v1/carriers/find-ports=${state_code}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getSpotRageAvg(token: TokenType, queryString: string) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/spot-rate-avg?${queryString}`);

    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getDayoutAvg(token: TokenType, queryString: string) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/day-out-avg?${queryString}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function CarrierMapForSendToCarrier(token: TokenType) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/carriers-for-map`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function SendCarriers(
  access_token: AccessToken,
  payload: PAYLOAD,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/carriers/send-mail", payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getFavCarriersStatus(
  access_token: AccessToken,
  payload: PAYLOAD,
  id: id,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get("/api/v1/customers/email/sent/status", {
      params: {
        carrier_id: payload,
        quotes_id: id,
      },
    });
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

// export async function  carrirsDataInfoMap(access_token: TokenType, id: any) {
//   try {
//     const accessToken = await UseAccessToken();
//    const client = getAxiosClient(accessToken);
//     const response = await client.get(`/api/v1/carriers/details/${id}`);
//     return response.data;
//   } catch (error: any) {
//     return {
//       ...error.response?.data,
//       status_code: error.response?.status,
//     };
//   }
// }

// export async function getcarrierbyid(access_token: TokenType, id: any) {
//   try {
//     const accessToken = await UseAccessToken();
//    const client = getAxiosClient(accessToken);
//     const response = await client.get(`/api/v1/carriers/details/${id}`);
//     return response.data;
//   } catch (error: any) {
//     return {
//       ...error.response?.data,
//       status_code: error.response?.status,
//     };
//   }
// }

export async function GetHazClasses() {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/haz-classes`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function CustomersDieselprice(
  accessToken: string | null | undefined,
  id: any,
) {
  try {
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/carriers/get-fsc-percent/${id}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function CarrierDieselprice(
  accessToken: string | null | undefined,
) {
  try {
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/carriers/diesel-price`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function StreamLineSsl(token: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/ssls?status=${1}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function CustomerLead(token: any, queryid: any) {
  try {
    if(queryid === null || queryid === undefined || queryid === 'undefined' || queryid === ''){
      return;
    }
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/customers/child/all/${queryid}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function RoundTrip(payload: PasswordResetLink, token: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/round-trip", {
      port_id: payload?.port_id,
      lat: payload?.lat,
      lng: payload?.lng,
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

export async function getLog(token: any, id: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/carrier/log/details/${id}`, {});
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function Updatecarrier(payload: any, token: any, id: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/carriers/update/carrier/data/${id}`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function getStateMarket(token: any, id: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/carriers/state/data/${id}`, {});
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

export async function getAllUserList(
  access_token: null,
  pageno: any,
  query: string,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/all/customer/type?page=${pageno}&${query}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function addFavourite(token: any, payload: PasswordResetLink) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/carriers/add/my-carrier", {
      carrier_ids: payload,
    });
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

/* This function is used to get all claim listing */
export async function getAllClaimRequestList(
  access_token: string,
  pageno: any,
  query: string,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/innactive/carriers?page=${pageno}&${query}`,
      {},
    );
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

export async function getAllCancelRequestList(
  access_token: string,
  pageno: any,
  query: string,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/subscriptions/cancel/request?page=${pageno}&${query}`,
      {},
    );
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function roundTrip(token: any, payload: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`/api/v1/round-trip`, payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

/* This function is used to accept claim */
export async function toAcceptClaimRequest(payloadObj: any, token) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/claim/accepted", payloadObj);
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function toAcceptCancelRequest(payloadObj: any, token) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/subscriptions/cancel", payloadObj);
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

export async function close(token: any, payload: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`/api/v1/close/and/send`,payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

/* This function is used to reject claim */
export async function toRejectClaimRequest(token: any, payloadObj: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/claim/rejected", payloadObj);
    return response?.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function toRejectCancelRequest(token: any, payloadObj: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post("/api/v1/cancel/request/rejected", payloadObj);
    return response?.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
/* This function is used to get role wise permission list */
export async function getRoleWisePermissionList(dataObj: any) {
  try {
    const client = getAxiosClient(dataObj.access_token);
    const response = await client.get(
      `/api/v1/role/wise/permission/${dataObj.role_id}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

/* This function is used for to claim user profile */
export async function toClaimUserProfileRequest(user_id: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/innactive/carrier/details/${user_id}`,
    );
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

export async function ClaimUsers(payload: any) {
  try {
    const client = getAxiosClient();
    const response = await client.post(
      `/api/v1/search/innactive/carriers`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function ClaimUsersEmail(payload: any) {
  try {
    const client = getAxiosClient();
    const response = await client.post(
      `/api/v1/claim/innactive/carriers`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function addContact(payload: any, token: any, id: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.put(
      `/api/v1/carriers/add-contact/${payload?.user_id}`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
export async function AddAdditionalContact(payload: any, token: any, id: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/customers/add-contact/${id}`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getCarrierContactInformation(
  access_token: AccessToken,
  ID: ID,
) {
  try {
    if (!ID) {
      return;
    }
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/carriers/get-contact/${ID}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

/* For delete contact */
export async function toDeleteContactName(
  access_token: AccessToken,
  ID: ID,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/delete/contact/${ID}`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}
/* This function is used to update user role */
export async function toUpdateUserRole(payload: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(`api/v1/assign/role/to/user`, payload);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function getFuelPrice(access_token: AccessToken, ID: ID) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(`/api/v1/carriers/diesel-price`);
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

export async function toSendForgotUsername(payloadObj: any) {
  try {
    const client = getAxiosClient(null);
    const response = await client.post("/api/v1/forget/username", payloadObj);
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

/* This is used for verify unsubscribe token  */
export async function verifyUnsubscribeToken(payload: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint =
      "/api/v1/carrier/unsubscribe/" +
      payload.token +
      "/" +
      payload.type +
      "/" +
      payload.id;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function getLogo(id: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = `/api/v1/carriers/logo/${id}`;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
/* This function is used to get Role Listing */
export async function getAllUserRoleList(
  access_token: null,
  pageno: any,
  query: string,
) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.get(
      `/api/v1/role/listing?page=${pageno}&${query}`,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
export async function getId() {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = `/api/v1/innactive/carrier/ids`;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}
/* This is used for unsubscribe carrier rate request via email */
export async function toUnsubscribeEmail(payloadObj: any, token: any) {
  try {
     const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = "/api/v1/carriers/subscribe";
    const response = await client.post(endpoint, payloadObj);
    return response?.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

/* This function is used to update user role */
export async function toRoleAssignPermission(payload: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/role/assign/permission`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

/* This function is used to delete terminal */
export async function toTerminalDeleteStatus(payload: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/terminal/status/change`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

/* This function is used to get inactive terminal list */
export async function toGetInactiveTerminalRecord(pageno: number, query: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = `/api/v1/inactive/terminals?page=${pageno}&${query}`;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

/* This function is used to restore terminal */
export async function toTerminalRestoreStatus(payload: any) {
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/terminal/mass/status/change`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

/* This function is used to change password */
export async function toChangeAdminPassword(payload: any){
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/change-password`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

/* This function is used to get sub-user list */
export async function toGetSubUserSalesList(payload: any){
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = `/api/v1/requestedby/${payload?.ownerId}`;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

/* This function is used to get version and commit details */
export async function toGetVersionDetails(){
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = `/api/v1/version`;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

/* This function is used to get table header field*/
export async function toGetTableColumnData(payload: any){
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const endpoint = `/api/v1/column/index?listing_name=${payload?.requestType}`;
    const response = await client.get(endpoint);
    return response.data;
  } catch (error: any) {
    return {
      ...error?.response?.data,
      status_code: error?.response?.status,
    };
  }
}

/* This function is used to update table header columns */
export async function toUpdateTableHeaderColumns(payload: any){
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/column/update`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

/* This fuction is used to rest table header columns */
export async function toResetTableHeaderColumns(payload: any){
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/column/index/reset`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}

/* This function is used to update accessorial data */
export async function toUpdateAccessorialsData(payload: any){
  try {
    const accessToken = await UseAccessToken();
    const client = getAxiosClient(accessToken);
    const response = await client.post(
      `/api/v1/special/service/update`,
      payload,
    );
    return response.data;
  } catch (error: any) {
    return {
      ...error.response?.data,
      status_code: error.response?.status,
    };
  }
}