@blackcode_sa/metaestetics-api 1.5.28 → 1.5.30

package/src/services/procedure/procedure.service.ts

@@ -12,6 +12,14 @@ import {
   serverTimestamp,
   DocumentData,
   writeBatch,
+  arrayUnion,
+  arrayRemove,
+  FieldValue,
+  orderBy,
+  limit,
+  startAfter,
+  QueryConstraint,
+  documentId,
 } from "firebase/firestore";
 import { BaseService } from "../base.service";
 import {
@@ -19,6 +27,7 @@ import {
   CreateProcedureData,
   UpdateProcedureData,
   PROCEDURES_COLLECTION,
+  ProcedureSummaryInfo,
 } from "../../types/procedure";
 import {
   createProcedureSchema,
@@ -57,7 +66,10 @@ import {
   CertificationSpecialty,
   ProcedureFamily,
 } from "../../backoffice/types";
-import { CLINICS_COLLECTION } from "../../types/clinic";
+import { Clinic, CLINICS_COLLECTION } from "../../types/clinic";
+import { ProcedureReviewInfo } from "../../types/reviews";
+import { distanceBetween, geohashQueryBounds } from "geofire-common";
+import { TreatmentBenefit } from "../../backoffice/types/static/treatment-benefit.types";
 
 export class ProcedureService extends BaseService {
   private categoryService: CategoryService;
@@ -87,10 +99,9 @@ export class ProcedureService extends BaseService {
    * @returns The created procedure
    */
   async createProcedure(data: CreateProcedureData): Promise<Procedure> {
-    // Validate input data
     const validatedData = createProcedureSchema.parse(data);
 
-    // Get references to related entities
+    // Get references to related entities (Category, Subcategory, Technology, Product)
     const [category, subcategory, technology, product] = await Promise.all([
       this.categoryService.getById(validatedData.categoryId),
       this.subcategoryService.getById(
@@ -105,75 +116,65 @@ export class ProcedureService extends BaseService {
     ]);
 
     if (!category || !subcategory || !technology || !product) {
-      throw new Error("One or more required entities not found");
+      throw new Error("One or more required base entities not found");
     }
 
-    // Get clinic and practitioner information
+    // Get clinic and practitioner information for aggregation
     const clinicRef = doc(
       this.db,
       CLINICS_COLLECTION,
       validatedData.clinicBranchId
     );
     const clinicSnapshot = await getDoc(clinicRef);
-
     if (!clinicSnapshot.exists()) {
       throw new Error(
         `Clinic with ID ${validatedData.clinicBranchId} not found`
       );
     }
+    const clinic = clinicSnapshot.data() as Clinic; // Assert type
 
-    const clinic = clinicSnapshot.data();
-
-    // Create clinic info
-    const clinicInfo = {
-      id: clinicSnapshot.id,
-      name: clinic.name,
-      description: clinic.description || "",
-      featuredPhoto:
-        clinic.featuredPhotos && clinic.featuredPhotos.length > 0
-          ? clinic.featuredPhotos[0]
-          : clinic.coverPhoto || "",
-      location: clinic.location,
-      contactInfo: clinic.contactInfo,
-    };
-
-    // Get practitioner information
     const practitionerRef = doc(
       this.db,
       PRACTITIONERS_COLLECTION,
       validatedData.practitionerId
     );
     const practitionerSnapshot = await getDoc(practitionerRef);
-
     if (!practitionerSnapshot.exists()) {
       throw new Error(
         `Practitioner with ID ${validatedData.practitionerId} not found`
       );
     }
+    const practitioner = practitionerSnapshot.data() as Practitioner; // Assert type
 
-    const practitioner = practitionerSnapshot.data();
-
-    // Find doctor info in clinic's doctorsInfo array
-    let doctorInfo = clinic.doctorsInfo?.find(
-      (doctor: any) => doctor.id === validatedData.practitionerId
-    );
+    // Create aggregated clinic info for the procedure document
+    const clinicInfo = {
+      id: clinicSnapshot.id,
+      name: clinic.name,
+      description: clinic.description || "",
+      featuredPhoto:
+        clinic.featuredPhotos && clinic.featuredPhotos.length > 0
+          ? clinic.featuredPhotos[0]
+          : clinic.coverPhoto || "",
+      location: clinic.location,
+      contactInfo: clinic.contactInfo,
+    };
 
-    // If not found, create basic doctor info
-    if (!doctorInfo) {
-      doctorInfo = {
-        id: practitionerSnapshot.id,
-        name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
-        description: practitioner.basicInfo.bio || "",
-        photo: practitioner.basicInfo.profileImageUrl || "",
-        rating: 0,
-        services: [],
-      };
-    }
+    // Create aggregated doctor info for the procedure document
+    const doctorInfo = {
+      id: practitionerSnapshot.id,
+      name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
+      description: practitioner.basicInfo.bio || "",
+      photo: practitioner.basicInfo.profileImageUrl || "",
+      rating: practitioner.reviewInfo?.averageRating || 0,
+      services: practitioner.procedures || [],
+    };
 
     // Create the procedure object
-    const procedure: Omit<Procedure, "id"> = {
+    const procedureId = this.generateId();
+    const newProcedure: Omit<Procedure, "createdAt" | "updatedAt"> = {
+      id: procedureId,
       ...validatedData,
-      category,
+      category, // Embed full objects
       subcategory,
       technology,
       product,
@@ -183,24 +184,33 @@ export class ProcedureService extends BaseService {
       postRequirements: technology.requirements.post,
       certificationRequirement: technology.certificationRequirement,
       documentationTemplates: technology.documentationTemplates || [],
-      clinicInfo,
-      doctorInfo,
-      isActive: true,
-      createdAt: new Date(),
-      updatedAt: new Date(),
+      clinicInfo, // Embed aggregated info
+      doctorInfo, // Embed aggregated info
+      reviewInfo: {
+        // Default empty reviews
+        totalReviews: 0,
+        averageRating: 0,
+        effectivenessOfTreatment: 0,
+        outcomeExplanation: 0,
+        painManagement: 0,
+        followUpCare: 0,
+        valueForMoney: 0,
+        recommendationPercentage: 0,
+      },
+      isActive: true, // Default to active
     };
 
-    // Generate ID and create document
-    const id = this.generateId();
-    const docRef = doc(this.db, PROCEDURES_COLLECTION, id);
-    await setDoc(docRef, {
-      ...procedure,
-      id,
+    // Create the procedure document
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, procedureId);
+    await setDoc(procedureRef, {
+      ...newProcedure,
       createdAt: serverTimestamp(),
       updatedAt: serverTimestamp(),
     });
 
-    return { ...procedure, id } as Procedure;
+    // Return the created procedure (fetch again to get server timestamps)
+    const savedDoc = await getDoc(procedureRef);
+    return savedDoc.data() as Procedure;
   }
 
   /**
@@ -256,71 +266,207 @@ export class ProcedureService extends BaseService {
   /**
    * Updates a procedure
    * @param id - The ID of the procedure to update
-   * @param data - The data to update
+   * @param data - The data to update the procedure with
    * @returns The updated procedure
    */
   async updateProcedure(
     id: string,
     data: UpdateProcedureData
   ): Promise<Procedure> {
-    // Validate input data
     const validatedData = updateProcedureSchema.parse(data);
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnapshot = await getDoc(procedureRef);
 
-    // Get the existing procedure
-    const existingProcedure = await this.getProcedure(id);
-    if (!existingProcedure) {
+    if (!procedureSnapshot.exists()) {
       throw new Error(`Procedure with ID ${id} not found`);
     }
 
-    // Update the procedure
-    const docRef = doc(this.db, PROCEDURES_COLLECTION, id);
-    await updateDoc(docRef, {
-      ...validatedData,
+    const existingProcedure = procedureSnapshot.data() as Procedure;
+    let updatedProcedureData: Partial<Procedure> = { ...validatedData };
+
+    let practitionerChanged = false;
+    let clinicChanged = false;
+    const oldPractitionerId = existingProcedure.practitionerId;
+    const oldClinicId = existingProcedure.clinicBranchId;
+    let newPractitioner: Practitioner | null = null;
+    let newClinic: Clinic | null = null;
+
+    // --- Prepare updates and fetch new related data if IDs change ---
+
+    // Handle Practitioner Change
+    if (
+      validatedData.practitionerId &&
+      validatedData.practitionerId !== oldPractitionerId
+    ) {
+      practitionerChanged = true;
+      const newPractitionerRef = doc(
+        this.db,
+        PRACTITIONERS_COLLECTION,
+        validatedData.practitionerId
+      );
+      const newPractitionerSnap = await getDoc(newPractitionerRef);
+      if (!newPractitionerSnap.exists())
+        throw new Error(
+          `New Practitioner ${validatedData.practitionerId} not found`
+        );
+      newPractitioner = newPractitionerSnap.data() as Practitioner;
+      // Update doctorInfo within the procedure document
+      updatedProcedureData.doctorInfo = {
+        id: newPractitioner.id,
+        name: `${newPractitioner.basicInfo.firstName} ${newPractitioner.basicInfo.lastName}`,
+        description: newPractitioner.basicInfo.bio || "",
+        photo: newPractitioner.basicInfo.profileImageUrl || "",
+        rating: newPractitioner.reviewInfo?.averageRating || 0,
+        services: newPractitioner.procedures || [],
+      };
+    }
+
+    // Handle Clinic Change
+    if (
+      validatedData.clinicBranchId &&
+      validatedData.clinicBranchId !== oldClinicId
+    ) {
+      clinicChanged = true;
+      const newClinicRef = doc(
+        this.db,
+        CLINICS_COLLECTION,
+        validatedData.clinicBranchId
+      );
+      const newClinicSnap = await getDoc(newClinicRef);
+      if (!newClinicSnap.exists())
+        throw new Error(`New Clinic ${validatedData.clinicBranchId} not found`);
+      newClinic = newClinicSnap.data() as Clinic;
+      // Update clinicInfo within the procedure document
+      updatedProcedureData.clinicInfo = {
+        id: newClinic.id,
+        name: newClinic.name,
+        description: newClinic.description || "",
+        featuredPhoto:
+          newClinic.featuredPhotos && newClinic.featuredPhotos.length > 0
+            ? newClinic.featuredPhotos[0]
+            : newClinic.coverPhoto || "",
+        location: newClinic.location,
+        contactInfo: newClinic.contactInfo,
+      };
+    }
+
+    // Handle Category/Subcategory/Technology/Product Changes
+    let finalCategoryId = existingProcedure.category.id;
+    if (validatedData.categoryId) {
+      const category = await this.categoryService.getById(
+        validatedData.categoryId
+      );
+      if (!category)
+        throw new Error(`Category ${validatedData.categoryId} not found`);
+      updatedProcedureData.category = category;
+      finalCategoryId = category.id; // Update finalCategoryId if category changed
+    }
+
+    // Only fetch subcategory if its ID is provided AND we have a valid finalCategoryId
+    if (validatedData.subcategoryId && finalCategoryId) {
+      const subcategory = await this.subcategoryService.getById(
+        finalCategoryId,
+        validatedData.subcategoryId
+      );
+      if (!subcategory)
+        throw new Error(
+          `Subcategory ${validatedData.subcategoryId} not found for category ${finalCategoryId}`
+        );
+      updatedProcedureData.subcategory = subcategory;
+    } else if (validatedData.subcategoryId) {
+      console.warn(
+        "Attempted to update subcategory without a valid categoryId"
+      );
+    }
+
+    let finalTechnologyId = existingProcedure.technology.id;
+    if (validatedData.technologyId) {
+      const technology = await this.technologyService.getById(
+        validatedData.technologyId
+      );
+      if (!technology)
+        throw new Error(`Technology ${validatedData.technologyId} not found`);
+      updatedProcedureData.technology = technology;
+      finalTechnologyId = technology.id; // Update finalTechnologyId if technology changed
+      // Update related fields derived from technology
+      updatedProcedureData.blockingConditions = technology.blockingConditions;
+      updatedProcedureData.treatmentBenefits = technology.benefits;
+      updatedProcedureData.preRequirements = technology.requirements.pre;
+      updatedProcedureData.postRequirements = technology.requirements.post;
+      updatedProcedureData.certificationRequirement =
+        technology.certificationRequirement;
+      updatedProcedureData.documentationTemplates =
+        technology.documentationTemplates || [];
+    }
+
+    // Only fetch product if its ID is provided AND we have a valid finalTechnologyId
+    if (validatedData.productId && finalTechnologyId) {
+      const product = await this.productService.getById(
+        finalTechnologyId,
+        validatedData.productId
+      );
+      if (!product)
+        throw new Error(
+          `Product ${validatedData.productId} not found for technology ${finalTechnologyId}`
+        );
+      updatedProcedureData.product = product;
+    } else if (validatedData.productId) {
+      console.warn("Attempted to update product without a valid technologyId");
+    }
+
+    // Update the procedure document
+    await updateDoc(procedureRef, {
+      ...updatedProcedureData,
       updatedAt: serverTimestamp(),
     });
 
-    // Return the updated procedure with combined data
-    // Note: Since we're not changing the clinicInfo or doctorInfo in this update,
-    // we just keep the existing values from the procedure
-    return {
-      ...existingProcedure,
-      ...validatedData,
-      updatedAt: new Date(),
-    };
+    // Return the updated procedure
+    const updatedSnapshot = await getDoc(procedureRef);
+    return updatedSnapshot.data() as Procedure;
   }
 
   /**
-   * Deactivates a procedure
+   * Deactivates a procedure (soft delete)
    * @param id - The ID of the procedure to deactivate
    */
   async deactivateProcedure(id: string): Promise<void> {
-    const docRef = doc(this.db, PROCEDURES_COLLECTION, id);
-    await updateDoc(docRef, {
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnap = await getDoc(procedureRef);
+    if (!procedureSnap.exists()) {
+      console.warn(`Procedure ${id} not found for deactivation.`);
+      return;
+    }
+
+    // Mark procedure as inactive
+    await updateDoc(procedureRef, {
       isActive: false,
       updatedAt: serverTimestamp(),
     });
   }
 
+  /**
+   * Deletes a procedure permanently
+   * @param id - The ID of the procedure to delete
+   * @returns A boolean indicating if the deletion was successful
+   */
+  async deleteProcedure(id: string): Promise<boolean> {
+    const procedureRef = doc(this.db, PROCEDURES_COLLECTION, id);
+    const procedureSnapshot = await getDoc(procedureRef);
+
+    if (!procedureSnapshot.exists()) {
+      // Already deleted or never existed
+      return false;
+    }
+
+    // Delete the procedure document
+    await deleteDoc(procedureRef);
+    return true;
+  }
+
   /**
    * Gets all procedures that a practitioner is certified to perform
    * @param practitioner - The practitioner's profile
-   * @returns Object containing:
-   * - procedures: List of procedures the practitioner can perform
-   * - families: List of procedure families the practitioner can perform
-   * - categories: List of category IDs the practitioner can perform
-   * - subcategories: List of subcategory IDs the practitioner can perform
-   *
-   * @example
-   * const practitioner = {
-   *   certification: {
-   *     level: CertificationLevel.DOCTOR,
-   *     specialties: [CertificationSpecialty.INJECTABLES]
-   *   }
-   * };
-   * const allowedProcedures = await procedureService.getAllowedProcedures(practitioner);
-   * console.log(allowedProcedures.families); // [ProcedureFamily.AESTHETICS]
-   * console.log(allowedProcedures.categories); // ["category1", "category2"]
-   * console.log(allowedProcedures.subcategories); // ["subcategory1", "subcategory2"]
+   * @returns Object containing allowed technologies, families, categories, subcategories
    */
   async getAllowedTechnologies(practitioner: Practitioner): Promise<{
     technologies: Technology[];
@@ -328,7 +474,7 @@ export class ProcedureService extends BaseService {
     categories: string[];
     subcategories: string[];
   }> {
-    // Get all allowed technologies for the practitioner
+    // This logic depends on TechnologyService and remains valid
     const { technologies, families, categories, subcategories } =
       await this.technologyService.getAllowedTechnologies(practitioner);
 
@@ -355,19 +501,26 @@ export class ProcedureService extends BaseService {
       const proceduresCollection = collection(this.db, PROCEDURES_COLLECTION);
       let proceduresQuery = query(proceduresCollection);
 
-      // If pagination is specified and greater than 0, limit the query
+      // Apply pagination if specified
       if (pagination && pagination > 0) {
-        const { limit, startAfter } = require("firebase/firestore");
+        const { limit, startAfter } = await import("firebase/firestore"); // Use dynamic import if needed top-level
 
         if (lastDoc) {
           proceduresQuery = query(
             proceduresCollection,
+            orderBy("name"), // Use imported orderBy
             startAfter(lastDoc),
             limit(pagination)
           );
         } else {
-          proceduresQuery = query(proceduresCollection, limit(pagination));
+          proceduresQuery = query(
+            proceduresCollection,
+            orderBy("name"),
+            limit(pagination)
+          ); // Use imported orderBy
         }
+      } else {
+        proceduresQuery = query(proceduresCollection, orderBy("name")); // Use imported orderBy
       }
 
       const proceduresSnapshot = await getDocs(proceduresQuery);
@@ -376,17 +529,9 @@ export class ProcedureService extends BaseService {
 
       const procedures = proceduresSnapshot.docs.map((doc) => {
         const data = doc.data() as Procedure;
-
-        // Ensure clinicInfo and doctorInfo are present
-        if (!data.clinicInfo || !data.doctorInfo) {
-          console.warn(
-            `Procedure ${data.id} is missing clinicInfo or doctorInfo fields. These should be updated.`
-          );
-        }
-
         return {
           ...data,
-          id: doc.id,
+          id: doc.id, // Ensure ID is present
         };
       });
 
@@ -401,249 +546,314 @@ export class ProcedureService extends BaseService {
   }
 
   /**
-   * Updates the clinicInfo and doctorInfo fields in procedures when the source data changes
+   * Searches and filters procedures based on multiple criteria
    *
-   * @param entityType - The type of entity that changed ("clinic" or "doctor")
-   * @param entityId - The ID of the entity that changed
-   * @param updatedData - The updated data for the entity
-   * @returns Number of procedures updated
+   * @param filters - Various filters to apply
+   * @param filters.nameSearch - Optional search text for procedure name
+   * @param filters.treatmentBenefits - Optional array of treatment benefits to filter by
+   * @param filters.procedureFamily - Optional procedure family to filter by
+   * @param filters.procedureCategory - Optional procedure category to filter by
+   * @param filters.procedureSubcategory - Optional procedure subcategory to filter by
+   * @param filters.procedureTechnology - Optional procedure technology to filter by
+   * @param filters.location - Optional location for distance-based search
+   * @param filters.radiusInKm - Optional radius in kilometers (required if location is provided)
+   * @param filters.minPrice - Optional minimum price
+   * @param filters.maxPrice - Optional maximum price
+   * @param filters.minRating - Optional minimum rating (0-5)
+   * @param filters.maxRating - Optional maximum rating (0-5)
+   * @param filters.pagination - Optional number of results per page
+   * @param filters.lastDoc - Optional last document for pagination
+   * @param filters.isActive - Optional filter for active procedures only
+   * @returns Filtered procedures and the last document for pagination
    */
-  async updateProcedureAggregateData(
-    entityType: "clinic" | "doctor",
-    entityId: string,
-    updatedData: any
-  ): Promise<number> {
-    let proceduresQuery;
-    const updatedField = entityType === "clinic" ? "clinicInfo" : "doctorInfo";
-
-    // Find all procedures related to this entity
-    if (entityType === "clinic") {
-      proceduresQuery = query(
-        collection(this.db, PROCEDURES_COLLECTION),
-        where("clinicBranchId", "==", entityId)
-      );
-    } else {
-      proceduresQuery = query(
-        collection(this.db, PROCEDURES_COLLECTION),
-        where("practitionerId", "==", entityId)
+  async getProceduresByFilters(filters: {
+    nameSearch?: string;
+    treatmentBenefits?: TreatmentBenefit[];
+    procedureFamily?: ProcedureFamily;
+    procedureCategory?: string;
+    procedureSubcategory?: string;
+    procedureTechnology?: string;
+    location?: { latitude: number; longitude: number };
+    radiusInKm?: number;
+    minPrice?: number;
+    maxPrice?: number;
+    minRating?: number;
+    maxRating?: number;
+    pagination?: number;
+    lastDoc?: any;
+    isActive?: boolean;
+  }): Promise<{
+    procedures: (Procedure & { distance?: number })[];
+    lastDoc: any;
+  }> {
+    try {
+      console.log(
+        "[PROCEDURE_SERVICE] Starting procedure filtering with criteria:",
+        filters
       );
-    }
-
-    const snapshot = await getDocs(proceduresQuery);
 
-    if (snapshot.empty) {
-      return 0;
-    }
+      // Determine if we're doing a geo query or a regular query
+      const isGeoQuery =
+        filters.location && filters.radiusInKm && filters.radiusInKm > 0;
 
-    // Create the updated data object
-    let updatedFieldData;
+      // Initialize base constraints
+      const constraints: QueryConstraint[] = [];
 
-    if (entityType === "clinic") {
-      // Clinic info format
-      updatedFieldData = {
-        id: entityId,
-        name: updatedData.name,
-        description: updatedData.description || "",
-        featuredPhoto:
-          updatedData.featuredPhotos && updatedData.featuredPhotos.length > 0
-            ? updatedData.featuredPhotos[0]
-            : updatedData.coverPhoto || "",
-        location: updatedData.location,
-        contactInfo: updatedData.contactInfo,
-      };
-    } else {
-      // Doctor info format
-      if (updatedData.basicInfo) {
-        // If it's a practitioner object
-        updatedFieldData = {
-          id: entityId,
-          name: `${updatedData.basicInfo.firstName} ${updatedData.basicInfo.lastName}`,
-          description: updatedData.basicInfo.bio || "",
-          photo: updatedData.basicInfo.profileImageUrl || "",
-          rating: 0, // This would need to be calculated or passed in
-          services: [], // This would need to be determined or passed in
-        };
+      // Add active status filter (default to active if not specified)
+      if (filters.isActive !== undefined) {
+        constraints.push(where("isActive", "==", filters.isActive));
       } else {
-        // If it's already a doctorInfo object
-        updatedFieldData = {
-          id: entityId,
-          name: updatedData.name,
-          description: updatedData.description || "",
-          photo: updatedData.photo || "",
-          rating: updatedData.rating || 0,
-          services: updatedData.services || [],
-        };
+        constraints.push(where("isActive", "==", true));
       }
-    }
 
-    // Update all found procedures
-    const batch = writeBatch(this.db);
+      // Filter by procedure family if specified
+      if (filters.procedureFamily) {
+        constraints.push(where("family", "==", filters.procedureFamily));
+      }
 
-    snapshot.docs.forEach((doc) => {
-      batch.update(doc.ref, {
-        [updatedField]: updatedFieldData,
-        updatedAt: serverTimestamp(),
-      });
-    });
+      // Add ordering to make pagination consistent
+      constraints.push(orderBy(documentId()));
 
-    await batch.commit();
+      // Add pagination if specified
+      if (filters.pagination && filters.pagination > 0 && filters.lastDoc) {
+        constraints.push(startAfter(filters.lastDoc));
+        constraints.push(limit(filters.pagination));
+      } else if (filters.pagination && filters.pagination > 0) {
+        constraints.push(limit(filters.pagination));
+      }
 
-    return snapshot.size;
-  }
+      let proceduresResult: (Procedure & { distance?: number })[] = [];
+      let lastVisibleDoc = null;
 
-  /**
-   * Updates the clinicInfo for all procedures associated with a specific clinic
-   *
-   * @param clinicId - The ID of the clinic that was updated
-   * @param clinicData - The updated clinic data
-   * @returns Number of procedures updated
-   */
-  async updateClinicInfoInProcedures(
-    clinicId: string,
-    clinicData: any
-  ): Promise<number> {
-    return this.updateProcedureAggregateData("clinic", clinicId, clinicData);
-  }
+      // For geo queries, we need a different approach
+      if (isGeoQuery) {
+        const center = filters.location!;
+        const radiusInKm = filters.radiusInKm!;
 
-  /**
-   * Updates the doctorInfo for all procedures associated with a specific practitioner
-   *
-   * @param practitionerId - The ID of the practitioner that was updated
-   * @param practitionerData - The updated practitioner data
-   * @returns Number of procedures updated
-   */
-  async updateDoctorInfoInProcedures(
-    practitionerId: string,
-    practitionerData: any
-  ): Promise<number> {
-    return this.updateProcedureAggregateData(
-      "doctor",
-      practitionerId,
-      practitionerData
-    );
-  }
-
-  /**
-   * Updates all existing procedures to include clinicInfo and doctorInfo
-   * This is a migration helper method that can be used to update existing procedures
-   *
-   * @returns Number of procedures updated
-   */
-  async migrateAllProceduresWithAggregateData(): Promise<number> {
-    // Get all procedures
-    const proceduresQuery = query(collection(this.db, PROCEDURES_COLLECTION));
-    const proceduresSnapshot = await getDocs(proceduresQuery);
+        // Get the geohash query bounds
+        const bounds = geohashQueryBounds(
+          [center.latitude, center.longitude],
+          radiusInKm * 1000 // Convert to meters
+        );
 
-    if (proceduresSnapshot.empty) {
-      return 0;
-    }
+        // Collect matching procedures from all bounds
+        const matchingProcedures: (Procedure & { distance: number })[] = [];
+
+        // Execute queries for each bound
+        for (const bound of bounds) {
+          // Create a geo query for this bound
+          const geoConstraints = [
+            ...constraints,
+            where("clinicInfo.location.geohash", ">=", bound[0]),
+            where("clinicInfo.location.geohash", "<=", bound[1]),
+          ];
+
+          const q = query(
+            collection(this.db, PROCEDURES_COLLECTION),
+            ...geoConstraints
+          );
+          const querySnapshot = await getDocs(q);
 
-    let updatedCount = 0;
-    const batch = writeBatch(this.db);
-    const batchLimit = 500; // Firestore batch limit
-    let batchCount = 0;
+          console.log(
+            `[PROCEDURE_SERVICE] Found ${querySnapshot.docs.length} procedures in geo bound`
+          );
 
-    // Process each procedure
-    for (const procedureDoc of proceduresSnapshot.docs) {
-      const procedure = procedureDoc.data() as Procedure;
+          // Process results and filter by actual distance
+          for (const doc of querySnapshot.docs) {
+            const procedure = { ...doc.data(), id: doc.id } as Procedure;
+
+            // Calculate actual distance
+            const distance = distanceBetween(
+              [center.latitude, center.longitude],
+              [
+                procedure.clinicInfo.location.latitude,
+                procedure.clinicInfo.location.longitude,
+              ]
+            );
+
+            // Convert to kilometers
+            const distanceInKm = distance / 1000;
+
+            // Check if within radius
+            if (distanceInKm <= radiusInKm) {
+              // Add distance to procedure object
+              matchingProcedures.push({
+                ...procedure,
+                distance: distanceInKm,
+              });
+            }
+          }
+        }
 
-      // Skip if already has both required fields
-      if (procedure.clinicInfo && procedure.doctorInfo) {
-        continue;
-      }
+        // Apply additional filters that couldn't be applied in the query
+        let filteredProcedures = matchingProcedures;
 
-      try {
-        // Get clinic data
-        const clinicRef = doc(
-          this.db,
-          CLINICS_COLLECTION,
-          procedure.clinicBranchId
+        // Apply remaining filters in memory
+        filteredProcedures = this.applyInMemoryFilters(
+          filteredProcedures,
+          filters
         );
-        const clinicSnapshot = await getDoc(clinicRef);
 
-        if (!clinicSnapshot.exists()) {
-          console.warn(
-            `Clinic ${procedure.clinicBranchId} not found for procedure ${procedure.id}`
+        // Sort by distance
+        filteredProcedures.sort((a, b) => a.distance - b.distance);
+
+        // Apply pagination after all filters have been applied
+        if (filters.pagination && filters.pagination > 0) {
+          // If we have a lastDoc, find its index
+          let startIndex = 0;
+          if (filters.lastDoc) {
+            const lastDocIndex = filteredProcedures.findIndex(
+              (procedure) => procedure.id === filters.lastDoc.id
+            );
+            if (lastDocIndex !== -1) {
+              startIndex = lastDocIndex + 1;
+            }
+          }
+
+          // Get paginated subset
+          const paginatedProcedures = filteredProcedures.slice(
+            startIndex,
+            startIndex + filters.pagination
           );
-          continue;
-        }
 
-        const clinic = clinicSnapshot.data();
-
-        // Create clinic info
-        const clinicInfo = {
-          id: clinicSnapshot.id,
-          name: clinic.name,
-          description: clinic.description || "",
-          featuredPhoto:
-            clinic.featuredPhotos && clinic.featuredPhotos.length > 0
-              ? clinic.featuredPhotos[0]
-              : clinic.coverPhoto || "",
-          location: clinic.location,
-          contactInfo: clinic.contactInfo,
-        };
+          // Set last document for next pagination
+          lastVisibleDoc =
+            paginatedProcedures.length > 0
+              ? paginatedProcedures[paginatedProcedures.length - 1]
+              : null;
 
-        // Get practitioner data
-        const practitionerRef = doc(
-          this.db,
-          PRACTITIONERS_COLLECTION,
-          procedure.practitionerId
+          proceduresResult = paginatedProcedures;
+        } else {
+          proceduresResult = filteredProcedures;
+        }
+      } else {
+        // For non-geo queries, execute a single query with all constraints
+        const q = query(
+          collection(this.db, PROCEDURES_COLLECTION),
+          ...constraints
         );
-        const practitionerSnapshot = await getDoc(practitionerRef);
+        const querySnapshot = await getDocs(q);
 
-        if (!practitionerSnapshot.exists()) {
-          console.warn(
-            `Practitioner ${procedure.practitionerId} not found for procedure ${procedure.id}`
-          );
-          continue;
-        }
+        console.log(
+          `[PROCEDURE_SERVICE] Found ${querySnapshot.docs.length} procedures with regular query`
+        );
+
+        // Convert docs to procedures
+        const procedures = querySnapshot.docs.map((doc) => {
+          return { ...doc.data(), id: doc.id } as Procedure;
+        });
+
+        // Apply filters that couldn't be applied in the query
+        let filteredProcedures = this.applyInMemoryFilters(procedures, filters);
+
+        // Set last document for pagination
+        lastVisibleDoc =
+          querySnapshot.docs.length > 0
+            ? querySnapshot.docs[querySnapshot.docs.length - 1]
+            : null;
 
-        const practitioner = practitionerSnapshot.data();
+        proceduresResult = filteredProcedures;
+      }
+
+      return {
+        procedures: proceduresResult,
+        lastDoc: lastVisibleDoc,
+      };
+    } catch (error) {
+      console.error("[PROCEDURE_SERVICE] Error filtering procedures:", error);
+      throw error;
+    }
+  }
+
+  /**
+   * Helper method to apply in-memory filters to procedures
+   * Used by getProceduresByFilters to apply filters that can't be done in Firestore queries
+   *
+   * @param procedures - The procedures to filter
+   * @param filters - The filters to apply
+   * @returns Filtered procedures
+   */
+  private applyInMemoryFilters<T extends Procedure & { distance?: number }>(
+    procedures: T[],
+    filters: {
+      nameSearch?: string;
+      treatmentBenefits?: TreatmentBenefit[];
+      procedureCategory?: string;
+      procedureSubcategory?: string;
+      procedureTechnology?: string;
+      minPrice?: number;
+      maxPrice?: number;
+      minRating?: number;
+      maxRating?: number;
+    }
+  ): T[] {
+    let filteredProcedures = procedures;
+
+    // Filter by name search if specified
+    if (filters.nameSearch && filters.nameSearch.trim() !== "") {
+      const searchTerm = filters.nameSearch.toLowerCase().trim();
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        return procedure.name.toLowerCase().includes(searchTerm);
+      });
+    }
 
-        // Find doctor info in clinic's doctorsInfo array
-        let doctorInfo = clinic.doctorsInfo?.find(
-          (doctor: any) => doctor.id === procedure.practitionerId
+    // Filter by treatment benefits if specified
+    if (filters.treatmentBenefits && filters.treatmentBenefits.length > 0) {
+      filteredProcedures = filteredProcedures.filter((procedure) => {
+        // Check if procedure has all specified treatment benefits
+        return filters.treatmentBenefits!.every((benefit) =>
+          procedure.treatmentBenefits.includes(benefit)
         );
+      });
+    }
 
-        // If not found, create basic doctor info
-        if (!doctorInfo) {
-          doctorInfo = {
-            id: practitionerSnapshot.id,
-            name: `${practitioner.basicInfo.firstName} ${practitioner.basicInfo.lastName}`,
-            description: practitioner.basicInfo.bio || "",
-            photo: practitioner.basicInfo.profileImageUrl || "",
-            rating: 0,
-            services: [],
-          };
-        }
+    // Filter by procedure category if specified
+    if (filters.procedureCategory) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.category.id === filters.procedureCategory
+      );
+    }
 
-        // Add to batch
-        batch.update(procedureDoc.ref, {
-          clinicInfo,
-          doctorInfo,
-          updatedAt: serverTimestamp(),
-        });
+    // Filter by procedure subcategory if specified
+    if (filters.procedureSubcategory) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.subcategory.id === filters.procedureSubcategory
+      );
+    }
+
+    // Filter by procedure technology if specified
+    if (filters.procedureTechnology) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.technology.id === filters.procedureTechnology
+      );
+    }
 
-        batchCount++;
-        updatedCount++;
+    // Filter by price range if specified
+    if (filters.minPrice !== undefined) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.price >= filters.minPrice!
+      );
+    }
 
-        // Commit batch if we've reached the limit
-        if (batchCount >= batchLimit) {
-          await batch.commit();
-          console.log(`Committed batch of ${batchCount} procedure updates`);
-          batchCount = 0;
-        }
-      } catch (error) {
-        console.error(`Error updating procedure ${procedure.id}:`, error);
-      }
+    if (filters.maxPrice !== undefined) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.price <= filters.maxPrice!
+      );
     }
 
-    // Commit any remaining updates
-    if (batchCount > 0) {
-      await batch.commit();
-      console.log(`Committed final batch of ${batchCount} procedure updates`);
+    // Filter by rating if specified
+    if (filters.minRating !== undefined) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.reviewInfo.averageRating >= filters.minRating!
+      );
+    }
+
+    if (filters.maxRating !== undefined) {
+      filteredProcedures = filteredProcedures.filter(
+        (procedure) => procedure.reviewInfo.averageRating <= filters.maxRating!
+      );
     }
 
-    return updatedCount;
+    return filteredProcedures;
   }
 }