import ApiService from "./ApiService";

// Contractor interfaces
export interface Contractor {
  id: string;
  contractor_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 ContractorType {
  id: string;
  type_name: string;
  type_category: string;
}

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

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

export interface CreateContractorData {
  contractor_name: string;
  type_id: string;
  phone_number: string;
  email: string;
  project_id: string;
  notes: string;
}

export interface UpdateContractorData {
  id: string;
  contractor_name: string;
  type_id: string;
  phone_number: string;
  email: string;
  project_id: string;
  notes: string;
}

export interface CreateContractorTypeData {
  type_name: string;
  type_category: "CONTRACTOR";
}

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

export interface ContractorResponse {
  success: boolean;
  message?: string;
  data: Contractor;
}

export interface ContractorTypesResponse {
  success: boolean;
  message?: string;
  data: ContractorType[];
}

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

export interface ContractorTypeResponse {
  success: boolean;
  message?: string;
  data: ContractorType;
}

// Get Contractor Types
export async function getContractorTypes() {
  return ApiService.request<ContractorTypesResponse>({
    url: "/contractors/types",
    method: "get",
  });
}

// Create Contractor Type (Inline)
export async function createContractorType(data: CreateContractorTypeData) {
  return ApiService.request<ContractorTypeResponse>({
    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 Contractor
export async function createContractor(data: CreateContractorData) {
  return ApiService.request<ContractorResponse>({
    url: "/contractors",
    method: "post",
    data,
  });
}

// Get Contractors with filters
export async function getContractors(filters?: ContractorFilters) {
  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<ContractorListResponse>({
    url: "/contractors",
    method: "get",
    params,
  });
}

// Get Contractor by ID
export async function getContractorById(id: string) {
  return ApiService.request<ContractorResponse>({
    url: `/contractors/${id}`,
    method: "get",
  });
}

// Update Contractor
export async function updateContractor(data: UpdateContractorData) {
  const { id, ...updateData } = data;
  return ApiService.request<ContractorResponse>({
    url: `/contractors/${id}`,
    method: "put",
    data: updateData,
  });
}

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

// Delete Contractor
export async function deleteContractor(id: string) {
  return ApiService.request<DeleteContractorResponse>({
    url: `/contractors/${id}`,
    method: "delete",
  });
}