import axiosInstance from '@/utills/axiosInstance';
import { notification } from 'antd';

export async function getAllLeads(filter: any, tabKey: string): Promise<any> {
  try {
    const response = await axiosInstance.get(`/api/v1/leads?tab_key=${tabKey}`, {
      params: {
        page: filter.page,
        pageSize: filter.pageSize,
        project_id: filter.project_id,
        locality_id: filter.locality_id,
        search: filter.search,
        sortColumn: filter.sortColumn,
        sortOrder: filter.sortOrder,
        created_by: filter.created_by,
        launch_id: filter.launch_id,
        // status_id: filter.status_id?.join(','),
        ...(Array.isArray(filter.status_id) && filter.status_id.length > 0
        ? { status_id: filter.status_id.join(',') }
        : {}),
        whats_your_tentative_budget_: filter.whats_your_tentative_budget_,
        which_configuration_you_are_looking_for_:
                    filter.which_configuration_you_are_looking_for_,
        start_date: filter.start_date,
        end_date: filter.end_date,
        lead_user_role_name: filter.lead_user_role_name,
        lead_user_id: filter.lead_user_id,
        lead_user_city_id: filter.lead_user_city_id,
        veiw_data: filter.veiw_data,
        isNRI: filter.isNRI,
        source: filter.source,
        tag: filter.tag,
        is_transferred: filter.is_transferred,
        ...(Array.isArray(filter.status_history) && filter.status_history.length > 0
        ? { status_history: filter.status_history.join(',') }
        : {}),
      },
    });
    if (response !== undefined) {
      return response.data;
    } else {
      throw new Error('Failed to fetch Users');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error.message,
    });
    throw error;
  }
}
// Function for API call to get Today Follow Up Leads
export async function getAllTodayFollowUpLeads(tabKey: string): Promise<any> {
  try {
    const response = await axiosInstance.get(`/api/v1/leads/today-follow-up-leads?tab_key=${tabKey}`, {
      params: {
        sortColumn: 'follow_up_date',
        sortOrder: 'asc',
      },
    });
    if (response !== undefined) {
      return response.data;
    } else {
      throw new Error('Failed to fetch Today Follow up Leads');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error.message,
    });
    throw error;
  }
}

export async function getLeadsCalendar(filter: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/leads/leads/calendar', {
      params: {
        start_date: filter.start_date,
        end_date: filter.end_date,
        project_id: filter.project_id,
        launch_id: filter.launch_id,
        status_id: filter.status_id == 0 ? null : filter.status_id,
        lead_user_role_name: filter.lead_user_role_name,
        lead_user_id: filter.lead_user_id,
        lead_user_city_id: filter.lead_user_city_id,
        veiw_data: filter.veiw_data,
        tab_key: filter.tab_key,
      },
    });
    if (response !== undefined) {
      return response;
    } else {
      throw new Error('Failed to fetch Calendar');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error.message,
    });
    throw error;
  }
}
export async function getActiveLeads(filter: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/all-leads?', {
      params: {
        page: filter.current_page,
        pageSize: filter.per_page,
        username: filter.filters?.username,
        sort: filter.sort,
        status: filter.filters?.status,
      },
    });

    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('failed to fetch active leads');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export async function getOverDueLeads(filter?: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/overdue', {
      params: {
        page: filter.current_page,
        pageSize: filter.per_page,
        username: filter.filters?.username,
        sort: filter.sort,
        status: filter.filters?.status,
      },
    });

    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch overdue leads');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export async function getScheduledLeads(filter?: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/scheduled', {
      params: {
        page: filter.current_page,
        pageSize: filter.per_page,
        username: filter.filters?.username,
        sort: filter.sort,
        status: filter.filters?.status,
      },
    });

    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch scheduled leads');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export async function getVisitedDetail(filter?: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/visitedleads', {
      params: {
        page: filter.current_page,
        pageSize: filter.per_page,
        username: filter.filters?.username,
        sort: filter.sort,
        status: filter.filters?.status,
      },
    });

    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch visited leads');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export async function geToken(filter?: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/tokenLeads', {
      params: {
        page: filter.current_page,
        pageSize: filter.per_page,
        username: filter.filters?.username,
        sort: filter.sort,
        status: filter.filters?.status,
      },
    });

    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch token ');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export async function getBookedLeads(filter?: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/bookedLeads', {
      params: {
        page: filter.current_page,
        pageSize: filter.per_page,
        username: filter.filters?.username,
        sort: filter.sort,
        status: filter.filters?.status,
      },
    });

    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch booked leads');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export async function getDeadLeads(filter?: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/deadleads', {
      params: {
        page: filter.current_page,
        pageSize: filter.per_page,
        username: filter.filters?.username,
        sort: filter.sort,
        status: filter.filters?.status,
      },
    });

    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to get dead leads');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export async function addActiveLeads(data: any): Promise<any> {
  const response = await axiosInstance.post('/api/v1/leads', data);
  if (response.status === 200) {
    return response.data;
  } else {
    throw new Error('Failed to add lead');
  }
}

// Check if a lead with the same WhatsApp number already exists in the same launch
export async function checkDuplicateLead(
  whatsapp_number: string,
  launch_id: string | number,
  assigned_user_id: string | number
): Promise<any> {
  const response = await axiosInstance.get('/api/v1/leads/leads/check-duplicate', {
    params: { whatsapp_number, launch_id, assigned_user_id },
  });
  return response.data;
}

export async function reviveLead(
  lead_id: number,
  new_launch_id?: number | string,
  new_project_id?: number | string,
  action?: 'creating' | 'importing',
  remark?: string,
  pre_sales_id?: number | null,
  field_sales_id?: number | null,
  status_id?: number | null
): Promise<any> {
  const response = await axiosInstance.patch(`/api/v1/leads/leads/revive/${lead_id}`, {
    new_launch_id,
    new_project_id,
    action,
    remark,
    pre_sales_id,
    field_sales_id,
    status_id,
  });
  return response.data;
}

export async function reviveAllLeads(
  leads: Array<{ id: number; pre_sales_id?: number | null; field_sales_id?: number | null }>,
  new_launch_id?: number | string,
  new_project_id?: number | string,
  remark?: string
): Promise<any> {
  const response = await axiosInstance.patch('/api/v1/leads/leads/revive-all', {
    leads,
    new_launch_id,
    new_project_id,
    action: 'importing',
    remark,
  });
  return response.data;
}

export async function getProjectList(): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/projects', {});

    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch projects');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}
export async function getLeadData(id: number): Promise<any> {
  try {
    const response = await axiosInstance.get(`/api/v1/leads/${id}`);
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch lead');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export const updateLeadData = async(id: number | string, data: any) => {
  const response = await axiosInstance.patch(`/api/v1/leads/customer-details/${id}`, data);
  if (response.status === 200) {
    return response.data;
  } else {
    throw new Error('Failed to update lead');
  }
};

export async function getPossessionList(_param: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/possession', {});

    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch projects');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export async function getMaxBudget(_param: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/budget', {});

    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch budget');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export const updateLeads = async(data: any): Promise<any> => {
  const response = await axiosInstance.post('/api/v1/leads/leads/action', data);
  if (response.status === 200) {
    return response.data;
  } else {
    throw new Error('Failed to update lead');
  }
};

export const deleteLead = async(leadId: number): Promise<any> => {
  const response = await axiosInstance.delete(`/api/v1/leads/${leadId}`);
  if (response.status === 200) {
    return { success: true };
  } else {
    throw new Error('Failed to delete lead');
  }
};

export const getFilterProjectList = async(params?: { page?: number; pageSize?: number; search?: string }) => {
  try {
    const response = await axiosInstance.get('/api/v1/projects/projects/project-list', {
      params: {
        page: params?.page || 1,
        pageSize: params?.pageSize || 10,
        search: params?.search || '',
      },
    });
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch project list');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
};

export const getFilterLocalityList = async(params?: { page?: number; pageSize?: number; search?: string }) => {
  try {
    const response = await axiosInstance.get('/api/v1/locality/locality-list', {
      params: {
        page: params?.page || 1,
        pageSize: params?.pageSize || 10,
        search: params?.search || '',
      },
    });
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch locality list');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
};
export const getFilterLaunchList = async(filter: any,) => {
  try {
    const response = await axiosInstance.get('/api/v1/leads/leads/launch-list', {
      params: {
        launch_id: filter.launch_id? filter.launch_id : '',
        lead_user_role_name: filter.lead_user_role_name,
        lead_user_id: filter.lead_user_id,
        lead_user_city_id: filter.lead_user_city_id,
      },
    });
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch launch list');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
};

export const getFilterConfigurations = async() => {
  try {
    const response = await axiosInstance.get('/api/v1/projects/projects/configuration', {});
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch configuration list');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
};

export const getFilterBudgetList = async() => {
  try {
    const response = await axiosInstance.get('/api/v1/leads/leads/budget-list', {});
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch budget list');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
};

export const getLeadStatus = async() => {
  try {
    const response = await axiosInstance.get('/api/v1/lead-requests/lead-status', {});
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch lead status');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
};

// Function to get Launched Projects for Project Filter section
export const getLaunchedProjects = async() => {
  try {
    const response = await axiosInstance.get('/api/v1/lead-requests/launch-projects', {});
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch launched projects');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
};

export const getLeadRemarks = async(id: number | string) => {
  try {
    const response = await axiosInstance.get(`/api/v1/leads/leads/get-remark/${id}`);
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch lead remarks');
    }
  } catch (error: any) {
    console.error('error: ', error);
  }
};

export async function getLeadUserDropdown(filter?: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/users/users/hierarchy-chart', {
      params: {
        search: filter.search,
        tab_key: filter?.tab_key,
        city_id: filter.city_id,
        reporting_manager_id: filter?.reporting_manager_id,
      },
    });
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch user dropdown list');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}

export async function getBothSalesLeadDropdown(filter?: any): Promise<any> {
  try {
    const response = await axiosInstance.get('/api/v1/users/users/hierarchy-chart-lead', {
      params: {
        search: filter.search,
        tab_key: filter?.tab_key,
        city_id: filter.city_id,
        reporting_manager_id: filter?.reporting_manager_id,
      },
    });
    if (response.status === 200) {
      return response.data;
    } else {
      throw new Error('Failed to fetch user dropdown list');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error,
    });
  }
}
export async function getExportLeads(filter: any, tabKey: string): Promise<any> {
  try {
    const response = await axiosInstance.get(
      `/api/v1/leads/leads/export-lead?tab_key=${tabKey}`,
      {
        params: {
          project_id: filter?.project_id?.join(','),
          locality_id: filter?.locality_id?.join
                        ? filter.locality_id.join(',')
                        : filter.locality_id,
          search: filter.search,
          sortColumn: filter.sortColumn,
          sortOrder: filter.sortOrder,
          created_by: filter.created_by,
          launch_id: filter.launch_id,
          status_id: filter?.status_id?.join(','),
          whats_your_tentative_budget_: filter.whats_your_tentative_budget_,
          which_configuration_you_are_looking_for_:
                        filter.which_configuration_you_are_looking_for_,
          start_date: filter.start_date,
          end_date: filter.end_date,
          lead_user_role_name: filter.lead_user_role_name,
          lead_user_id: filter.lead_user_id,
          lead_user_city_id: filter.lead_user_city_id,
          veiw_data: filter.veiw_data,
          isNRI: filter.isNRI,
          source: filter.source,
          tag: filter.tag,
          is_transferred: filter.is_transferred,
          ...(Array.isArray(filter.status_history) && filter.status_history.length > 0
            ? { status_history: filter.status_history.join(',') }
            : {}),
        },
        responseType: 'blob',
      }
    );

    if (response !== undefined) {
      // Create a Blob from the response data
      const blob = new Blob([response.data], { type: response.headers['content-type'] });

      // Create a temporary URL for the Blob
      const url = window.URL.createObjectURL(blob);

      // Create a link element
      const link = document.createElement('a');
      link.href = url;
      link.setAttribute('download', `lead-${tabKey}-report.xlsx`); // Set the filename

      // Append the link to the document body
      document.body.appendChild(link);

      // Trigger a click event on the link to initiate the download
      link.click();

      // Remove the link from the document body
      document.body.removeChild(link);

      return null;
    } else {
      throw new Error('Failed to fetch Users');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error.message,
    });
    throw error;
  }
}

export const importLeads = async(formData: FormData): Promise<any> => {
  const response = await axiosInstance.post('/api/v1/leads/leads/import-lead', formData, {
    headers: {
      'Content-Type': 'multipart/form-data',
    },
  });
  if (response.status === 200) {
    return response.data;
  } else {
    throw new Error('Failed to import lead');
  }
};

export const uploadBookingImages = async(leadId: number | string, formData: FormData): Promise<any> => {
  const response = await axiosInstance.post(`/api/v1/leads/leads/${leadId}/booking-images`, formData, {
    headers: {
      'Content-Type': 'multipart/form-data',
    },
  });
  if (response.status === 200) {
    return response.data;
  } else {
    throw new Error('Failed to upload booking image');
  }
};

export const deleteBookingImage = async(leadId: number | string, key: string): Promise<any> => {
  const response = await axiosInstance.delete(`/api/v1/leads/leads/${leadId}/booking-images`, {
    data: { key },
  });
  if (response.status === 200) {
    return response.data;
  } else {
    throw new Error('Failed to delete booking image');
  }
};

export const getLeadBookings = async(leadId: number | string): Promise<any> => {
  const response = await axiosInstance.get(`/api/v1/leads/leads/${leadId}/bookings`);
  if (response.status === 200) {
    return response.data;
  } else {
    throw new Error('Failed to fetch bookings');
  }
};

export const createLeadBooking = async(leadId: number | string, data: any): Promise<any> => {
  const response = await axiosInstance.post(`/api/v1/leads/leads/${leadId}/bookings`, data);
  if (response.status === 200) {
    return response.data;
  } else {
    throw new Error('Failed to create booking');
  }
};

export const updateLeadBooking = async(leadId: number | string, bookingId: number | string, data: any): Promise<any> => {
  const response = await axiosInstance.patch(`/api/v1/leads/leads/${leadId}/bookings/${bookingId}`, data);
  if (response.status === 200) {
    return response.data;
  } else {
    throw new Error('Failed to update booking');
  }
};

export const cancelLeadBooking = async(leadId: number | string, bookingId: number | string, remark: string): Promise<any> => {
  const response = await axiosInstance.patch(`/api/v1/leads/leads/${leadId}/bookings/${bookingId}/cancel`, { remark });
  if (response.status === 200) {
    return response.data;
  } else {
    throw new Error('Failed to cancel booking');
  }
};

export async function getLeadTransferHistory(leadId: number): Promise<any> {
  try {
    const response = await axiosInstance.get(`/api/v1/de-association/lead-transfer-history/${leadId}`);
    if (response !== undefined) {
      return response.data;
    } else {
      throw new Error('Failed to fetch transfer history');
    }
  } catch (error: any) {
    notification.error({
      message: 'Error',
      description: error.message,
    });
    throw error;
  }
}