import ApiService from "./ApiService";

// Consultant interfaces
export interface Consultant {
  id: string;
  consultant_name: string;
  type_id: string;
  phone_number: string;
  email: string;
  project_id: string;
  notes: string;
  created_at?: string;
  updated_at?: string;
  partyType?: {
    id: string;
    type_name: string;
  };
  project?: {
    id: string;
    name: string;
  };
}

export interface ConsultantType {
  id: string;
  type_name: string;
  type_category: string;
}

export interface Project {
  id: string;
  name: string;
}

export interface ConsultantFilters {
  search?: string;
  type_id?: string;
  column_name?: string;
  order?: 'ASC' | 'DESC';
  page?: number;
  limit?: number;
}

export interface CreateConsultantData {
  consultant_name: string;
  type_id: string;
  phone_number: string;
  email: string;
  project_id: string;
  notes: string;
}

export interface UpdateConsultantData {
  id: string;
  consultant_name: string;
  type_id: string;
  phone_number: string;
  email: string;
  project_id: string;
  notes: string;
}

export interface CreateConsultantTypeData {
  type_name: string;
  type_category: "CONSULTANT";
}

export interface ConsultantListResponse {
  success: boolean;
  message?: string;
  data: {
    data: Consultant[];
    count: number;
  };
}

export interface ConsultantResponse {
  success: boolean;
  message?: string;
  data: Consultant;
}

export interface ConsultantTypesResponse {
  success: boolean;
  message?: string;
  data: ConsultantType[];
}

export interface ProjectsResponse {
  success: boolean;
  message?: string;
  data: {
    data: Project[];
    count: number;
  };
}

export interface ConsultantTypeResponse {
  success: boolean;
  message?: string;
  data: ConsultantType;
}

// Get Consultant Types
export async function getConsultantTypes() {
  return ApiService.request<ConsultantTypesResponse>({
    url: "/consultants/types",
    method: "get",
  });
}

// Create Consultant Type (Inline)
export async function createConsultantType(data: CreateConsultantTypeData) {
  return ApiService.request<ConsultantTypeResponse>({
    url: "/party-types",
    method: "post",
    data,
  });
}

// Get Projects for dropdown
export async function getProjectsForDropdown() {
  return ApiService.request<ProjectsResponse>({
    url: "/projects",
    method: "get",
    params: {
      limit: 9999,
    },
  });
}

// Create Consultant
export async function createConsultant(data: CreateConsultantData) {
  return ApiService.request<ConsultantResponse>({
    url: "/consultants",
    method: "post",
    data,
  });
}

// Get Consultants with filters
export async function getConsultants(filters?: ConsultantFilters) {
  const params: any = {
    search: filters?.search || "",
    page: filters?.page || 1,
    limit: filters?.limit || 10,
  };

  // Only add type_id to params if it's defined and not "all"
  if (filters?.type_id && filters.type_id !== "all") {
    params.type_id = filters.type_id;
  }

  if (filters?.column_name) {
    params.column_name = filters.column_name;
  }

  if (filters?.order) {
    params.order = filters.order;
  }

  return ApiService.request<ConsultantListResponse>({
    url: "/consultants",
    method: "get",
    params,
  });
}

// Get Consultant by ID
export async function getConsultantById(id: string) {
  return ApiService.request<ConsultantResponse>({
    url: `/consultants/${id}`,
    method: "get",
  });
}

// Update Consultant
export async function updateConsultant(data: UpdateConsultantData) {
  const { id, ...updateData } = data;
  return ApiService.request<ConsultantResponse>({
    url: `/consultants/${id}`,
    method: "put",
    data: updateData,
  });
}

export interface DeleteConsultantResponse {
  success: boolean;
  message?: string;
}

// Delete Consultant
export async function deleteConsultant(id: string) {
  return ApiService.request<DeleteConsultantResponse>({
    url: `/consultants/${id}`,
    method: "delete",
  });
}