@blackcode_sa/metaestetics-api 1.13.0 → 1.13.2

package/dist/admin/index.mjs

@@ -616,8 +616,8 @@ var NotificationsAdmin = class {
    * Dohvata notifikaciju po ID-u
    */
   async getNotification(id) {
-    const doc2 = await this.db.collection("notifications").doc(id).get();
-    return doc2.exists ? { id: doc2.id, ...doc2.data() } : null;
+    const doc3 = await this.db.collection("notifications").doc(id).get();
+    return doc3.exists ? { id: doc3.id, ...doc3.data() } : null;
   }
   /**
    * Kreira novu notifikaciju
@@ -804,10 +804,10 @@ var NotificationsAdmin = class {
       return;
     }
     const results = await Promise.allSettled(
-      pendingNotifications.docs.map(async (doc2) => {
+      pendingNotifications.docs.map(async (doc3) => {
         const notification = {
-          id: doc2.id,
-          ...doc2.data()
+          id: doc3.id,
+          ...doc3.data()
         };
         Logger.info(
           `[NotificationsAdmin] Processing notification ${notification.id} of type ${notification.notificationType}`
@@ -848,8 +848,8 @@ var NotificationsAdmin = class {
         break;
       }
       const batch = this.db.batch();
-      oldNotifications.docs.forEach((doc2) => {
-        batch.delete(doc2.ref);
+      oldNotifications.docs.forEach((doc3) => {
+        batch.delete(doc3.ref);
       });
       await batch.commit();
       totalDeleted += oldNotifications.size;
@@ -3537,10 +3537,10 @@ var AppointmentAggregationService = class {
       }
       const batch = this.db.batch();
       let instancesUpdatedCount = 0;
-      instancesSnapshot.docs.forEach((doc2) => {
-        const instance = doc2.data();
+      instancesSnapshot.docs.forEach((doc3) => {
+        const instance = doc3.data();
         if (instance.overallStatus !== newOverallStatus && instance.overallStatus !== "failedToProcess" /* FAILED_TO_PROCESS */) {
-          batch.update(doc2.ref, {
+          batch.update(doc3.ref, {
             overallStatus: newOverallStatus,
             updatedAt: admin6.firestore.FieldValue.serverTimestamp()
             // Cast for now
@@ -3549,7 +3549,7 @@ var AppointmentAggregationService = class {
           });
           instancesUpdatedCount++;
           Logger.debug(
-            `[AggService] Added update for PatientRequirementInstance ${doc2.id} to batch. New status: ${newOverallStatus}`
+            `[AggService] Added update for PatientRequirementInstance ${doc3.id} to batch. New status: ${newOverallStatus}`
           );
         }
       });
@@ -3724,8 +3724,8 @@ var AppointmentAggregationService = class {
   // --- Data Fetching Helpers (Consider moving to a data access layer or using existing services if available) ---
   async fetchPatientProfile(patientId) {
     try {
-      const doc2 = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).get();
-      return doc2.exists ? doc2.data() : null;
+      const doc3 = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).get();
+      return doc3.exists ? doc3.data() : null;
     } catch (error) {
       Logger.error(`[AggService] Error fetching patient profile ${patientId}:`, error);
       return null;
@@ -3738,12 +3738,12 @@ var AppointmentAggregationService = class {
    */
   async fetchPatientSensitiveInfo(patientId) {
     try {
-      const doc2 = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).collection(PATIENT_SENSITIVE_INFO_COLLECTION).doc(patientId).get();
-      if (!doc2.exists) {
+      const doc3 = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).collection(PATIENT_SENSITIVE_INFO_COLLECTION).doc(patientId).get();
+      if (!doc3.exists) {
         Logger.warn(`[AggService] No sensitive info found for patient ${patientId}`);
         return null;
       }
-      return doc2.data();
+      return doc3.data();
     } catch (error) {
       Logger.error(`[AggService] Error fetching patient sensitive info ${patientId}:`, error);
       return null;
@@ -3760,12 +3760,12 @@ var AppointmentAggregationService = class {
       return null;
     }
     try {
-      const doc2 = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
-      if (!doc2.exists) {
+      const doc3 = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
+      if (!doc3.exists) {
         Logger.warn(`[AggService] No practitioner profile found for ID ${practitionerId}`);
         return null;
       }
-      return doc2.data();
+      return doc3.data();
     } catch (error) {
       Logger.error(`[AggService] Error fetching practitioner profile ${practitionerId}:`, error);
       return null;
@@ -3782,12 +3782,12 @@ var AppointmentAggregationService = class {
       return null;
     }
     try {
-      const doc2 = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
-      if (!doc2.exists) {
+      const doc3 = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
+      if (!doc3.exists) {
         Logger.warn(`[AggService] No clinic info found for ID ${clinicId}`);
         return null;
       }
-      return doc2.data();
+      return doc3.data();
     } catch (error) {
       Logger.error(`[AggService] Error fetching clinic info ${clinicId}:`, error);
       return null;
@@ -4254,11 +4254,11 @@ var ClinicAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc2) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[ClinicAggregationService] Updating location for calendar event ${doc2.ref.path}`
+          `[ClinicAggregationService] Updating location for calendar event ${doc3.ref.path}`
         );
-        batch.update(doc2.ref, {
+        batch.update(doc3.ref, {
           eventLocation: newLocation,
           updatedAt: admin7.firestore.FieldValue.serverTimestamp()
         });
@@ -4301,11 +4301,11 @@ var ClinicAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc2) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[ClinicAggregationService] Updating clinic info for calendar event ${doc2.ref.path}`
+          `[ClinicAggregationService] Updating clinic info for calendar event ${doc3.ref.path}`
         );
-        batch.update(doc2.ref, {
+        batch.update(doc3.ref, {
           clinicInfo,
           updatedAt: admin7.firestore.FieldValue.serverTimestamp()
         });
@@ -4516,11 +4516,11 @@ var ClinicAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc2) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[ClinicAggregationService] Canceling calendar event ${doc2.ref.path}`
+          `[ClinicAggregationService] Canceling calendar event ${doc3.ref.path}`
         );
-        batch.update(doc2.ref, {
+        batch.update(doc3.ref, {
           status: "CANCELED",
           cancelReason: "Clinic deleted",
           updatedAt: admin7.firestore.FieldValue.serverTimestamp()
@@ -4788,11 +4788,11 @@ var PatientAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc2) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[PatientAggregationService] Updating patient info for calendar event ${doc2.ref.path}`
+          `[PatientAggregationService] Updating patient info for calendar event ${doc3.ref.path}`
         );
-        batch.update(doc2.ref, {
+        batch.update(doc3.ref, {
           patientInfo,
           updatedAt: admin9.firestore.FieldValue.serverTimestamp()
         });
@@ -4836,11 +4836,11 @@ var PatientAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc2) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[PatientAggregationService] Canceling calendar event ${doc2.ref.path}`
+          `[PatientAggregationService] Canceling calendar event ${doc3.ref.path}`
         );
-        batch.update(doc2.ref, {
+        batch.update(doc3.ref, {
           status: "CANCELED",
           cancelReason: "Patient deleted",
           updatedAt: admin9.firestore.FieldValue.serverTimestamp()
@@ -5011,11 +5011,11 @@ var PractitionerAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc2) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[PractitionerAggregationService] Updating practitioner info for calendar event ${doc2.ref.path}`
+          `[PractitionerAggregationService] Updating practitioner info for calendar event ${doc3.ref.path}`
         );
-        batch.update(doc2.ref, {
+        batch.update(doc3.ref, {
           practitionerInfo,
           updatedAt: admin10.firestore.FieldValue.serverTimestamp()
         });
@@ -5099,11 +5099,11 @@ var PractitionerAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc2) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[PractitionerAggregationService] Canceling calendar event ${doc2.ref.path}`
+          `[PractitionerAggregationService] Canceling calendar event ${doc3.ref.path}`
         );
-        batch.update(doc2.ref, {
+        batch.update(doc3.ref, {
           status: "CANCELED",
           cancelReason: "Practitioner deleted",
           updatedAt: admin10.firestore.FieldValue.serverTimestamp()
@@ -5655,8 +5655,8 @@ var PractitionerInviteAggregationService = class {
    */
   async fetchClinicAdminById(adminId) {
     try {
-      const doc2 = await this.db.collection(CLINIC_ADMINS_COLLECTION).doc(adminId).get();
-      return doc2.exists ? doc2.data() : null;
+      const doc3 = await this.db.collection(CLINIC_ADMINS_COLLECTION).doc(adminId).get();
+      return doc3.exists ? doc3.data() : null;
     } catch (error) {
       Logger.error(
         `[PractitionerInviteAggService] Error fetching clinic admin ${adminId}:`,
@@ -5672,8 +5672,8 @@ var PractitionerInviteAggregationService = class {
    */
   async fetchPractitionerById(practitionerId) {
     try {
-      const doc2 = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
-      return doc2.exists ? doc2.data() : null;
+      const doc3 = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
+      return doc3.exists ? doc3.data() : null;
     } catch (error) {
       Logger.error(
         `[PractitionerInviteAggService] Error fetching practitioner ${practitionerId}:`,
@@ -5689,8 +5689,8 @@ var PractitionerInviteAggregationService = class {
    */
   async fetchClinicById(clinicId) {
     try {
-      const doc2 = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
-      return doc2.exists ? doc2.data() : null;
+      const doc3 = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
+      return doc3.exists ? doc3.data() : null;
     } catch (error) {
       Logger.error(
         `[PractitionerInviteAggService] Error fetching clinic ${clinicId}:`,
@@ -6125,11 +6125,11 @@ var ProcedureAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc2) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[ProcedureAggregationService] Updating procedure info for calendar event ${doc2.ref.path}`
+          `[ProcedureAggregationService] Updating procedure info for calendar event ${doc3.ref.path}`
         );
-        batch.update(doc2.ref, {
+        batch.update(doc3.ref, {
           procedureInfo,
           updatedAt: admin12.firestore.FieldValue.serverTimestamp()
         });
@@ -6172,11 +6172,11 @@ var ProcedureAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc2) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[ProcedureAggregationService] Canceling calendar event ${doc2.ref.path}`
+          `[ProcedureAggregationService] Canceling calendar event ${doc3.ref.path}`
         );
-        batch.update(doc2.ref, {
+        batch.update(doc3.ref, {
           status: "CANCELED",
           cancelReason: "Procedure deleted or inactivated",
           updatedAt: admin12.firestore.FieldValue.serverTimestamp()
@@ -6557,7 +6557,7 @@ var ReviewsAggregationService = class {
       );
       return updatedReviewInfo2;
     }
-    const reviews = reviewsQuery.docs.map((doc2) => doc2.data());
+    const reviews = reviewsQuery.docs.map((doc3) => doc3.data());
     const clinicReviews = reviews.map((review) => review.clinicReview).filter((review) => review !== void 0);
     let totalRating = 0;
     let totalCleanliness = 0;
@@ -6647,7 +6647,7 @@ var ReviewsAggregationService = class {
       );
       return updatedReviewInfo2;
     }
-    const reviews = reviewsQuery.docs.map((doc2) => doc2.data());
+    const reviews = reviewsQuery.docs.map((doc3) => doc3.data());
     const practitionerReviews = reviews.map((review) => review.practitionerReview).filter((review) => review !== void 0);
     let totalRating = 0;
     let totalKnowledgeAndExpertise = 0;
@@ -6720,7 +6720,7 @@ var ReviewsAggregationService = class {
       recommendationPercentage: 0
     };
     const allReviewsQuery = await this.db.collection(REVIEWS_COLLECTION).get();
-    const reviews = allReviewsQuery.docs.map((doc2) => doc2.data());
+    const reviews = allReviewsQuery.docs.map((doc3) => doc3.data());
     const procedureReviews = [];
     reviews.forEach((review) => {
       if (review.procedureReview && review.procedureReview.procedureId === procedureId) {
@@ -6890,7 +6890,7 @@ var ReviewsAggregationService = class {
 import * as admin14 from "firebase-admin";
 
 // src/services/analytics/analytics.service.ts
-import { where, Timestamp as Timestamp2 } from "firebase/firestore";
+import { where as where2, Timestamp as Timestamp3 } from "firebase/firestore";
 
 // src/services/base.service.ts
 import { getStorage } from "firebase/storage";
@@ -6990,7 +6990,9 @@ function extractProductUsage(appointment) {
       if (item.type === "item" && item.productId) {
         const price = item.priceOverrideAmount || item.price || 0;
         const quantity = item.quantity || 1;
-        const subtotal = item.subtotal || price * quantity;
+        const calculatedSubtotal = price * quantity;
+        const storedSubtotal = item.subtotal || 0;
+        const subtotal = Math.abs(storedSubtotal - calculatedSubtotal) < 0.01 ? storedSubtotal : calculatedSubtotal;
         products.push({
           productId: item.productId,
           productName: item.productName || "Unknown Product",
@@ -7119,6 +7121,17 @@ function calculateCancellationLeadTime(appointment) {
 }
 
 // src/services/analytics/utils/appointment-filtering.utils.ts
+function filterByDateRange(appointments, dateRange) {
+  if (!dateRange) {
+    return appointments;
+  }
+  const startTime = dateRange.start.getTime();
+  const endTime = dateRange.end.getTime();
+  return appointments.filter((appointment) => {
+    const appointmentTime = appointment.appointmentStartTime.toMillis();
+    return appointmentTime >= startTime && appointmentTime <= endTime;
+  });
+}
 function filterAppointments(appointments, filters) {
   if (!filters) {
     return appointments;
@@ -7394,6 +7407,7 @@ function calculateGroupedRevenueMetrics(appointments, entityType) {
   const entityMap = groupAppointmentsByEntity(appointments, entityType);
   const completed = getCompletedAppointments(appointments);
   return Array.from(entityMap.entries()).map(([entityId, data]) => {
+    var _a;
     const entityAppointments = data.appointments;
     const entityCompleted = entityAppointments.filter(
       (a) => completed.some((c) => c.id === a.id)
@@ -7417,6 +7431,13 @@ function calculateGroupedRevenueMetrics(appointments, entityType) {
         refundedRevenue += costData.cost;
       }
     });
+    let practitionerId;
+    let practitionerName;
+    if (entityType === "procedure" && entityAppointments.length > 0) {
+      const firstAppointment = entityAppointments[0];
+      practitionerId = firstAppointment.practitionerId;
+      practitionerName = (_a = firstAppointment.practitionerInfo) == null ? void 0 : _a.name;
+    }
     return {
       entityId,
       entityName: data.name,
@@ -7429,7 +7450,9 @@ function calculateGroupedRevenueMetrics(appointments, entityType) {
       unpaidRevenue,
       refundedRevenue,
       totalTax,
-      totalSubtotal
+      totalSubtotal,
+      ...practitionerId && { practitionerId },
+      ...practitionerName && { practitionerName }
     };
   });
 }
@@ -7437,6 +7460,7 @@ function calculateGroupedProductUsageMetrics(appointments, entityType) {
   const entityMap = groupAppointmentsByEntity(appointments, entityType);
   const completed = getCompletedAppointments(appointments);
   return Array.from(entityMap.entries()).map(([entityId, data]) => {
+    var _a;
     const entityAppointments = data.appointments;
     const entityCompleted = entityAppointments.filter(
       (a) => completed.some((c) => c.id === a.id)
@@ -7471,6 +7495,13 @@ function calculateGroupedProductUsageMetrics(appointments, entityType) {
     })).sort((a, b) => b.totalRevenue - a.totalRevenue).slice(0, 10);
     const totalProductRevenue = topProducts.reduce((sum, p) => sum + p.totalRevenue, 0);
     const totalProductQuantity = topProducts.reduce((sum, p) => sum + p.totalQuantity, 0);
+    let practitionerId;
+    let practitionerName;
+    if (entityType === "procedure" && entityAppointments.length > 0) {
+      const firstAppointment = entityAppointments[0];
+      practitionerId = firstAppointment.practitionerId;
+      practitionerName = (_a = firstAppointment.practitionerInfo) == null ? void 0 : _a.name;
+    }
     return {
       entityId,
       entityName: data.name,
@@ -7480,7 +7511,9 @@ function calculateGroupedProductUsageMetrics(appointments, entityType) {
       totalProductRevenue,
       totalProductQuantity,
       averageProductsPerAppointment: entityCompleted.length > 0 ? productMap.size / entityCompleted.length : 0,
-      topProducts
+      topProducts,
+      ...practitionerId && { practitionerId },
+      ...practitionerName && { practitionerName }
     };
   });
 }
@@ -7488,11 +7521,19 @@ function calculateGroupedTimeEfficiencyMetrics(appointments, entityType) {
   const entityMap = groupAppointmentsByEntity(appointments, entityType);
   const completed = getCompletedAppointments(appointments);
   return Array.from(entityMap.entries()).map(([entityId, data]) => {
+    var _a;
     const entityAppointments = data.appointments;
     const entityCompleted = entityAppointments.filter(
       (a) => completed.some((c) => c.id === a.id)
     );
     const timeMetrics = calculateAverageTimeMetrics(entityCompleted);
+    let practitionerId;
+    let practitionerName;
+    if (entityType === "procedure" && entityAppointments.length > 0) {
+      const firstAppointment = entityAppointments[0];
+      practitionerId = firstAppointment.practitionerId;
+      practitionerName = (_a = firstAppointment.practitionerInfo) == null ? void 0 : _a.name;
+    }
     return {
       entityId,
       entityName: data.name,
@@ -7505,7 +7546,9 @@ function calculateGroupedTimeEfficiencyMetrics(appointments, entityType) {
       totalOverrun: timeMetrics.totalOverrun,
       totalUnderutilization: timeMetrics.totalUnderutilization,
       averageOverrun: timeMetrics.averageOverrun,
-      averageUnderutilization: timeMetrics.averageUnderutilization
+      averageUnderutilization: timeMetrics.averageUnderutilization,
+      ...practitionerId && { practitionerId },
+      ...practitionerName && { practitionerName }
     };
   });
 }
@@ -7587,6 +7630,763 @@ function calculateGroupedPatientBehaviorMetrics(appointments, entityType) {
   });
 }
 
+// src/services/analytics/utils/trend-calculation.utils.ts
+function getPeriodDates(date, period) {
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const day = date.getDate();
+  let startDate;
+  let endDate;
+  let periodString;
+  switch (period) {
+    case "week": {
+      const dayOfWeek = date.getDay();
+      const diff = date.getDate() - dayOfWeek + (dayOfWeek === 0 ? -6 : 1);
+      startDate = new Date(year, month, diff);
+      startDate.setHours(0, 0, 0, 0);
+      endDate = new Date(startDate);
+      endDate.setDate(endDate.getDate() + 6);
+      endDate.setHours(23, 59, 59, 999);
+      const weekNumber = getWeekNumber(date);
+      periodString = `${year}-W${weekNumber.toString().padStart(2, "0")}`;
+      break;
+    }
+    case "month": {
+      startDate = new Date(year, month, 1);
+      startDate.setHours(0, 0, 0, 0);
+      endDate = new Date(year, month + 1, 0);
+      endDate.setHours(23, 59, 59, 999);
+      periodString = `${year}-${(month + 1).toString().padStart(2, "0")}`;
+      break;
+    }
+    case "quarter": {
+      const quarter = Math.floor(month / 3);
+      const quarterStartMonth = quarter * 3;
+      startDate = new Date(year, quarterStartMonth, 1);
+      startDate.setHours(0, 0, 0, 0);
+      endDate = new Date(year, quarterStartMonth + 3, 0);
+      endDate.setHours(23, 59, 59, 999);
+      periodString = `${year}-Q${quarter + 1}`;
+      break;
+    }
+    case "year": {
+      startDate = new Date(year, 0, 1);
+      startDate.setHours(0, 0, 0, 0);
+      endDate = new Date(year, 11, 31);
+      endDate.setHours(23, 59, 59, 999);
+      periodString = `${year}`;
+      break;
+    }
+  }
+  return {
+    period: periodString,
+    startDate,
+    endDate
+  };
+}
+function getWeekNumber(date) {
+  const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+  const dayNum = d.getUTCDay() || 7;
+  d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+  return Math.ceil(((d.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+}
+function groupAppointmentsByPeriod(appointments, period) {
+  const periodMap = /* @__PURE__ */ new Map();
+  appointments.forEach((appointment) => {
+    const appointmentDate = appointment.appointmentStartTime.toDate();
+    const periodInfo = getPeriodDates(appointmentDate, period);
+    const periodKey = periodInfo.period;
+    if (!periodMap.has(periodKey)) {
+      periodMap.set(periodKey, []);
+    }
+    periodMap.get(periodKey).push(appointment);
+  });
+  return periodMap;
+}
+function generatePeriods(startDate, endDate, period) {
+  const periods = [];
+  const current = new Date(startDate);
+  while (current <= endDate) {
+    const periodInfo = getPeriodDates(current, period);
+    if (periodInfo.endDate >= startDate && periodInfo.startDate <= endDate) {
+      periods.push(periodInfo);
+    }
+    switch (period) {
+      case "week":
+        current.setDate(current.getDate() + 7);
+        break;
+      case "month":
+        current.setMonth(current.getMonth() + 1);
+        break;
+      case "quarter":
+        current.setMonth(current.getMonth() + 3);
+        break;
+      case "year":
+        current.setFullYear(current.getFullYear() + 1);
+        break;
+    }
+  }
+  return periods.sort((a, b) => a.startDate.getTime() - b.startDate.getTime());
+}
+function calculatePercentageChange(current, previous) {
+  if (previous === 0) {
+    return current > 0 ? 100 : 0;
+  }
+  return (current - previous) / previous * 100;
+}
+function getTrendChange(current, previous) {
+  const percentageChange = calculatePercentageChange(current, previous);
+  const direction = percentageChange > 0.01 ? "up" : percentageChange < -0.01 ? "down" : "stable";
+  return {
+    value: current,
+    previousValue: previous,
+    percentageChange: Math.abs(percentageChange),
+    direction
+  };
+}
+
+// src/services/analytics/review-analytics.service.ts
+import { collection, query, where, getDocs, getDoc as getDoc2, doc as doc2, Timestamp as Timestamp2 } from "firebase/firestore";
+var ReviewAnalyticsService = class extends BaseService {
+  constructor(db, auth, app, appointmentService) {
+    super(db, auth, app);
+    this.appointmentService = appointmentService;
+  }
+  /**
+   * Fetches reviews filtered by date range and optional filters
+   * Properly filters by clinic branch by checking appointment's clinicId
+   */
+  async fetchReviews(dateRange, filters) {
+    let q = query(collection(this.db, REVIEWS_COLLECTION));
+    if (dateRange) {
+      const startTimestamp = Timestamp2.fromDate(dateRange.start);
+      const endTimestamp = Timestamp2.fromDate(dateRange.end);
+      q = query(q, where("createdAt", ">=", startTimestamp), where("createdAt", "<=", endTimestamp));
+    }
+    const snapshot = await getDocs(q);
+    const reviews = snapshot.docs.map((doc3) => {
+      var _a, _b;
+      const data = doc3.data();
+      return {
+        ...data,
+        id: doc3.id,
+        createdAt: ((_a = data.createdAt) == null ? void 0 : _a.toDate) ? data.createdAt.toDate() : new Date(data.createdAt),
+        updatedAt: ((_b = data.updatedAt) == null ? void 0 : _b.toDate) ? data.updatedAt.toDate() : new Date(data.updatedAt)
+      };
+    });
+    console.log(`[ReviewAnalytics] Fetched ${reviews.length} reviews in date range`);
+    if ((filters == null ? void 0 : filters.clinicBranchId) && reviews.length > 0) {
+      const appointmentIds = [...new Set(reviews.map((r) => r.appointmentId))];
+      console.log(`[ReviewAnalytics] Filtering by clinic ${filters.clinicBranchId}, checking ${appointmentIds.length} appointments`);
+      const validAppointmentIds = /* @__PURE__ */ new Set();
+      for (let i = 0; i < appointmentIds.length; i += 10) {
+        const batch = appointmentIds.slice(i, i + 10);
+        const appointmentsQuery = query(
+          collection(this.db, APPOINTMENTS_COLLECTION),
+          where("id", "in", batch)
+        );
+        const appointmentSnapshot = await getDocs(appointmentsQuery);
+        appointmentSnapshot.docs.forEach((doc3) => {
+          const appointment = doc3.data();
+          if (appointment.clinicBranchId === filters.clinicBranchId) {
+            validAppointmentIds.add(doc3.id);
+          }
+        });
+      }
+      const filteredReviews = reviews.filter((review) => validAppointmentIds.has(review.appointmentId));
+      console.log(`[ReviewAnalytics] After clinic filter: ${filteredReviews.length} reviews (from ${validAppointmentIds.size} valid appointments)`);
+      return filteredReviews;
+    }
+    return reviews;
+  }
+  /**
+   * Gets review metrics for a specific entity
+   */
+  async getReviewMetricsByEntity(entityType, entityId, dateRange, filters) {
+    const reviews = await this.fetchReviews(dateRange, filters);
+    let relevantReviews = [];
+    if (entityType === "practitioner") {
+      relevantReviews = reviews.filter((r) => {
+        var _a;
+        return ((_a = r.practitionerReview) == null ? void 0 : _a.practitionerId) === entityId;
+      });
+    } else if (entityType === "procedure") {
+      relevantReviews = reviews.filter((r) => {
+        var _a;
+        return ((_a = r.procedureReview) == null ? void 0 : _a.procedureId) === entityId;
+      });
+    } else if (entityType === "category" || entityType === "subcategory") {
+      relevantReviews = reviews;
+    }
+    if (relevantReviews.length === 0) {
+      return null;
+    }
+    return this.calculateReviewMetrics(relevantReviews, entityType, entityId);
+  }
+  /**
+   * Gets review metrics for multiple entities (grouped)
+   */
+  async getReviewMetricsByEntities(entityType, dateRange, filters) {
+    const reviews = await this.fetchReviews(dateRange, filters);
+    const entityMap = /* @__PURE__ */ new Map();
+    let practitionerNameMap = null;
+    let procedureNameMap = null;
+    let procedureToTechnologyMap = null;
+    if (entityType === "practitioner" || entityType === "procedure" || entityType === "technology") {
+      if (!this.appointmentService) {
+        console.warn(`[ReviewAnalytics] AppointmentService not available for ${entityType} name resolution`);
+        return [];
+      }
+      console.log(`[ReviewAnalytics] Grouping by ${entityType}, fetching appointments for name resolution...`);
+      const searchParams = {
+        ...filters
+      };
+      if (dateRange) {
+        searchParams.startDate = dateRange.start;
+        searchParams.endDate = dateRange.end;
+      }
+      const appointmentsResult = await this.appointmentService.searchAppointments(searchParams);
+      const appointments = appointmentsResult.appointments || [];
+      console.log(`[ReviewAnalytics] Found ${appointments.length} appointments for name resolution`);
+      practitionerNameMap = /* @__PURE__ */ new Map();
+      procedureNameMap = /* @__PURE__ */ new Map();
+      procedureToTechnologyMap = /* @__PURE__ */ new Map();
+      appointments.forEach((appointment) => {
+        var _a, _b, _c, _d, _e, _f;
+        if (appointment.practitionerId && ((_a = appointment.practitionerInfo) == null ? void 0 : _a.name)) {
+          practitionerNameMap.set(appointment.practitionerId, appointment.practitionerInfo.name);
+        }
+        if (appointment.procedureId) {
+          if ((_b = appointment.procedureInfo) == null ? void 0 : _b.name) {
+            procedureNameMap.set(appointment.procedureId, appointment.procedureInfo.name);
+          }
+          const mainTechnologyId = ((_c = appointment.procedureExtendedInfo) == null ? void 0 : _c.procedureTechnologyId) || "unknown-technology";
+          const mainTechnologyName = ((_d = appointment.procedureExtendedInfo) == null ? void 0 : _d.procedureTechnologyName) || ((_e = appointment.procedureInfo) == null ? void 0 : _e.name) || "Unknown Technology";
+          procedureToTechnologyMap.set(appointment.procedureId, {
+            id: mainTechnologyId,
+            name: mainTechnologyName
+          });
+        }
+        if ((_f = appointment.metadata) == null ? void 0 : _f.extendedProcedures) {
+          appointment.metadata.extendedProcedures.forEach((extendedProc) => {
+            if (extendedProc.procedureId) {
+              if (extendedProc.procedureName) {
+                procedureNameMap.set(extendedProc.procedureId, extendedProc.procedureName);
+              }
+              const extTechnologyId = extendedProc.procedureTechnologyId || "unknown-technology";
+              const extTechnologyName = extendedProc.procedureTechnologyName || "Unknown Technology";
+              procedureToTechnologyMap.set(extendedProc.procedureId, {
+                id: extTechnologyId,
+                name: extTechnologyName
+              });
+            }
+          });
+        }
+      });
+      console.log(`[ReviewAnalytics] Built name maps: ${practitionerNameMap.size} practitioners, ${procedureNameMap.size} procedures, ${procedureToTechnologyMap.size} technologies`);
+    }
+    if (entityType === "technology" && procedureToTechnologyMap) {
+      let processedReviewCount = 0;
+      reviews.forEach((review) => {
+        var _a;
+        if ((_a = review.procedureReview) == null ? void 0 : _a.procedureId) {
+          const techInfo = procedureToTechnologyMap.get(review.procedureReview.procedureId);
+          if (techInfo) {
+            if (!entityMap.has(techInfo.id)) {
+              entityMap.set(techInfo.id, { reviews: [], name: techInfo.name });
+            }
+            entityMap.get(techInfo.id).reviews.push(review);
+            processedReviewCount++;
+          }
+        }
+        if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
+          review.extendedProcedureReviews.forEach((extendedReview) => {
+            if (extendedReview.procedureId) {
+              const techInfo = procedureToTechnologyMap.get(extendedReview.procedureId);
+              if (techInfo) {
+                if (!entityMap.has(techInfo.id)) {
+                  entityMap.set(techInfo.id, { reviews: [], name: techInfo.name });
+                }
+                const reviewWithExtendedOnly = {
+                  ...review,
+                  procedureReview: extendedReview,
+                  extendedProcedureReviews: void 0
+                };
+                entityMap.get(techInfo.id).reviews.push(reviewWithExtendedOnly);
+                processedReviewCount++;
+              }
+            }
+          });
+        }
+      });
+      console.log(`[ReviewAnalytics] Processed ${processedReviewCount} procedure reviews into ${entityMap.size} technology groups`);
+      entityMap.forEach((data, techId) => {
+        console.log(`[ReviewAnalytics]   - ${data.name} (${techId}): ${data.reviews.length} reviews`);
+      });
+    } else if (entityType === "procedure" && procedureNameMap) {
+      let processedReviewCount = 0;
+      reviews.forEach((review) => {
+        if (review.procedureReview) {
+          const procedureId = review.procedureReview.procedureId;
+          const procedureName = procedureId && procedureNameMap.get(procedureId) || review.procedureReview.procedureName || "Unknown Procedure";
+          if (procedureId) {
+            if (!entityMap.has(procedureId)) {
+              entityMap.set(procedureId, { reviews: [], name: procedureName });
+            }
+            entityMap.get(procedureId).reviews.push(review);
+            processedReviewCount++;
+          }
+        }
+        if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
+          review.extendedProcedureReviews.forEach((extendedReview) => {
+            const procedureId = extendedReview.procedureId;
+            const procedureName = procedureId && procedureNameMap.get(procedureId) || extendedReview.procedureName || "Unknown Procedure";
+            if (procedureId) {
+              if (!entityMap.has(procedureId)) {
+                entityMap.set(procedureId, { reviews: [], name: procedureName });
+              }
+              const reviewWithExtendedOnly = {
+                ...review,
+                procedureReview: extendedReview,
+                extendedProcedureReviews: void 0
+              };
+              entityMap.get(procedureId).reviews.push(reviewWithExtendedOnly);
+              processedReviewCount++;
+            }
+          });
+        }
+      });
+      console.log(`[ReviewAnalytics] Processed ${processedReviewCount} procedure reviews into ${entityMap.size} procedure groups`);
+      entityMap.forEach((data, procId) => {
+        console.log(`[ReviewAnalytics]   - ${data.name} (${procId}): ${data.reviews.length} reviews`);
+      });
+    } else if (entityType === "practitioner" && practitionerNameMap) {
+      reviews.forEach((review) => {
+        if (review.practitionerReview) {
+          const practitionerId = review.practitionerReview.practitionerId;
+          const practitionerName = practitionerId && practitionerNameMap.get(practitionerId) || review.practitionerReview.practitionerName || "Unknown Practitioner";
+          if (practitionerId) {
+            if (!entityMap.has(practitionerId)) {
+              entityMap.set(practitionerId, { reviews: [], name: practitionerName });
+            }
+            entityMap.get(practitionerId).reviews.push(review);
+          }
+        }
+      });
+      console.log(`[ReviewAnalytics] Processed ${reviews.length} reviews into ${entityMap.size} practitioner groups`);
+      entityMap.forEach((data, practId) => {
+        console.log(`[ReviewAnalytics]   - ${data.name} (${practId}): ${data.reviews.length} reviews`);
+      });
+    } else {
+      reviews.forEach((review) => {
+        let entityId;
+        let entityName;
+        if (entityId) {
+          if (!entityMap.has(entityId)) {
+            entityMap.set(entityId, { reviews: [], name: entityName || entityId });
+          }
+          entityMap.get(entityId).reviews.push(review);
+        }
+      });
+    }
+    const metrics = [];
+    for (const [entityId, data] of entityMap.entries()) {
+      const metric = this.calculateReviewMetrics(data.reviews, entityType, entityId);
+      if (metric) {
+        metric.entityName = data.name;
+        metrics.push(metric);
+      }
+    }
+    return metrics;
+  }
+  /**
+   * Calculates review metrics from a list of reviews
+   */
+  calculateReviewMetrics(reviews, entityType, entityId) {
+    if (reviews.length === 0) {
+      return null;
+    }
+    let totalRating = 0;
+    let recommendationCount = 0;
+    let practitionerMetrics;
+    let procedureMetrics;
+    let entityName = entityId;
+    if (entityType === "practitioner") {
+      const practitionerReviews = reviews.filter((r) => r.practitionerReview).map((r) => r.practitionerReview);
+      if (practitionerReviews.length === 0) {
+        return null;
+      }
+      entityName = practitionerReviews[0].practitionerName || entityId;
+      totalRating = practitionerReviews.reduce((sum, r) => sum + r.overallRating, 0);
+      recommendationCount = practitionerReviews.filter((r) => r.wouldRecommend).length;
+      practitionerMetrics = {
+        averageKnowledgeAndExpertise: this.calculateAverage(practitionerReviews.map((r) => r.knowledgeAndExpertise)),
+        averageCommunicationSkills: this.calculateAverage(practitionerReviews.map((r) => r.communicationSkills)),
+        averageBedSideManner: this.calculateAverage(practitionerReviews.map((r) => r.bedSideManner)),
+        averageThoroughness: this.calculateAverage(practitionerReviews.map((r) => r.thoroughness)),
+        averageTrustworthiness: this.calculateAverage(practitionerReviews.map((r) => r.trustworthiness))
+      };
+    } else if (entityType === "procedure" || entityType === "technology") {
+      const procedureReviews = reviews.filter((r) => r.procedureReview).map((r) => r.procedureReview);
+      if (procedureReviews.length === 0) {
+        return null;
+      }
+      if (entityType === "procedure") {
+        entityName = procedureReviews[0].procedureName || entityId;
+      }
+      totalRating = procedureReviews.reduce((sum, r) => sum + r.overallRating, 0);
+      recommendationCount = procedureReviews.filter((r) => r.wouldRecommend).length;
+      procedureMetrics = {
+        averageEffectiveness: this.calculateAverage(procedureReviews.map((r) => r.effectivenessOfTreatment)),
+        averageOutcomeExplanation: this.calculateAverage(procedureReviews.map((r) => r.outcomeExplanation)),
+        averagePainManagement: this.calculateAverage(procedureReviews.map((r) => r.painManagement)),
+        averageFollowUpCare: this.calculateAverage(procedureReviews.map((r) => r.followUpCare)),
+        averageValueForMoney: this.calculateAverage(procedureReviews.map((r) => r.valueForMoney))
+      };
+    }
+    const averageRating = totalRating / reviews.length;
+    const recommendationRate = recommendationCount / reviews.length * 100;
+    const result = {
+      entityId,
+      entityName,
+      entityType,
+      totalReviews: reviews.length,
+      averageRating,
+      recommendationRate,
+      practitionerMetrics,
+      procedureMetrics,
+      comparisonToOverall: {
+        ratingDifference: 0,
+        // Will be calculated when comparing to overall
+        recommendationDifference: 0
+      }
+    };
+    return result;
+  }
+  /**
+   * Gets overall review averages for comparison
+   */
+  async getOverallReviewAverages(dateRange, filters) {
+    const reviews = await this.fetchReviews(dateRange, filters);
+    const practitionerReviews = reviews.filter((r) => r.practitionerReview).map((r) => r.practitionerReview);
+    const procedureReviews = reviews.filter((r) => r.procedureReview).map((r) => r.procedureReview);
+    return {
+      practitionerAverage: {
+        totalReviews: practitionerReviews.length,
+        averageRating: practitionerReviews.length > 0 ? this.calculateAverage(practitionerReviews.map((r) => r.overallRating)) : 0,
+        recommendationRate: practitionerReviews.length > 0 ? practitionerReviews.filter((r) => r.wouldRecommend).length / practitionerReviews.length * 100 : 0,
+        averageKnowledgeAndExpertise: this.calculateAverage(practitionerReviews.map((r) => r.knowledgeAndExpertise)),
+        averageCommunicationSkills: this.calculateAverage(practitionerReviews.map((r) => r.communicationSkills)),
+        averageBedSideManner: this.calculateAverage(practitionerReviews.map((r) => r.bedSideManner)),
+        averageThoroughness: this.calculateAverage(practitionerReviews.map((r) => r.thoroughness)),
+        averageTrustworthiness: this.calculateAverage(practitionerReviews.map((r) => r.trustworthiness))
+      },
+      procedureAverage: {
+        totalReviews: procedureReviews.length,
+        averageRating: procedureReviews.length > 0 ? this.calculateAverage(procedureReviews.map((r) => r.overallRating)) : 0,
+        recommendationRate: procedureReviews.length > 0 ? procedureReviews.filter((r) => r.wouldRecommend).length / procedureReviews.length * 100 : 0,
+        averageEffectiveness: this.calculateAverage(procedureReviews.map((r) => r.effectivenessOfTreatment)),
+        averageOutcomeExplanation: this.calculateAverage(procedureReviews.map((r) => r.outcomeExplanation)),
+        averagePainManagement: this.calculateAverage(procedureReviews.map((r) => r.painManagement)),
+        averageFollowUpCare: this.calculateAverage(procedureReviews.map((r) => r.followUpCare)),
+        averageValueForMoney: this.calculateAverage(procedureReviews.map((r) => r.valueForMoney))
+      }
+    };
+  }
+  /**
+   * Gets review details for a specific entity
+   */
+  async getReviewDetails(entityType, entityId, dateRange, filters) {
+    var _a, _b, _c;
+    const reviews = await this.fetchReviews(dateRange, filters);
+    let relevantReviews = [];
+    if (entityType === "practitioner") {
+      relevantReviews = reviews.filter((r) => {
+        var _a2;
+        return ((_a2 = r.practitionerReview) == null ? void 0 : _a2.practitionerId) === entityId;
+      });
+    } else if (entityType === "procedure") {
+      relevantReviews = reviews.filter((r) => {
+        var _a2;
+        return ((_a2 = r.procedureReview) == null ? void 0 : _a2.procedureId) === entityId;
+      });
+    }
+    const details = [];
+    for (const review of relevantReviews) {
+      try {
+        const appointmentDocRef = doc2(this.db, APPOINTMENTS_COLLECTION, review.appointmentId);
+        const appointmentDoc = await getDoc2(appointmentDocRef);
+        let appointment = null;
+        if (appointmentDoc.exists()) {
+          appointment = appointmentDoc.data();
+        }
+        const createdAt = review.createdAt instanceof Timestamp2 ? review.createdAt.toDate() : new Date(review.createdAt);
+        const appointmentDate = (appointment == null ? void 0 : appointment.appointmentStartTime) ? appointment.appointmentStartTime instanceof Timestamp2 ? appointment.appointmentStartTime.toDate() : appointment.appointmentStartTime : createdAt;
+        details.push({
+          reviewId: review.id,
+          appointmentId: review.appointmentId,
+          patientId: review.patientId,
+          patientName: review.patientName || ((_a = appointment == null ? void 0 : appointment.patientInfo) == null ? void 0 : _a.fullName),
+          createdAt,
+          practitionerReview: review.practitionerReview,
+          procedureReview: review.procedureReview,
+          procedureName: (_b = appointment == null ? void 0 : appointment.procedureInfo) == null ? void 0 : _b.name,
+          practitionerName: (_c = appointment == null ? void 0 : appointment.practitionerInfo) == null ? void 0 : _c.name,
+          appointmentDate
+        });
+      } catch (error) {
+        console.warn(`Failed to enhance review ${review.id}:`, error);
+      }
+    }
+    return details;
+  }
+  /**
+   * Helper method to calculate average
+   */
+  calculateAverage(values) {
+    if (values.length === 0) return 0;
+    const sum = values.reduce((acc, val) => acc + val, 0);
+    return sum / values.length;
+  }
+  /**
+   * Calculate review trends over time
+   * Groups reviews by period and calculates rating and recommendation metrics
+   * 
+   * @param dateRange - Date range for trend analysis (must align with period boundaries)
+   * @param period - Period type (week, month, quarter, year)
+   * @param filters - Optional filters for clinic, practitioner, procedure
+   * @param entityType - Optional entity type to group trends by (practitioner, procedure, technology)
+   * @returns Array of review trends with percentage changes
+   */
+  async getReviewTrends(dateRange, period, filters, entityType) {
+    const reviews = await this.fetchReviews(dateRange, filters);
+    if (reviews.length === 0) {
+      return [];
+    }
+    if (entityType) {
+      return this.getGroupedReviewTrends(reviews, dateRange, period, entityType, filters);
+    }
+    const periods = generatePeriods(dateRange.start, dateRange.end, period);
+    const trends = [];
+    let previousAvgRating = 0;
+    let previousRecRate = 0;
+    periods.forEach((periodInfo) => {
+      const periodReviews = reviews.filter((review) => {
+        const reviewDate = review.createdAt instanceof Date ? review.createdAt : review.createdAt.toDate();
+        return reviewDate >= periodInfo.startDate && reviewDate <= periodInfo.endDate;
+      });
+      if (periodReviews.length === 0) {
+        trends.push({
+          period: periodInfo.period,
+          startDate: periodInfo.startDate,
+          endDate: periodInfo.endDate,
+          averageRating: 0,
+          recommendationRate: 0,
+          totalReviews: 0,
+          previousPeriod: void 0
+        });
+        previousAvgRating = 0;
+        previousRecRate = 0;
+        return;
+      }
+      let totalRatingSum = 0;
+      let totalRatingCount = 0;
+      let totalRecommendations = 0;
+      let totalRecommendationCount = 0;
+      periodReviews.forEach((review) => {
+        if (review.practitionerReview) {
+          totalRatingSum += review.practitionerReview.overallRating;
+          totalRatingCount++;
+          if (review.practitionerReview.wouldRecommend) {
+            totalRecommendations++;
+          }
+          totalRecommendationCount++;
+        }
+        if (review.procedureReview) {
+          totalRatingSum += review.procedureReview.overallRating;
+          totalRatingCount++;
+          if (review.procedureReview.wouldRecommend) {
+            totalRecommendations++;
+          }
+          totalRecommendationCount++;
+        }
+        if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
+          review.extendedProcedureReviews.forEach((extReview) => {
+            totalRatingSum += extReview.overallRating;
+            totalRatingCount++;
+            if (extReview.wouldRecommend) {
+              totalRecommendations++;
+            }
+            totalRecommendationCount++;
+          });
+        }
+      });
+      const currentAvgRating = totalRatingCount > 0 ? totalRatingSum / totalRatingCount : 0;
+      const currentRecRate = totalRecommendationCount > 0 ? totalRecommendations / totalRecommendationCount * 100 : 0;
+      const trendChange = getTrendChange(currentAvgRating, previousAvgRating);
+      trends.push({
+        period: periodInfo.period,
+        startDate: periodInfo.startDate,
+        endDate: periodInfo.endDate,
+        averageRating: currentAvgRating,
+        recommendationRate: currentRecRate,
+        totalReviews: periodReviews.length,
+        previousPeriod: previousAvgRating > 0 ? {
+          averageRating: previousAvgRating,
+          recommendationRate: previousRecRate,
+          percentageChange: Math.abs(trendChange.percentageChange),
+          direction: trendChange.direction
+        } : void 0
+      });
+      previousAvgRating = currentAvgRating;
+      previousRecRate = currentRecRate;
+    });
+    return trends;
+  }
+  /**
+   * Calculate grouped review trends (by practitioner, procedure, or technology)
+   * Returns the AVERAGE across all entities of that type for each period
+   * @private
+   */
+  async getGroupedReviewTrends(reviews, dateRange, period, entityType, filters) {
+    const periods = generatePeriods(dateRange.start, dateRange.end, period);
+    const trends = [];
+    let appointments = [];
+    let procedureToTechnologyMap = /* @__PURE__ */ new Map();
+    if (entityType === "technology" && this.appointmentService) {
+      const searchParams = { ...filters };
+      if (dateRange) {
+        searchParams.startDate = dateRange.start;
+        searchParams.endDate = dateRange.end;
+      }
+      const appointmentsResult = await this.appointmentService.searchAppointments(searchParams);
+      appointments = appointmentsResult.appointments || [];
+      appointments.forEach((appointment) => {
+        var _a, _b;
+        if (appointment.procedureId && ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId)) {
+          procedureToTechnologyMap.set(appointment.procedureId, {
+            id: appointment.procedureExtendedInfo.procedureTechnologyId,
+            name: appointment.procedureExtendedInfo.procedureTechnologyName || "Unknown Technology"
+          });
+        }
+        if ((_b = appointment.metadata) == null ? void 0 : _b.extendedProcedures) {
+          appointment.metadata.extendedProcedures.forEach((extProc) => {
+            if (extProc.procedureId && extProc.procedureTechnologyId) {
+              procedureToTechnologyMap.set(extProc.procedureId, {
+                id: extProc.procedureTechnologyId,
+                name: extProc.procedureTechnologyName || "Unknown Technology"
+              });
+            }
+          });
+        }
+      });
+    }
+    let previousAvgRating = 0;
+    let previousRecRate = 0;
+    periods.forEach((periodInfo) => {
+      const periodReviews = reviews.filter((review) => {
+        const reviewDate = review.createdAt instanceof Date ? review.createdAt : review.createdAt.toDate();
+        return reviewDate >= periodInfo.startDate && reviewDate <= periodInfo.endDate;
+      });
+      if (periodReviews.length === 0) {
+        trends.push({
+          period: periodInfo.period,
+          startDate: periodInfo.startDate,
+          endDate: periodInfo.endDate,
+          averageRating: 0,
+          recommendationRate: 0,
+          totalReviews: 0,
+          previousPeriod: void 0
+        });
+        previousAvgRating = 0;
+        previousRecRate = 0;
+        return;
+      }
+      let totalRatingSum = 0;
+      let totalRatingCount = 0;
+      let totalRecommendations = 0;
+      let totalRecommendationCount = 0;
+      periodReviews.forEach((review) => {
+        var _a;
+        if (entityType === "practitioner" && review.practitionerReview) {
+          totalRatingSum += review.practitionerReview.overallRating;
+          totalRatingCount++;
+          if (review.practitionerReview.wouldRecommend) {
+            totalRecommendations++;
+          }
+          totalRecommendationCount++;
+        } else if (entityType === "procedure" && review.procedureReview) {
+          totalRatingSum += review.procedureReview.overallRating;
+          totalRatingCount++;
+          if (review.procedureReview.wouldRecommend) {
+            totalRecommendations++;
+          }
+          totalRecommendationCount++;
+          if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
+            review.extendedProcedureReviews.forEach((extReview) => {
+              totalRatingSum += extReview.overallRating;
+              totalRatingCount++;
+              if (extReview.wouldRecommend) {
+                totalRecommendations++;
+              }
+              totalRecommendationCount++;
+            });
+          }
+        } else if (entityType === "technology") {
+          if ((_a = review.procedureReview) == null ? void 0 : _a.procedureId) {
+            const tech = procedureToTechnologyMap.get(review.procedureReview.procedureId);
+            if (tech) {
+              totalRatingSum += review.procedureReview.overallRating;
+              totalRatingCount++;
+              if (review.procedureReview.wouldRecommend) {
+                totalRecommendations++;
+              }
+              totalRecommendationCount++;
+            }
+          }
+          if (review.extendedProcedureReviews && review.extendedProcedureReviews.length > 0) {
+            review.extendedProcedureReviews.forEach((extReview) => {
+              if (extReview.procedureId) {
+                const tech = procedureToTechnologyMap.get(extReview.procedureId);
+                if (tech) {
+                  totalRatingSum += extReview.overallRating;
+                  totalRatingCount++;
+                  if (extReview.wouldRecommend) {
+                    totalRecommendations++;
+                  }
+                  totalRecommendationCount++;
+                }
+              }
+            });
+          }
+        }
+      });
+      const currentAvgRating = totalRatingCount > 0 ? totalRatingSum / totalRatingCount : 0;
+      const currentRecRate = totalRecommendationCount > 0 ? totalRecommendations / totalRecommendationCount * 100 : 0;
+      const trendChange = getTrendChange(currentAvgRating, previousAvgRating);
+      trends.push({
+        period: periodInfo.period,
+        startDate: periodInfo.startDate,
+        endDate: periodInfo.endDate,
+        averageRating: currentAvgRating,
+        recommendationRate: currentRecRate,
+        totalReviews: totalRatingCount,
+        // Count of reviews for this entity type
+        previousPeriod: previousAvgRating > 0 ? {
+          averageRating: previousAvgRating,
+          recommendationRate: previousRecRate,
+          percentageChange: Math.abs(trendChange.percentageChange),
+          direction: trendChange.direction
+        } : void 0
+      });
+      previousAvgRating = currentAvgRating;
+      previousRecRate = currentRecRate;
+    });
+    return trends;
+  }
+};
+
 // src/services/analytics/analytics.service.ts
 var AnalyticsService = class extends BaseService {
   /**
@@ -7600,6 +8400,7 @@ var AnalyticsService = class extends BaseService {
   constructor(db, auth, app, appointmentService) {
     super(db, auth, app);
     this.appointmentService = appointmentService;
+    this.reviewAnalyticsService = new ReviewAnalyticsService(db, auth, app, appointmentService);
   }
   /**
    * Fetches appointments with optional filters
@@ -7612,20 +8413,20 @@ var AnalyticsService = class extends BaseService {
     try {
       const constraints = [];
       if (filters == null ? void 0 : filters.clinicBranchId) {
-        constraints.push(where("clinicBranchId", "==", filters.clinicBranchId));
+        constraints.push(where2("clinicBranchId", "==", filters.clinicBranchId));
       }
       if (filters == null ? void 0 : filters.practitionerId) {
-        constraints.push(where("practitionerId", "==", filters.practitionerId));
+        constraints.push(where2("practitionerId", "==", filters.practitionerId));
       }
       if (filters == null ? void 0 : filters.procedureId) {
-        constraints.push(where("procedureId", "==", filters.procedureId));
+        constraints.push(where2("procedureId", "==", filters.procedureId));
       }
       if (filters == null ? void 0 : filters.patientId) {
-        constraints.push(where("patientId", "==", filters.patientId));
+        constraints.push(where2("patientId", "==", filters.patientId));
       }
       if (dateRange) {
-        constraints.push(where("appointmentStartTime", ">=", Timestamp2.fromDate(dateRange.start)));
-        constraints.push(where("appointmentStartTime", "<=", Timestamp2.fromDate(dateRange.end)));
+        constraints.push(where2("appointmentStartTime", ">=", Timestamp3.fromDate(dateRange.start)));
+        constraints.push(where2("appointmentStartTime", "<=", Timestamp3.fromDate(dateRange.end)));
       }
       const searchParams = {};
       if (filters == null ? void 0 : filters.clinicBranchId) searchParams.clinicBranchId = filters.clinicBranchId;
@@ -8107,11 +8908,17 @@ var AnalyticsService = class extends BaseService {
   groupCancellationsByProcedure(canceled, allAppointments) {
     const procedureMap = /* @__PURE__ */ new Map();
     allAppointments.forEach((appointment) => {
-      var _a;
+      var _a, _b;
       const procedureId = appointment.procedureId;
       const procedureName = ((_a = appointment.procedureInfo) == null ? void 0 : _a.name) || "Unknown";
       if (!procedureMap.has(procedureId)) {
-        procedureMap.set(procedureId, { name: procedureName, canceled: [], all: [] });
+        procedureMap.set(procedureId, {
+          name: procedureName,
+          canceled: [],
+          all: [],
+          practitionerId: appointment.practitionerId,
+          practitionerName: (_b = appointment.practitionerInfo) == null ? void 0 : _b.name
+        });
       }
       procedureMap.get(procedureId).all.push(appointment);
     });
@@ -8121,15 +8928,20 @@ var AnalyticsService = class extends BaseService {
         procedureMap.get(procedureId).canceled.push(appointment);
       }
     });
-    return Array.from(procedureMap.entries()).map(
-      ([procedureId, data]) => this.calculateCancellationMetrics(
+    return Array.from(procedureMap.entries()).map(([procedureId, data]) => {
+      const metrics = this.calculateCancellationMetrics(
         procedureId,
         data.name,
         "procedure",
         data.canceled,
         data.all
-      )
-    );
+      );
+      return {
+        ...metrics,
+        ...data.practitionerId && { practitionerId: data.practitionerId },
+        ...data.practitionerName && { practitionerName: data.practitionerName }
+      };
+    });
   }
   /**
    * Group cancellations by technology
@@ -8334,11 +9146,17 @@ var AnalyticsService = class extends BaseService {
   groupNoShowsByProcedure(noShow, allAppointments) {
     const procedureMap = /* @__PURE__ */ new Map();
     allAppointments.forEach((appointment) => {
-      var _a;
+      var _a, _b;
       const procedureId = appointment.procedureId;
       const procedureName = ((_a = appointment.procedureInfo) == null ? void 0 : _a.name) || "Unknown";
       if (!procedureMap.has(procedureId)) {
-        procedureMap.set(procedureId, { name: procedureName, noShow: [], all: [] });
+        procedureMap.set(procedureId, {
+          name: procedureName,
+          noShow: [],
+          all: [],
+          practitionerId: appointment.practitionerId,
+          practitionerName: (_b = appointment.practitionerInfo) == null ? void 0 : _b.name
+        });
       }
       procedureMap.get(procedureId).all.push(appointment);
     });
@@ -8354,7 +9172,9 @@ var AnalyticsService = class extends BaseService {
       entityType: "procedure",
       totalAppointments: data.all.length,
       noShowAppointments: data.noShow.length,
-      noShowRate: calculatePercentage(data.noShow.length, data.all.length)
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length),
+      ...data.practitionerId && { practitionerId: data.practitionerId },
+      ...data.practitionerName && { practitionerName: data.practitionerName }
     }));
   }
   /**
@@ -8407,6 +9227,10 @@ var AnalyticsService = class extends BaseService {
    * Get revenue metrics
    * First checks for stored analytics, then calculates if not available or stale
    *
+   * IMPORTANT: Financial calculations only consider COMPLETED appointments.
+   * Confirmed, pending, canceled, and no-show appointments are NOT included in revenue calculations.
+   * Only procedures that have been completed generate revenue.
+   *
    * @param filters - Optional filters
    * @param dateRange - Optional date range filter
    * @param options - Options for reading stored analytics
@@ -8429,11 +9253,8 @@ var AnalyticsService = class extends BaseService {
     const completed = getCompletedAppointments(appointments);
     const { totalRevenue, currency } = calculateTotalRevenue(completed);
     const revenueByStatus = {};
-    Object.values(AppointmentStatus).forEach((status) => {
-      const statusAppointments = appointments.filter((a) => a.status === status);
-      const { totalRevenue: statusRevenue } = calculateTotalRevenue(statusAppointments);
-      revenueByStatus[status] = statusRevenue;
-    });
+    const { totalRevenue: completedRevenue } = calculateTotalRevenue(completed);
+    revenueByStatus["completed" /* COMPLETED */] = completedRevenue;
     const revenueByPaymentStatus = {};
     Object.values(PaymentStatus).forEach((paymentStatus) => {
       const paymentAppointments = completed.filter((a) => a.paymentStatus === paymentStatus);
@@ -8487,18 +9308,23 @@ var AnalyticsService = class extends BaseService {
   /**
    * Get product usage metrics
    *
+   * IMPORTANT: Only COMPLETED appointments are included in product usage calculations.
+   * Products are only considered "used" when the procedure has been completed.
+   * Confirmed, pending, canceled, and no-show appointments are excluded from product metrics.
+   *
    * @param productId - Optional product ID (if not provided, returns all products)
    * @param dateRange - Optional date range filter
+   * @param filters - Optional filters (e.g., clinicBranchId)
    * @returns Product usage metrics
    */
-  async getProductUsageMetrics(productId, dateRange) {
-    const appointments = await this.fetchAppointments(void 0, dateRange);
+  async getProductUsageMetrics(productId, dateRange, filters) {
+    const appointments = await this.fetchAppointments(filters, dateRange);
     const completed = getCompletedAppointments(appointments);
     const productMap = /* @__PURE__ */ new Map();
     completed.forEach((appointment) => {
       const products = extractProductUsage(appointment);
+      const productsInThisAppointment = /* @__PURE__ */ new Set();
       products.forEach((product) => {
-        var _a;
         if (productId && product.productId !== productId) {
           return;
         }
@@ -8510,25 +9336,37 @@ var AnalyticsService = class extends BaseService {
             quantity: 0,
             revenue: 0,
             usageCount: 0,
+            appointmentIds: /* @__PURE__ */ new Set(),
             procedureMap: /* @__PURE__ */ new Map()
           });
         }
         const productData = productMap.get(product.productId);
         productData.quantity += product.quantity;
         productData.revenue += product.subtotal;
-        productData.usageCount++;
-        const procId = appointment.procedureId;
-        const procName = ((_a = appointment.procedureInfo) == null ? void 0 : _a.name) || "Unknown";
-        if (productData.procedureMap.has(procId)) {
-          const procData = productData.procedureMap.get(procId);
-          procData.count++;
-          procData.quantity += product.quantity;
-        } else {
-          productData.procedureMap.set(procId, {
-            name: procName,
-            count: 1,
-            quantity: product.quantity
-          });
+        productsInThisAppointment.add(product.productId);
+      });
+      productsInThisAppointment.forEach((productId2) => {
+        var _a;
+        const productData = productMap.get(productId2);
+        if (!productData.appointmentIds.has(appointment.id)) {
+          productData.appointmentIds.add(appointment.id);
+          productData.usageCount++;
+          const procId = appointment.procedureId;
+          const procName = ((_a = appointment.procedureInfo) == null ? void 0 : _a.name) || "Unknown";
+          if (productData.procedureMap.has(procId)) {
+            const procData = productData.procedureMap.get(procId);
+            procData.count++;
+            const appointmentProducts = products.filter((p) => p.productId === productId2);
+            procData.quantity += appointmentProducts.reduce((sum, p) => sum + p.quantity, 0);
+          } else {
+            const appointmentProducts = products.filter((p) => p.productId === productId2);
+            const totalQuantity = appointmentProducts.reduce((sum, p) => sum + p.quantity, 0);
+            productData.procedureMap.set(procId, {
+              name: procName,
+              count: 1,
+              quantity: totalQuantity
+            });
+          }
         }
       });
     });
@@ -8766,6 +9604,341 @@ var AnalyticsService = class extends BaseService {
       recentActivity
     };
   }
+  /**
+   * Calculate revenue trends over time
+   * Groups appointments by week/month/quarter/year and calculates revenue metrics
+   *
+   * @param dateRange - Date range for trend analysis (must align with period boundaries)
+   * @param period - Period type (week, month, quarter, year)
+   * @param filters - Optional filters for clinic, practitioner, procedure, patient
+   * @param groupBy - Optional entity type to group trends by (clinic, practitioner, procedure, technology, patient)
+   * @returns Array of revenue trends with percentage changes
+   */
+  async getRevenueTrends(dateRange, period, filters, groupBy) {
+    const appointments = await this.fetchAppointments(filters);
+    const filtered = filterByDateRange(appointments, dateRange);
+    if (filtered.length === 0) {
+      return [];
+    }
+    if (groupBy) {
+      return this.getGroupedRevenueTrends(filtered, dateRange, period, groupBy);
+    }
+    const periodMap = groupAppointmentsByPeriod(filtered, period);
+    const periods = generatePeriods(dateRange.start, dateRange.end, period);
+    const trends = [];
+    let previousRevenue = 0;
+    let previousAppointmentCount = 0;
+    periods.forEach((periodInfo) => {
+      const periodAppointments = periodMap.get(periodInfo.period) || [];
+      const completed = getCompletedAppointments(periodAppointments);
+      const { totalRevenue, currency } = calculateTotalRevenue(completed);
+      const appointmentCount = completed.length;
+      const averageRevenue = appointmentCount > 0 ? totalRevenue / appointmentCount : 0;
+      const trend = {
+        period: periodInfo.period,
+        startDate: periodInfo.startDate,
+        endDate: periodInfo.endDate,
+        revenue: totalRevenue,
+        appointmentCount,
+        averageRevenue,
+        currency
+      };
+      if (previousRevenue > 0 || previousAppointmentCount > 0) {
+        const revenueChange = getTrendChange(totalRevenue, previousRevenue);
+        trend.previousPeriod = {
+          revenue: previousRevenue,
+          appointmentCount: previousAppointmentCount,
+          percentageChange: revenueChange.percentageChange,
+          direction: revenueChange.direction
+        };
+      }
+      trends.push(trend);
+      previousRevenue = totalRevenue;
+      previousAppointmentCount = appointmentCount;
+    });
+    return trends;
+  }
+  /**
+   * Calculate revenue trends grouped by entity
+   */
+  async getGroupedRevenueTrends(appointments, dateRange, period, groupBy) {
+    const periodMap = groupAppointmentsByPeriod(appointments, period);
+    const periods = generatePeriods(dateRange.start, dateRange.end, period);
+    const trends = [];
+    periods.forEach((periodInfo) => {
+      var _a;
+      const periodAppointments = periodMap.get(periodInfo.period) || [];
+      if (periodAppointments.length === 0) return;
+      const groupedMetrics = calculateGroupedRevenueMetrics(periodAppointments, groupBy);
+      const totalRevenue = groupedMetrics.reduce((sum, m) => sum + m.totalRevenue, 0);
+      const totalAppointments = groupedMetrics.reduce((sum, m) => sum + m.totalAppointments, 0);
+      const currency = ((_a = groupedMetrics[0]) == null ? void 0 : _a.currency) || "CHF";
+      const averageRevenue = totalAppointments > 0 ? totalRevenue / totalAppointments : 0;
+      trends.push({
+        period: periodInfo.period,
+        startDate: periodInfo.startDate,
+        endDate: periodInfo.endDate,
+        revenue: totalRevenue,
+        appointmentCount: totalAppointments,
+        averageRevenue,
+        currency
+      });
+    });
+    for (let i = 1; i < trends.length; i++) {
+      const current = trends[i];
+      const previous = trends[i - 1];
+      const revenueChange = getTrendChange(current.revenue, previous.revenue);
+      current.previousPeriod = {
+        revenue: previous.revenue,
+        appointmentCount: previous.appointmentCount,
+        percentageChange: revenueChange.percentageChange,
+        direction: revenueChange.direction
+      };
+    }
+    return trends;
+  }
+  /**
+   * Calculate duration/efficiency trends over time
+   *
+   * @param dateRange - Date range for trend analysis
+   * @param period - Period type (week, month, quarter, year)
+   * @param filters - Optional filters
+   * @param groupBy - Optional entity type to group trends by
+   * @returns Array of duration trends with percentage changes
+   */
+  async getDurationTrends(dateRange, period, filters, groupBy) {
+    const appointments = await this.fetchAppointments(filters);
+    const filtered = filterByDateRange(appointments, dateRange);
+    if (filtered.length === 0) {
+      return [];
+    }
+    const periodMap = groupAppointmentsByPeriod(filtered, period);
+    const periods = generatePeriods(dateRange.start, dateRange.end, period);
+    const trends = [];
+    let previousEfficiency = 0;
+    let previousBookedDuration = 0;
+    let previousActualDuration = 0;
+    periods.forEach((periodInfo) => {
+      const periodAppointments = periodMap.get(periodInfo.period) || [];
+      const completed = getCompletedAppointments(periodAppointments);
+      if (groupBy) {
+        const groupedMetrics = calculateGroupedTimeEfficiencyMetrics(completed, groupBy);
+        if (groupedMetrics.length === 0) return;
+        const totalAppointments = groupedMetrics.reduce((sum, m) => sum + m.totalAppointments, 0);
+        const weightedBooked = groupedMetrics.reduce(
+          (sum, m) => sum + m.averageBookedDuration * m.totalAppointments,
+          0
+        );
+        const weightedActual = groupedMetrics.reduce(
+          (sum, m) => sum + m.averageActualDuration * m.totalAppointments,
+          0
+        );
+        const weightedEfficiency = groupedMetrics.reduce(
+          (sum, m) => sum + m.averageEfficiency * m.totalAppointments,
+          0
+        );
+        const averageBookedDuration = totalAppointments > 0 ? weightedBooked / totalAppointments : 0;
+        const averageActualDuration = totalAppointments > 0 ? weightedActual / totalAppointments : 0;
+        const averageEfficiency = totalAppointments > 0 ? weightedEfficiency / totalAppointments : 0;
+        const trend = {
+          period: periodInfo.period,
+          startDate: periodInfo.startDate,
+          endDate: periodInfo.endDate,
+          averageBookedDuration,
+          averageActualDuration,
+          averageEfficiency,
+          appointmentCount: totalAppointments
+        };
+        if (previousEfficiency > 0) {
+          const efficiencyChange = getTrendChange(averageEfficiency, previousEfficiency);
+          trend.previousPeriod = {
+            averageBookedDuration: previousBookedDuration,
+            averageActualDuration: previousActualDuration,
+            averageEfficiency: previousEfficiency,
+            efficiencyPercentageChange: efficiencyChange.percentageChange,
+            direction: efficiencyChange.direction
+          };
+        }
+        trends.push(trend);
+        previousEfficiency = averageEfficiency;
+        previousBookedDuration = averageBookedDuration;
+        previousActualDuration = averageActualDuration;
+      } else {
+        const timeMetrics = calculateAverageTimeMetrics(completed);
+        const trend = {
+          period: periodInfo.period,
+          startDate: periodInfo.startDate,
+          endDate: periodInfo.endDate,
+          averageBookedDuration: timeMetrics.averageBookedDuration,
+          averageActualDuration: timeMetrics.averageActualDuration,
+          averageEfficiency: timeMetrics.averageEfficiency,
+          appointmentCount: timeMetrics.appointmentsWithActualTime
+        };
+        if (previousEfficiency > 0) {
+          const efficiencyChange = getTrendChange(timeMetrics.averageEfficiency, previousEfficiency);
+          trend.previousPeriod = {
+            averageBookedDuration: previousBookedDuration,
+            averageActualDuration: previousActualDuration,
+            averageEfficiency: previousEfficiency,
+            efficiencyPercentageChange: efficiencyChange.percentageChange,
+            direction: efficiencyChange.direction
+          };
+        }
+        trends.push(trend);
+        previousEfficiency = timeMetrics.averageEfficiency;
+        previousBookedDuration = timeMetrics.averageBookedDuration;
+        previousActualDuration = timeMetrics.averageActualDuration;
+      }
+    });
+    return trends;
+  }
+  /**
+   * Calculate appointment count trends over time
+   *
+   * @param dateRange - Date range for trend analysis
+   * @param period - Period type (week, month, quarter, year)
+   * @param filters - Optional filters
+   * @param groupBy - Optional entity type to group trends by
+   * @returns Array of appointment trends with percentage changes
+   */
+  async getAppointmentTrends(dateRange, period, filters, groupBy) {
+    const appointments = await this.fetchAppointments(filters);
+    const filtered = filterByDateRange(appointments, dateRange);
+    if (filtered.length === 0) {
+      return [];
+    }
+    const periodMap = groupAppointmentsByPeriod(filtered, period);
+    const periods = generatePeriods(dateRange.start, dateRange.end, period);
+    const trends = [];
+    let previousTotal = 0;
+    let previousCompleted = 0;
+    periods.forEach((periodInfo) => {
+      const periodAppointments = periodMap.get(periodInfo.period) || [];
+      const completed = getCompletedAppointments(periodAppointments);
+      const canceled = getCanceledAppointments(periodAppointments);
+      const noShow = getNoShowAppointments(periodAppointments);
+      const pending = periodAppointments.filter((a) => a.status === "pending" /* PENDING */);
+      const confirmed = periodAppointments.filter((a) => a.status === "confirmed" /* CONFIRMED */);
+      const trend = {
+        period: periodInfo.period,
+        startDate: periodInfo.startDate,
+        endDate: periodInfo.endDate,
+        totalAppointments: periodAppointments.length,
+        completedAppointments: completed.length,
+        canceledAppointments: canceled.length,
+        noShowAppointments: noShow.length,
+        pendingAppointments: pending.length,
+        confirmedAppointments: confirmed.length
+      };
+      if (previousTotal > 0) {
+        const totalChange = getTrendChange(periodAppointments.length, previousTotal);
+        trend.previousPeriod = {
+          totalAppointments: previousTotal,
+          completedAppointments: previousCompleted,
+          percentageChange: totalChange.percentageChange,
+          direction: totalChange.direction
+        };
+      }
+      trends.push(trend);
+      previousTotal = periodAppointments.length;
+      previousCompleted = completed.length;
+    });
+    return trends;
+  }
+  /**
+   * Calculate cancellation and no-show rate trends over time
+   *
+   * @param dateRange - Date range for trend analysis
+   * @param period - Period type (week, month, quarter, year)
+   * @param filters - Optional filters
+   * @param groupBy - Optional entity type to group trends by
+   * @returns Array of cancellation rate trends with percentage changes
+   */
+  async getCancellationRateTrends(dateRange, period, filters, groupBy) {
+    const appointments = await this.fetchAppointments(filters);
+    const filtered = filterByDateRange(appointments, dateRange);
+    if (filtered.length === 0) {
+      return [];
+    }
+    const periodMap = groupAppointmentsByPeriod(filtered, period);
+    const periods = generatePeriods(dateRange.start, dateRange.end, period);
+    const trends = [];
+    let previousCancellationRate = 0;
+    let previousNoShowRate = 0;
+    periods.forEach((periodInfo) => {
+      const periodAppointments = periodMap.get(periodInfo.period) || [];
+      const canceled = getCanceledAppointments(periodAppointments);
+      const noShow = getNoShowAppointments(periodAppointments);
+      const cancellationRate = calculatePercentage(canceled.length, periodAppointments.length);
+      const noShowRate = calculatePercentage(noShow.length, periodAppointments.length);
+      const trend = {
+        period: periodInfo.period,
+        startDate: periodInfo.startDate,
+        endDate: periodInfo.endDate,
+        cancellationRate,
+        noShowRate,
+        totalAppointments: periodAppointments.length,
+        canceledAppointments: canceled.length,
+        noShowAppointments: noShow.length
+      };
+      if (previousCancellationRate > 0 || previousNoShowRate > 0) {
+        const cancellationChange = getTrendChange(cancellationRate, previousCancellationRate);
+        const noShowChange = getTrendChange(noShowRate, previousNoShowRate);
+        trend.previousPeriod = {
+          cancellationRate: previousCancellationRate,
+          noShowRate: previousNoShowRate,
+          cancellationRateChange: cancellationChange.percentageChange,
+          noShowRateChange: noShowChange.percentageChange,
+          direction: cancellationChange.direction
+          // Use cancellation direction as primary
+        };
+      }
+      trends.push(trend);
+      previousCancellationRate = cancellationRate;
+      previousNoShowRate = noShowRate;
+    });
+    return trends;
+  }
+  // ==========================================
+  // Review Analytics Methods
+  // ==========================================
+  /**
+   * Get review metrics for a specific entity (practitioner, procedure, etc.)
+   */
+  async getReviewMetricsByEntity(entityType, entityId, dateRange, filters) {
+    return this.reviewAnalyticsService.getReviewMetricsByEntity(entityType, entityId, dateRange, filters);
+  }
+  /**
+   * Get review metrics for multiple entities (grouped)
+   */
+  async getReviewMetricsByEntities(entityType, dateRange, filters) {
+    return this.reviewAnalyticsService.getReviewMetricsByEntities(entityType, dateRange, filters);
+  }
+  /**
+   * Get overall review averages for comparison
+   */
+  async getOverallReviewAverages(dateRange, filters) {
+    return this.reviewAnalyticsService.getOverallReviewAverages(dateRange, filters);
+  }
+  /**
+   * Get review details for a specific entity
+   */
+  async getReviewDetails(entityType, entityId, dateRange, filters) {
+    return this.reviewAnalyticsService.getReviewDetails(entityType, entityId, dateRange, filters);
+  }
+  /**
+   * Calculate review trends over time
+   * Groups reviews by period and calculates rating and recommendation metrics
+   *
+   * @param dateRange - Date range for trend analysis
+   * @param period - Period type (week, month, quarter, year)
+   * @param filters - Optional filters for clinic, practitioner, procedure
+   * @param entityType - Optional entity type to group trends by
+   * @returns Array of review trends with percentage changes
+   */
+  async getReviewTrends(dateRange, period, filters, entityType) {
+    return this.reviewAnalyticsService.getReviewTrends(dateRange, period, filters, entityType);
+  }
 };
 
 // src/admin/analytics/analytics.admin.service.ts
@@ -8798,33 +9971,33 @@ var AnalyticsAdminService = class {
   createAppointmentServiceAdapter() {
     return {
       searchAppointments: async (params) => {
-        let query2 = this.db.collection(APPOINTMENTS_COLLECTION);
+        let query3 = this.db.collection(APPOINTMENTS_COLLECTION);
         if (params.clinicBranchId) {
-          query2 = query2.where("clinicBranchId", "==", params.clinicBranchId);
+          query3 = query3.where("clinicBranchId", "==", params.clinicBranchId);
         }
         if (params.practitionerId) {
-          query2 = query2.where("practitionerId", "==", params.practitionerId);
+          query3 = query3.where("practitionerId", "==", params.practitionerId);
         }
         if (params.procedureId) {
-          query2 = query2.where("procedureId", "==", params.procedureId);
+          query3 = query3.where("procedureId", "==", params.procedureId);
         }
         if (params.patientId) {
-          query2 = query2.where("patientId", "==", params.patientId);
+          query3 = query3.where("patientId", "==", params.patientId);
         }
         if (params.startDate) {
           const startDate = params.startDate instanceof Date ? params.startDate : params.startDate.toDate();
           const startTimestamp = admin14.firestore.Timestamp.fromDate(startDate);
-          query2 = query2.where("appointmentStartTime", ">=", startTimestamp);
+          query3 = query3.where("appointmentStartTime", ">=", startTimestamp);
         }
         if (params.endDate) {
           const endDate = params.endDate instanceof Date ? params.endDate : params.endDate.toDate();
           const endTimestamp = admin14.firestore.Timestamp.fromDate(endDate);
-          query2 = query2.where("appointmentStartTime", "<=", endTimestamp);
+          query3 = query3.where("appointmentStartTime", "<=", endTimestamp);
         }
-        const snapshot = await query2.get();
-        const appointments = snapshot.docs.map((doc2) => ({
-          id: doc2.id,
-          ...doc2.data()
+        const snapshot = await query3.get();
+        const appointments = snapshot.docs.map((doc3) => ({
+          id: doc3.id,
+          ...doc3.data()
         }));
         return {
           appointments,
@@ -8921,7 +10094,7 @@ var AnalyticsAdminService = class {
 };
 
 // src/admin/booking/booking.calculator.ts
-import { Timestamp as Timestamp3 } from "firebase/firestore";
+import { Timestamp as Timestamp4 } from "firebase/firestore";
 import { DateTime as DateTime2 } from "luxon";
 var BookingAvailabilityCalculator = class {
   /**
@@ -9047,8 +10220,8 @@ var BookingAvailabilityCalculator = class {
             const intervalStart = workStart < DateTime2.fromMillis(startDate.getTime(), { zone: tz }) ? DateTime2.fromMillis(startDate.getTime(), { zone: tz }) : workStart;
             const intervalEnd = workEnd > DateTime2.fromMillis(endDate.getTime(), { zone: tz }) ? DateTime2.fromMillis(endDate.getTime(), { zone: tz }) : workEnd;
             workingIntervals.push({
-              start: Timestamp3.fromMillis(intervalStart.toMillis()),
-              end: Timestamp3.fromMillis(intervalEnd.toMillis())
+              start: Timestamp4.fromMillis(intervalStart.toMillis()),
+              end: Timestamp4.fromMillis(intervalEnd.toMillis())
             });
             if (daySchedule.breaks && daySchedule.breaks.length > 0) {
               for (const breakTime of daySchedule.breaks) {
@@ -9068,8 +10241,8 @@ var BookingAvailabilityCalculator = class {
                   ...this.subtractInterval(
                     workingIntervals[workingIntervals.length - 1],
                     {
-                      start: Timestamp3.fromMillis(breakStart.toMillis()),
-                      end: Timestamp3.fromMillis(breakEnd.toMillis())
+                      start: Timestamp4.fromMillis(breakStart.toMillis()),
+                      end: Timestamp4.fromMillis(breakEnd.toMillis())
                     }
                   )
                 );
@@ -9179,8 +10352,8 @@ var BookingAvailabilityCalculator = class {
             const intervalStart = workStart < DateTime2.fromMillis(startDate.getTime(), { zone: tz }) ? DateTime2.fromMillis(startDate.getTime(), { zone: tz }) : workStart;
             const intervalEnd = workEnd > DateTime2.fromMillis(endDate.getTime(), { zone: tz }) ? DateTime2.fromMillis(endDate.getTime(), { zone: tz }) : workEnd;
             workingIntervals.push({
-              start: Timestamp3.fromMillis(intervalStart.toMillis()),
-              end: Timestamp3.fromMillis(intervalEnd.toMillis())
+              start: Timestamp4.fromMillis(intervalStart.toMillis()),
+              end: Timestamp4.fromMillis(intervalEnd.toMillis())
             });
           }
         }
@@ -9260,7 +10433,7 @@ var BookingAvailabilityCalculator = class {
         const isInFuture = slotStart >= earliestBookableTime;
         if (isInFuture && this.isSlotFullyAvailable(slotStart, slotEnd, intervals, tz)) {
           slots.push({
-            start: Timestamp3.fromMillis(slotStart.toMillis())
+            start: Timestamp4.fromMillis(slotStart.toMillis())
           });
         }
         slotStart = slotStart.plus({ minutes: intervalMinutes });
@@ -9490,8 +10663,8 @@ var DocumentManagerAdminService = class {
     const templateIds = technologyTemplates.map((t) => t.templateId);
     const templatesSnapshot = await this.db.collection(DOCUMENTATION_TEMPLATES_COLLECTION).where(admin15.firestore.FieldPath.documentId(), "in", templateIds).get();
     const templatesMap = /* @__PURE__ */ new Map();
-    templatesSnapshot.forEach((doc2) => {
-      templatesMap.set(doc2.id, doc2.data());
+    templatesSnapshot.forEach((doc3) => {
+      templatesMap.set(doc3.id, doc3.data());
     });
     for (const templateRef of technologyTemplates) {
       const template = templatesMap.get(templateRef.templateId);
@@ -9732,9 +10905,9 @@ var BookingAdmin = class {
       );
       const eventsRef = this.db.collection(`clinics/${clinicId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<", end).orderBy("eventTime.start");
       const snapshot = await eventsRef.get();
-      const events = snapshot.docs.map((doc2) => ({
-        ...doc2.data(),
-        id: doc2.id
+      const events = snapshot.docs.map((doc3) => ({
+        ...doc3.data(),
+        id: doc3.id
       })).filter((event) => {
         return event.eventTime.end.toMillis() > start.toMillis();
       });
@@ -9778,9 +10951,9 @@ var BookingAdmin = class {
       );
       const eventsRef = this.db.collection(`practitioners/${practitionerId}/calendar`).where("eventTime.start", ">=", queryStart).where("eventTime.start", "<", end).orderBy("eventTime.start");
       const snapshot = await eventsRef.get();
-      const events = snapshot.docs.map((doc2) => ({
-        ...doc2.data(),
-        id: doc2.id
+      const events = snapshot.docs.map((doc3) => ({
+        ...doc3.data(),
+        id: doc3.id
       })).filter((event) => {
         return event.eventTime.end.toMillis() > start.toMillis();
       });
@@ -11635,8 +12808,8 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
    */
   async fetchPractitionerById(practitionerId) {
     try {
-      const doc2 = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
-      return doc2.exists ? doc2.data() : null;
+      const doc3 = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
+      return doc3.exists ? doc3.data() : null;
     } catch (error) {
       Logger.error(
         "[ExistingPractitionerInviteMailingService] Error fetching practitioner:",
@@ -11652,8 +12825,8 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
    */
   async fetchClinicById(clinicId) {
     try {
-      const doc2 = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
-      return doc2.exists ? doc2.data() : null;
+      const doc3 = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
+      return doc3.exists ? doc3.data() : null;
     } catch (error) {
       Logger.error(
         "[ExistingPractitionerInviteMailingService] Error fetching clinic:",