@blackcode_sa/metaestetics-api 1.12.72 → 1.13.1

package/dist/admin/index.mjs

@@ -481,6 +481,14 @@ var AppointmentStatus = /* @__PURE__ */ ((AppointmentStatus2) => {
   AppointmentStatus2["RESCHEDULED_BY_CLINIC"] = "rescheduled_by_clinic";
   return AppointmentStatus2;
 })(AppointmentStatus || {});
+var PaymentStatus = /* @__PURE__ */ ((PaymentStatus2) => {
+  PaymentStatus2["UNPAID"] = "unpaid";
+  PaymentStatus2["PAID"] = "paid";
+  PaymentStatus2["PARTIALLY_PAID"] = "partially_paid";
+  PaymentStatus2["REFUNDED"] = "refunded";
+  PaymentStatus2["NOT_APPLICABLE"] = "not_applicable";
+  return PaymentStatus2;
+})(PaymentStatus || {});
 var APPOINTMENTS_COLLECTION = "appointments";
 
 // src/types/patient/patient-requirements.ts
@@ -525,6 +533,17 @@ var DOCTOR_FORMS_SUBCOLLECTION = "doctor-forms";
 // src/types/reviews/index.ts
 var REVIEWS_COLLECTION = "reviews";
 
+// src/types/analytics/stored-analytics.types.ts
+var ANALYTICS_COLLECTION = "analytics";
+var PRACTITIONER_ANALYTICS_SUBCOLLECTION = "practitioners";
+var PROCEDURE_ANALYTICS_SUBCOLLECTION = "procedures";
+var CLINIC_ANALYTICS_SUBCOLLECTION = "clinic";
+var DASHBOARD_ANALYTICS_SUBCOLLECTION = "dashboard";
+var TIME_EFFICIENCY_ANALYTICS_SUBCOLLECTION = "time_efficiency";
+var CANCELLATION_ANALYTICS_SUBCOLLECTION = "cancellations";
+var NO_SHOW_ANALYTICS_SUBCOLLECTION = "no_shows";
+var REVENUE_ANALYTICS_SUBCOLLECTION = "revenue";
+
 // src/admin/notifications/notifications.admin.ts
 import * as admin2 from "firebase-admin";
 import { Expo } from "expo-server-sdk";
@@ -589,16 +608,16 @@ var Logger = class {
 
 // src/admin/notifications/notifications.admin.ts
 var NotificationsAdmin = class {
-  constructor(firestore18) {
+  constructor(firestore19) {
     this.expo = new Expo();
-    this.db = firestore18 || admin2.firestore();
+    this.db = firestore19 || admin2.firestore();
   }
   /**
    * Dohvata notifikaciju po ID-u
    */
   async getNotification(id) {
-    const doc = await this.db.collection("notifications").doc(id).get();
-    return doc.exists ? { id: doc.id, ...doc.data() } : null;
+    const doc3 = await this.db.collection("notifications").doc(id).get();
+    return doc3.exists ? { id: doc3.id, ...doc3.data() } : null;
   }
   /**
    * Kreira novu notifikaciju
@@ -785,10 +804,10 @@ var NotificationsAdmin = class {
       return;
     }
     const results = await Promise.allSettled(
-      pendingNotifications.docs.map(async (doc) => {
+      pendingNotifications.docs.map(async (doc3) => {
         const notification = {
-          id: doc.id,
-          ...doc.data()
+          id: doc3.id,
+          ...doc3.data()
         };
         Logger.info(
           `[NotificationsAdmin] Processing notification ${notification.id} of type ${notification.notificationType}`
@@ -829,8 +848,8 @@ var NotificationsAdmin = class {
         break;
       }
       const batch = this.db.batch();
-      oldNotifications.docs.forEach((doc) => {
-        batch.delete(doc.ref);
+      oldNotifications.docs.forEach((doc3) => {
+        batch.delete(doc3.ref);
       });
       await batch.commit();
       totalDeleted += oldNotifications.size;
@@ -1100,8 +1119,8 @@ var NotificationsAdmin = class {
 
 // src/admin/requirements/patient-requirements.admin.service.ts
 var PatientRequirementsAdminService = class {
-  constructor(firestore18) {
-    this.db = firestore18 || admin3.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin3.firestore();
     this.notificationsAdmin = new NotificationsAdmin(this.db);
   }
   /**
@@ -1429,8 +1448,8 @@ var PatientRequirementsAdminService = class {
 // src/admin/calendar/calendar.admin.service.ts
 import * as admin4 from "firebase-admin";
 var CalendarAdminService = class {
-  constructor(firestore18) {
-    this.db = firestore18 || admin4.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin4.firestore();
     Logger.info("[CalendarAdminService] Initialized.");
   }
   /**
@@ -1716,9 +1735,9 @@ var BaseMailingService = class {
    * @param firestore Firestore instance provided by the caller
    * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
    */
-  constructor(firestore18, mailgunClient) {
+  constructor(firestore19, mailgunClient) {
     var _a;
-    this.db = firestore18;
+    this.db = firestore19;
     this.mailgunClient = mailgunClient;
     if (!this.db) {
       Logger.error("[BaseMailingService] No Firestore instance provided");
@@ -2260,8 +2279,8 @@ var clinicAppointmentRequestedTemplate = `
 </html>
 `;
 var AppointmentMailingService = class extends BaseMailingService {
-  constructor(firestore18, mailgunClient) {
-    super(firestore18, mailgunClient);
+  constructor(firestore19, mailgunClient) {
+    super(firestore19, mailgunClient);
     this.DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
     Logger.info("[AppointmentMailingService] Initialized.");
   }
@@ -2490,8 +2509,8 @@ var AppointmentAggregationService = class {
    * @param mailgunClient - An initialized Mailgun client instance.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(mailgunClient, firestore18) {
-    this.db = firestore18 || admin6.firestore();
+  constructor(mailgunClient, firestore19) {
+    this.db = firestore19 || admin6.firestore();
     this.appointmentMailingService = new AppointmentMailingService(
       this.db,
       mailgunClient
@@ -3518,10 +3537,10 @@ var AppointmentAggregationService = class {
       }
       const batch = this.db.batch();
       let instancesUpdatedCount = 0;
-      instancesSnapshot.docs.forEach((doc) => {
-        const instance = doc.data();
+      instancesSnapshot.docs.forEach((doc3) => {
+        const instance = doc3.data();
         if (instance.overallStatus !== newOverallStatus && instance.overallStatus !== "failedToProcess" /* FAILED_TO_PROCESS */) {
-          batch.update(doc.ref, {
+          batch.update(doc3.ref, {
             overallStatus: newOverallStatus,
             updatedAt: admin6.firestore.FieldValue.serverTimestamp()
             // Cast for now
@@ -3530,7 +3549,7 @@ var AppointmentAggregationService = class {
           });
           instancesUpdatedCount++;
           Logger.debug(
-            `[AggService] Added update for PatientRequirementInstance ${doc.id} to batch. New status: ${newOverallStatus}`
+            `[AggService] Added update for PatientRequirementInstance ${doc3.id} to batch. New status: ${newOverallStatus}`
           );
         }
       });
@@ -3705,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 doc = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).get();
-      return doc.exists ? doc.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;
@@ -3719,12 +3738,12 @@ var AppointmentAggregationService = class {
    */
   async fetchPatientSensitiveInfo(patientId) {
     try {
-      const doc = await this.db.collection(PATIENTS_COLLECTION).doc(patientId).collection(PATIENT_SENSITIVE_INFO_COLLECTION).doc(patientId).get();
-      if (!doc.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 doc.data();
+      return doc3.data();
     } catch (error) {
       Logger.error(`[AggService] Error fetching patient sensitive info ${patientId}:`, error);
       return null;
@@ -3741,12 +3760,12 @@ var AppointmentAggregationService = class {
       return null;
     }
     try {
-      const doc = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
-      if (!doc.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 doc.data();
+      return doc3.data();
     } catch (error) {
       Logger.error(`[AggService] Error fetching practitioner profile ${practitionerId}:`, error);
       return null;
@@ -3763,12 +3782,12 @@ var AppointmentAggregationService = class {
       return null;
     }
     try {
-      const doc = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
-      if (!doc.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 doc.data();
+      return doc3.data();
     } catch (error) {
       Logger.error(`[AggService] Error fetching clinic info ${clinicId}:`, error);
       return null;
@@ -4012,8 +4031,8 @@ var ClinicAggregationService = class {
    * Constructor for ClinicAggregationService.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(firestore18) {
-    this.db = firestore18 || admin7.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin7.firestore();
   }
   /**
    * Adds clinic information to a clinic group when a new clinic is created
@@ -4235,11 +4254,11 @@ var ClinicAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[ClinicAggregationService] Updating location for calendar event ${doc.ref.path}`
+          `[ClinicAggregationService] Updating location for calendar event ${doc3.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc3.ref, {
           eventLocation: newLocation,
           updatedAt: admin7.firestore.FieldValue.serverTimestamp()
         });
@@ -4282,11 +4301,11 @@ var ClinicAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[ClinicAggregationService] Updating clinic info for calendar event ${doc.ref.path}`
+          `[ClinicAggregationService] Updating clinic info for calendar event ${doc3.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc3.ref, {
           clinicInfo,
           updatedAt: admin7.firestore.FieldValue.serverTimestamp()
         });
@@ -4497,11 +4516,11 @@ var ClinicAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[ClinicAggregationService] Canceling calendar event ${doc.ref.path}`
+          `[ClinicAggregationService] Canceling calendar event ${doc3.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc3.ref, {
           status: "CANCELED",
           cancelReason: "Clinic deleted",
           updatedAt: admin7.firestore.FieldValue.serverTimestamp()
@@ -4528,8 +4547,8 @@ var FilledFormsAggregationService = class {
    * Constructor for FilledFormsAggregationService.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(firestore18) {
-    this.db = firestore18 || admin8.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin8.firestore();
     Logger.info("[FilledFormsAggregationService] Initialized");
   }
   /**
@@ -4736,8 +4755,8 @@ var FilledFormsAggregationService = class {
 import * as admin9 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID2 = "calendar";
 var PatientAggregationService = class {
-  constructor(firestore18) {
-    this.db = firestore18 || admin9.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin9.firestore();
   }
   // --- Methods for Patient Creation --- >
   // No specific aggregations defined for patient creation in the plan.
@@ -4769,11 +4788,11 @@ var PatientAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[PatientAggregationService] Updating patient info for calendar event ${doc.ref.path}`
+          `[PatientAggregationService] Updating patient info for calendar event ${doc3.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc3.ref, {
           patientInfo,
           updatedAt: admin9.firestore.FieldValue.serverTimestamp()
         });
@@ -4817,11 +4836,11 @@ var PatientAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[PatientAggregationService] Canceling calendar event ${doc.ref.path}`
+          `[PatientAggregationService] Canceling calendar event ${doc3.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc3.ref, {
           status: "CANCELED",
           cancelReason: "Patient deleted",
           updatedAt: admin9.firestore.FieldValue.serverTimestamp()
@@ -4845,8 +4864,8 @@ var PatientAggregationService = class {
 import * as admin10 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID3 = "calendar";
 var PractitionerAggregationService = class {
-  constructor(firestore18) {
-    this.db = firestore18 || admin10.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin10.firestore();
   }
   /**
    * Adds practitioner information to a clinic when a new practitioner is created
@@ -4992,11 +5011,11 @@ var PractitionerAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[PractitionerAggregationService] Updating practitioner info for calendar event ${doc.ref.path}`
+          `[PractitionerAggregationService] Updating practitioner info for calendar event ${doc3.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc3.ref, {
           practitionerInfo,
           updatedAt: admin10.firestore.FieldValue.serverTimestamp()
         });
@@ -5080,11 +5099,11 @@ var PractitionerAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[PractitionerAggregationService] Canceling calendar event ${doc.ref.path}`
+          `[PractitionerAggregationService] Canceling calendar event ${doc3.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc3.ref, {
           status: "CANCELED",
           cancelReason: "Practitioner deleted",
           updatedAt: admin10.firestore.FieldValue.serverTimestamp()
@@ -5185,8 +5204,8 @@ var PractitionerInviteAggregationService = class {
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    * @param mailingService Optional mailing service for sending emails
    */
-  constructor(firestore18, mailingService) {
-    this.db = firestore18 || admin11.firestore();
+  constructor(firestore19, mailingService) {
+    this.db = firestore19 || admin11.firestore();
     this.mailingService = mailingService;
     Logger.info("[PractitionerInviteAggregationService] Initialized.");
   }
@@ -5636,8 +5655,8 @@ var PractitionerInviteAggregationService = class {
    */
   async fetchClinicAdminById(adminId) {
     try {
-      const doc = await this.db.collection(CLINIC_ADMINS_COLLECTION).doc(adminId).get();
-      return doc.exists ? doc.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}:`,
@@ -5653,8 +5672,8 @@ var PractitionerInviteAggregationService = class {
    */
   async fetchPractitionerById(practitionerId) {
     try {
-      const doc = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
-      return doc.exists ? doc.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}:`,
@@ -5670,8 +5689,8 @@ var PractitionerInviteAggregationService = class {
    */
   async fetchClinicById(clinicId) {
     try {
-      const doc = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
-      return doc.exists ? doc.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}:`,
@@ -5692,8 +5711,8 @@ var PractitionerInviteAggregationService = class {
     var _a, _b, _c, _d, _e, _f;
     if (!this.mailingService) return;
     try {
-      const admin18 = await this.fetchClinicAdminById(invite.invitedBy);
-      if (!admin18) {
+      const admin19 = await this.fetchClinicAdminById(invite.invitedBy);
+      if (!admin19) {
         Logger.warn(
           `[PractitionerInviteAggService] Admin ${invite.invitedBy} not found, using clinic contact email as fallback`
         );
@@ -5731,7 +5750,7 @@ var PractitionerInviteAggregationService = class {
         );
         return;
       }
-      const adminName = `${admin18.contactInfo.firstName} ${admin18.contactInfo.lastName}`;
+      const adminName = `${admin19.contactInfo.firstName} ${admin19.contactInfo.lastName}`;
       const notificationData = {
         invite,
         practitioner: {
@@ -5747,7 +5766,7 @@ var PractitionerInviteAggregationService = class {
         clinic: {
           name: clinic.name,
           adminName,
-          adminEmail: admin18.contactInfo.email
+          adminEmail: admin19.contactInfo.email
           // Use the specific admin's email
         },
         context: {
@@ -5783,8 +5802,8 @@ var PractitionerInviteAggregationService = class {
     var _a, _b, _c, _d, _e, _f;
     if (!this.mailingService) return;
     try {
-      const admin18 = await this.fetchClinicAdminById(invite.invitedBy);
-      if (!admin18) {
+      const admin19 = await this.fetchClinicAdminById(invite.invitedBy);
+      if (!admin19) {
         Logger.warn(
           `[PractitionerInviteAggService] Admin ${invite.invitedBy} not found, using clinic contact email as fallback`
         );
@@ -5822,7 +5841,7 @@ var PractitionerInviteAggregationService = class {
         );
         return;
       }
-      const adminName = `${admin18.contactInfo.firstName} ${admin18.contactInfo.lastName}`;
+      const adminName = `${admin19.contactInfo.firstName} ${admin19.contactInfo.lastName}`;
       const notificationData = {
         invite,
         practitioner: {
@@ -5836,7 +5855,7 @@ var PractitionerInviteAggregationService = class {
         clinic: {
           name: clinic.name,
           adminName,
-          adminEmail: admin18.contactInfo.email
+          adminEmail: admin19.contactInfo.email
           // Use the specific admin's email
         },
         context: {
@@ -5868,8 +5887,8 @@ var PractitionerInviteAggregationService = class {
 import * as admin12 from "firebase-admin";
 var CALENDAR_SUBCOLLECTION_ID4 = "calendar";
 var ProcedureAggregationService = class {
-  constructor(firestore18) {
-    this.db = firestore18 || admin12.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin12.firestore();
   }
   /**
    * Adds procedure information to a practitioner when a new procedure is created
@@ -6106,11 +6125,11 @@ var ProcedureAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[ProcedureAggregationService] Updating procedure info for calendar event ${doc.ref.path}`
+          `[ProcedureAggregationService] Updating procedure info for calendar event ${doc3.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc3.ref, {
           procedureInfo,
           updatedAt: admin12.firestore.FieldValue.serverTimestamp()
         });
@@ -6153,11 +6172,11 @@ var ProcedureAggregationService = class {
         return;
       }
       const batch = this.db.batch();
-      snapshot.docs.forEach((doc) => {
+      snapshot.docs.forEach((doc3) => {
         console.log(
-          `[ProcedureAggregationService] Canceling calendar event ${doc.ref.path}`
+          `[ProcedureAggregationService] Canceling calendar event ${doc3.ref.path}`
         );
-        batch.update(doc.ref, {
+        batch.update(doc3.ref, {
           status: "CANCELED",
           cancelReason: "Procedure deleted or inactivated",
           updatedAt: admin12.firestore.FieldValue.serverTimestamp()
@@ -6387,8 +6406,8 @@ var ReviewsAggregationService = class {
    * Constructor for ReviewsAggregationService.
    * @param firestore Optional Firestore instance. If not provided, it uses the default admin SDK instance.
    */
-  constructor(firestore18) {
-    this.db = firestore18 || admin13.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin13.firestore();
   }
   /**
    * Process a newly created review and update all related entities
@@ -6538,7 +6557,7 @@ var ReviewsAggregationService = class {
       );
       return updatedReviewInfo2;
     }
-    const reviews = reviewsQuery.docs.map((doc) => doc.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;
@@ -6628,7 +6647,7 @@ var ReviewsAggregationService = class {
       );
       return updatedReviewInfo2;
     }
-    const reviews = reviewsQuery.docs.map((doc) => doc.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;
@@ -6701,7 +6720,7 @@ var ReviewsAggregationService = class {
       recommendationPercentage: 0
     };
     const allReviewsQuery = await this.db.collection(REVIEWS_COLLECTION).get();
-    const reviews = allReviewsQuery.docs.map((doc) => doc.data());
+    const reviews = allReviewsQuery.docs.map((doc3) => doc3.data());
     const procedureReviews = [];
     reviews.forEach((review) => {
       if (review.procedureReview && review.procedureReview.procedureId === procedureId) {
@@ -6867,226 +6886,3433 @@ var ReviewsAggregationService = class {
   }
 };
 
-// src/admin/booking/booking.calculator.ts
-import { Timestamp } from "firebase/firestore";
-import { DateTime as DateTime2 } from "luxon";
-var BookingAvailabilityCalculator = class {
-  /**
-   * Calculate available booking slots based on the provided data
-   *
-   * @param request - The request containing all necessary data for calculation
-   * @returns Response with available booking slots
-   */
-  static calculateSlots(request) {
-    const {
-      clinic,
-      practitioner,
-      procedure,
-      timeframe,
-      clinicCalendarEvents,
-      practitionerCalendarEvents,
-      tz
-    } = request;
-    const schedulingIntervalMinutes = clinic.schedulingInterval || this.DEFAULT_INTERVAL_MINUTES;
-    const procedureDurationMinutes = procedure.duration;
-    console.log(
-      `Calculating slots with interval: ${schedulingIntervalMinutes}min and procedure duration: ${procedureDurationMinutes}min`
-    );
-    let availableIntervals = [
-      { start: timeframe.start, end: timeframe.end }
-    ];
-    availableIntervals = this.applyClinicWorkingHours(
-      availableIntervals,
-      clinic.workingHours,
-      timeframe,
-      tz
-    );
-    availableIntervals = this.subtractBlockingEvents(
-      availableIntervals,
-      clinicCalendarEvents
-    );
-    availableIntervals = this.applyPractitionerWorkingHours(
-      availableIntervals,
-      practitioner,
-      clinic.id,
-      timeframe,
-      tz
-    );
-    availableIntervals = this.subtractPractitionerBusyTimes(
-      availableIntervals,
-      practitionerCalendarEvents
-    );
-    console.log(
-      `After all filters, have ${availableIntervals.length} available intervals`
-    );
-    const availableSlots = this.generateAvailableSlots(
-      availableIntervals,
-      schedulingIntervalMinutes,
-      procedureDurationMinutes,
-      tz
-    );
-    return { availableSlots };
+// src/admin/analytics/analytics.admin.service.ts
+import * as admin14 from "firebase-admin";
+
+// src/services/analytics/analytics.service.ts
+import { where as where2, Timestamp as Timestamp3 } from "firebase/firestore";
+
+// src/services/base.service.ts
+import { getStorage } from "firebase/storage";
+var BaseService = class {
+  constructor(db, auth, app, storage) {
+    this.db = db;
+    this.auth = auth;
+    this.app = app;
+    if (app) {
+      this.storage = storage || getStorage(app);
+    }
+  }
+  /**
+   * Generiše jedinstveni ID za dokumente
+   * Format: xxxxxxxxxxxx-timestamp
+   * Gde je x random karakter (broj ili slovo)
+   */
+  generateId() {
+    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    const timestamp = Date.now().toString(36);
+    const randomPart = Array.from(
+      { length: 12 },
+      () => chars.charAt(Math.floor(Math.random() * chars.length))
+    ).join("");
+    return `${randomPart}-${timestamp}`;
   }
-  /**
-   * Apply clinic working hours to available intervals
-   *
-   * @param intervals - Current available intervals
-   * @param workingHours - Clinic working hours
-   * @param timeframe - Overall timeframe being considered
-   * @param tz - IANA timezone of the clinic
-   * @returns Intervals filtered by clinic working hours
-   */
-  static applyClinicWorkingHours(intervals, workingHours, timeframe, tz) {
-    if (!intervals.length) return [];
-    console.log(
-      `Applying clinic working hours to ${intervals.length} intervals`
-    );
-    const workingIntervals = this.createWorkingHoursIntervals(
-      workingHours,
-      timeframe.start.toDate(),
-      timeframe.end.toDate(),
-      tz
-    );
-    return this.intersectIntervals(intervals, workingIntervals);
+};
+
+// src/services/analytics/utils/cost-calculation.utils.ts
+function calculateAppointmentCost(appointment) {
+  const metadata = appointment.metadata;
+  const currency = appointment.currency || "CHF";
+  if (metadata == null ? void 0 : metadata.finalbilling) {
+    const finalbilling = metadata.finalbilling;
+    return {
+      cost: finalbilling.finalPrice,
+      currency: finalbilling.currency || currency,
+      source: "finalbilling",
+      subtotal: finalbilling.subtotalAll,
+      tax: finalbilling.taxPrice
+    };
   }
-  /**
-   * Create time intervals for working hours across multiple days
-   *
-   * @param workingHours - Working hours definition
-   * @param startDate - Start date of the overall timeframe
-   * @param endDate - End date of the overall timeframe
-   * @param tz - IANA timezone of the clinic
-   * @returns Array of time intervals representing working hours
-   */
-  static createWorkingHoursIntervals(workingHours, startDate, endDate, tz) {
-    const workingIntervals = [];
-    let start = DateTime2.fromMillis(startDate.getTime(), { zone: tz });
-    const end = DateTime2.fromMillis(endDate.getTime(), { zone: tz });
-    while (start <= end) {
-      const dayOfWeek = start.weekday;
-      const dayName = [
-        "monday",
-        "tuesday",
-        "wednesday",
-        "thursday",
-        "friday",
-        "saturday",
-        "sunday"
-      ][dayOfWeek - 1];
-      if (dayName && workingHours[dayName]) {
-        const daySchedule = workingHours[dayName];
-        if (daySchedule) {
-          const [openHours, openMinutes] = daySchedule.open.split(":").map(Number);
-          const [closeHours, closeMinutes] = daySchedule.close.split(":").map(Number);
-          let workStart = start.set({
-            hour: openHours,
-            minute: openMinutes,
-            second: 0,
-            millisecond: 0
-          });
-          let workEnd = start.set({
-            hour: closeHours,
-            minute: closeMinutes,
-            second: 0,
-            millisecond: 0
-          });
-          if (workEnd.toMillis() > startDate.getTime() && workStart.toMillis() < endDate.getTime()) {
-            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: Timestamp.fromMillis(intervalStart.toMillis()),
-              end: Timestamp.fromMillis(intervalEnd.toMillis())
-            });
-            if (daySchedule.breaks && daySchedule.breaks.length > 0) {
-              for (const breakTime of daySchedule.breaks) {
-                const [breakStartHours, breakStartMinutes] = breakTime.start.split(":").map(Number);
-                const [breakEndHours, breakEndMinutes] = breakTime.end.split(":").map(Number);
-                const breakStart = start.set({
-                  hour: breakStartHours,
-                  minute: breakStartMinutes
-                });
-                const breakEnd = start.set({
-                  hour: breakEndHours,
-                  minute: breakEndMinutes
-                });
-                workingIntervals.splice(
-                  -1,
-                  1,
-                  ...this.subtractInterval(
-                    workingIntervals[workingIntervals.length - 1],
-                    {
-                      start: Timestamp.fromMillis(breakStart.toMillis()),
-                      end: Timestamp.fromMillis(breakEnd.toMillis())
-                    }
-                  )
-                );
-              }
-            }
+  if (metadata == null ? void 0 : metadata.zonesData) {
+    const zonesData = metadata.zonesData;
+    let subtotal = 0;
+    let foundCurrency = currency;
+    Object.values(zonesData).forEach((items) => {
+      items.forEach((item) => {
+        if (item.type === "item" && item.subtotal) {
+          subtotal += item.subtotal;
+          if (item.currency && !foundCurrency) {
+            foundCurrency = item.currency;
           }
         }
-      }
-      start = start.plus({ days: 1 });
+      });
+    });
+    if (subtotal > 0) {
+      return {
+        cost: subtotal,
+        // Note: This doesn't include tax, but zonesData might not have tax info
+        currency: foundCurrency,
+        source: "zonesData",
+        subtotal
+      };
     }
-    return workingIntervals;
   }
-  /**
-   * Subtract blocking events from available intervals
-   *
-   * @param intervals - Current available intervals
-   * @param events - Calendar events to subtract
-   * @returns Available intervals after removing blocking events
-   */
-  static subtractBlockingEvents(intervals, events) {
-    if (!intervals.length) return [];
-    console.log(`Subtracting ${events.length} blocking events`);
-    const blockingEvents = events.filter(
-      (event) => event.eventType === "blocking" /* BLOCKING */ || event.eventType === "break" /* BREAK */ || event.eventType === "free_day" /* FREE_DAY */
-    );
-    let result = [...intervals];
-    for (const event of blockingEvents) {
-      const { start, end } = event.eventTime;
-      const blockingInterval = { start, end };
-      const newResult = [];
-      for (const interval of result) {
-        const remainingIntervals = this.subtractInterval(
-          interval,
-          blockingInterval
-        );
-        newResult.push(...remainingIntervals);
+  return {
+    cost: appointment.cost || 0,
+    currency,
+    source: "baseCost"
+  };
+}
+function calculateTotalRevenue(appointments) {
+  if (appointments.length === 0) {
+    return { totalRevenue: 0, currency: "CHF" };
+  }
+  let totalRevenue = 0;
+  const currencies = /* @__PURE__ */ new Set();
+  appointments.forEach((appointment) => {
+    const costData = calculateAppointmentCost(appointment);
+    totalRevenue += costData.cost;
+    currencies.add(costData.currency);
+  });
+  const currency = currencies.size > 0 ? Array.from(currencies)[0] : "CHF";
+  return { totalRevenue, currency };
+}
+function extractProductUsage(appointment) {
+  const products = [];
+  const metadata = appointment.metadata;
+  if (!(metadata == null ? void 0 : metadata.zonesData)) {
+    return products;
+  }
+  const zonesData = metadata.zonesData;
+  const currency = appointment.currency || "CHF";
+  Object.values(zonesData).forEach((items) => {
+    items.forEach((item) => {
+      if (item.type === "item" && item.productId) {
+        const price = item.priceOverrideAmount || item.price || 0;
+        const quantity = item.quantity || 1;
+        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",
+          brandId: item.productBrandId || "",
+          brandName: item.productBrandName || "",
+          quantity,
+          price,
+          subtotal,
+          currency: item.currency || currency
+        });
       }
-      result = newResult;
+    });
+  });
+  return products;
+}
+
+// src/services/analytics/utils/time-calculation.utils.ts
+function calculateTimeEfficiency(appointment) {
+  const startTime = appointment.appointmentStartTime;
+  const endTime = appointment.appointmentEndTime;
+  if (!startTime || !endTime) {
+    return null;
+  }
+  const bookedDurationMs = endTime.toMillis() - startTime.toMillis();
+  const bookedDuration = Math.round(bookedDurationMs / (1e3 * 60));
+  const actualDuration = appointment.actualDurationMinutes || bookedDuration;
+  const efficiency = bookedDuration > 0 ? actualDuration / bookedDuration * 100 : 100;
+  const overrun = actualDuration > bookedDuration ? actualDuration - bookedDuration : 0;
+  const underutilization = bookedDuration > actualDuration ? bookedDuration - actualDuration : 0;
+  return {
+    bookedDuration,
+    actualDuration,
+    efficiency,
+    overrun,
+    underutilization
+  };
+}
+function calculateAverageTimeMetrics(appointments) {
+  if (appointments.length === 0) {
+    return {
+      averageBookedDuration: 0,
+      averageActualDuration: 0,
+      averageEfficiency: 0,
+      totalOverrun: 0,
+      totalUnderutilization: 0,
+      averageOverrun: 0,
+      averageUnderutilization: 0,
+      appointmentsWithActualTime: 0
+    };
+  }
+  let totalBookedDuration = 0;
+  let totalActualDuration = 0;
+  let totalOverrun = 0;
+  let totalUnderutilization = 0;
+  let appointmentsWithActualTime = 0;
+  appointments.forEach((appointment) => {
+    const timeData = calculateTimeEfficiency(appointment);
+    if (timeData) {
+      totalBookedDuration += timeData.bookedDuration;
+      totalActualDuration += timeData.actualDuration;
+      totalOverrun += timeData.overrun;
+      totalUnderutilization += timeData.underutilization;
+      if (appointment.actualDurationMinutes !== void 0) {
+        appointmentsWithActualTime++;
+      }
+    }
+  });
+  const count = appointments.length;
+  const averageBookedDuration = count > 0 ? totalBookedDuration / count : 0;
+  const averageActualDuration = count > 0 ? totalActualDuration / count : 0;
+  const averageEfficiency = averageBookedDuration > 0 ? averageActualDuration / averageBookedDuration * 100 : 0;
+  const averageOverrun = count > 0 ? totalOverrun / count : 0;
+  const averageUnderutilization = count > 0 ? totalUnderutilization / count : 0;
+  return {
+    averageBookedDuration: Math.round(averageBookedDuration),
+    averageActualDuration: Math.round(averageActualDuration),
+    averageEfficiency: Math.round(averageEfficiency * 100) / 100,
+    totalOverrun,
+    totalUnderutilization,
+    averageOverrun: Math.round(averageOverrun),
+    averageUnderutilization: Math.round(averageUnderutilization),
+    appointmentsWithActualTime
+  };
+}
+function calculateEfficiencyDistribution(appointments) {
+  const ranges = [
+    { label: "0-50%", min: 0, max: 50 },
+    { label: "50-75%", min: 50, max: 75 },
+    { label: "75-100%", min: 75, max: 100 },
+    { label: "100%+", min: 100, max: Infinity }
+  ];
+  const distribution = ranges.map((range) => ({
+    range: range.label,
+    count: 0,
+    percentage: 0
+  }));
+  let validCount = 0;
+  appointments.forEach((appointment) => {
+    const timeData = calculateTimeEfficiency(appointment);
+    if (timeData) {
+      validCount++;
+      const efficiency = timeData.efficiency;
+      for (let i = 0; i < ranges.length; i++) {
+        if (efficiency >= ranges[i].min && efficiency < ranges[i].max) {
+          distribution[i].count++;
+          break;
+        }
+      }
+    }
+  });
+  if (validCount > 0) {
+    distribution.forEach((item) => {
+      item.percentage = Math.round(item.count / validCount * 100 * 100) / 100;
+    });
+  }
+  return distribution;
+}
+function calculateCancellationLeadTime(appointment) {
+  if (!appointment.cancellationTime || !appointment.appointmentStartTime) {
+    return null;
+  }
+  const cancellationTime = appointment.cancellationTime.toMillis();
+  const appointmentTime = appointment.appointmentStartTime.toMillis();
+  const diffMs = appointmentTime - cancellationTime;
+  return Math.max(0, diffMs / (1e3 * 60 * 60));
+}
+
+// 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;
+  }
+  return appointments.filter((appointment) => {
+    if (filters.clinicBranchId && appointment.clinicBranchId !== filters.clinicBranchId) {
+      return false;
     }
-    return result;
+    if (filters.practitionerId && appointment.practitionerId !== filters.practitionerId) {
+      return false;
+    }
+    if (filters.procedureId && appointment.procedureId !== filters.procedureId) {
+      return false;
+    }
+    if (filters.patientId && appointment.patientId !== filters.patientId) {
+      return false;
+    }
+    return true;
+  });
+}
+function filterByStatus(appointments, statuses) {
+  return appointments.filter((appointment) => statuses.includes(appointment.status));
+}
+function getCompletedAppointments(appointments) {
+  return filterByStatus(appointments, ["completed" /* COMPLETED */]);
+}
+function getCanceledAppointments(appointments) {
+  return filterByStatus(appointments, [
+    "canceled_patient" /* CANCELED_PATIENT */,
+    "canceled_clinic" /* CANCELED_CLINIC */,
+    "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */
+  ]);
+}
+function getNoShowAppointments(appointments) {
+  return filterByStatus(appointments, ["no_show" /* NO_SHOW */]);
+}
+function calculatePercentage(part, total) {
+  if (total === 0) {
+    return 0;
   }
-  /**
-   * Apply practitioner's specific working hours for the given clinic
-   *
-   * @param intervals - Current available intervals
-   * @param practitioner - Practitioner object
-   * @param clinicId - ID of the clinic
-   * @param timeframe - Overall timeframe being considered
-   * @param tz - IANA timezone of the clinic
-   * @returns Intervals filtered by practitioner's working hours
-   */
-  static applyPractitionerWorkingHours(intervals, practitioner, clinicId, timeframe, tz) {
-    if (!intervals.length) return [];
-    console.log(`Applying practitioner working hours for clinic ${clinicId}`);
-    const clinicWorkingHours = practitioner.clinicWorkingHours.find(
-      (hours) => hours.clinicId === clinicId && hours.isActive
+  return Math.round(part / total * 100 * 100) / 100;
+}
+
+// src/services/analytics/utils/stored-analytics.utils.ts
+import { Timestamp, doc, getDoc } from "firebase/firestore";
+function isAnalyticsDataFresh(computedAt, maxAgeHours) {
+  const now = Timestamp.now();
+  const ageMs = now.toMillis() - computedAt.toMillis();
+  const ageHours = ageMs / (1e3 * 60 * 60);
+  return ageHours <= maxAgeHours;
+}
+async function readStoredAnalytics(db, clinicBranchId, subcollection, documentId, period) {
+  try {
+    const docRef = doc(
+      db,
+      CLINICS_COLLECTION,
+      clinicBranchId,
+      ANALYTICS_COLLECTION,
+      subcollection,
+      period,
+      documentId
     );
-    if (!clinicWorkingHours) {
-      console.log(
-        `No working hours found for practitioner at clinic ${clinicId}`
-      );
-      return [];
+    const docSnap = await getDoc(docRef);
+    if (!docSnap.exists()) {
+      return null;
     }
-    const workingIntervals = this.createPractitionerWorkingHoursIntervals(
-      clinicWorkingHours.workingHours,
-      timeframe.start.toDate(),
-      timeframe.end.toDate(),
-      tz
-    );
-    return this.intersectIntervals(intervals, workingIntervals);
+    return docSnap.data();
+  } catch (error) {
+    console.error(`[StoredAnalytics] Error reading ${subcollection}/${period}/${documentId}:`, error);
+    return null;
+  }
+}
+async function readStoredPractitionerAnalytics(db, clinicBranchId, practitionerId, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    PRACTITIONER_ANALYTICS_SUBCOLLECTION,
+    practitionerId,
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredProcedureAnalytics(db, clinicBranchId, procedureId, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    PROCEDURE_ANALYTICS_SUBCOLLECTION,
+    procedureId,
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredDashboardAnalytics(db, clinicBranchId, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    DASHBOARD_ANALYTICS_SUBCOLLECTION,
+    "current",
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredTimeEfficiencyMetrics(db, clinicBranchId, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    TIME_EFFICIENCY_ANALYTICS_SUBCOLLECTION,
+    "current",
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredRevenueMetrics(db, clinicBranchId, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    REVENUE_ANALYTICS_SUBCOLLECTION,
+    "current",
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredCancellationMetrics(db, clinicBranchId, entityType, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    CANCELLATION_ANALYTICS_SUBCOLLECTION,
+    entityType,
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+async function readStoredNoShowMetrics(db, clinicBranchId, entityType, options = {}) {
+  const { useCache = true, maxCacheAgeHours = 12, period = "all_time" } = options;
+  if (!useCache) {
+    return null;
+  }
+  const stored = await readStoredAnalytics(
+    db,
+    clinicBranchId,
+    NO_SHOW_ANALYTICS_SUBCOLLECTION,
+    entityType,
+    period
+  );
+  if (!stored) {
+    return null;
+  }
+  if (!isAnalyticsDataFresh(stored.metadata.computedAt, maxCacheAgeHours)) {
+    return null;
+  }
+  return stored;
+}
+
+// src/services/analytics/utils/grouping.utils.ts
+function getTechnologyId(appointment) {
+  var _a;
+  return ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+}
+function getTechnologyName(appointment) {
+  var _a, _b;
+  return ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyName) || ((_b = appointment.procedureInfo) == null ? void 0 : _b.technologyName) || "Unknown";
+}
+function getEntityName(appointment, entityType) {
+  var _a, _b, _c, _d, _e, _f;
+  switch (entityType) {
+    case "clinic":
+      return ((_a = appointment.clinicInfo) == null ? void 0 : _a.name) || "Unknown";
+    case "practitioner":
+      return ((_b = appointment.practitionerInfo) == null ? void 0 : _b.name) || "Unknown";
+    case "patient":
+      return ((_c = appointment.patientInfo) == null ? void 0 : _c.fullName) || "Unknown";
+    case "procedure":
+      return ((_d = appointment.procedureInfo) == null ? void 0 : _d.name) || "Unknown";
+    case "technology":
+      return ((_e = appointment.procedureExtendedInfo) == null ? void 0 : _e.procedureTechnologyName) || ((_f = appointment.procedureInfo) == null ? void 0 : _f.technologyName) || "Unknown";
+  }
+}
+function getEntityId(appointment, entityType) {
+  var _a;
+  switch (entityType) {
+    case "clinic":
+      return appointment.clinicBranchId;
+    case "practitioner":
+      return appointment.practitionerId;
+    case "patient":
+      return appointment.patientId;
+    case "procedure":
+      return appointment.procedureId;
+    case "technology":
+      return ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+  }
+}
+function groupAppointmentsByEntity(appointments, entityType) {
+  const entityMap = /* @__PURE__ */ new Map();
+  appointments.forEach((appointment) => {
+    let entityId;
+    let entityName;
+    if (entityType === "technology") {
+      entityId = getTechnologyId(appointment);
+      entityName = getTechnologyName(appointment);
+    } else {
+      entityId = getEntityId(appointment, entityType);
+      entityName = getEntityName(appointment, entityType);
+    }
+    if (!entityMap.has(entityId)) {
+      entityMap.set(entityId, { name: entityName, appointments: [] });
+    }
+    entityMap.get(entityId).appointments.push(appointment);
+  });
+  return entityMap;
+}
+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)
+    );
+    const { totalRevenue, currency } = calculateTotalRevenue(entityCompleted);
+    let totalTax = 0;
+    let totalSubtotal = 0;
+    let unpaidRevenue = 0;
+    let refundedRevenue = 0;
+    entityCompleted.forEach((appointment) => {
+      const costData = calculateAppointmentCost(appointment);
+      if (costData.source === "finalbilling") {
+        totalTax += costData.tax || 0;
+        totalSubtotal += costData.subtotal || 0;
+      } else {
+        totalSubtotal += costData.cost;
+      }
+      if (appointment.paymentStatus === "unpaid") {
+        unpaidRevenue += costData.cost;
+      } else if (appointment.paymentStatus === "refunded") {
+        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,
+      entityType,
+      totalRevenue,
+      averageRevenuePerAppointment: entityCompleted.length > 0 ? totalRevenue / entityCompleted.length : 0,
+      totalAppointments: entityAppointments.length,
+      completedAppointments: entityCompleted.length,
+      currency,
+      unpaidRevenue,
+      refundedRevenue,
+      totalTax,
+      totalSubtotal,
+      ...practitionerId && { practitionerId },
+      ...practitionerName && { practitionerName }
+    };
+  });
+}
+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)
+    );
+    const productMap = /* @__PURE__ */ new Map();
+    entityCompleted.forEach((appointment) => {
+      const products = extractProductUsage(appointment);
+      products.forEach((product) => {
+        if (productMap.has(product.productId)) {
+          const existing = productMap.get(product.productId);
+          existing.quantity += product.quantity;
+          existing.revenue += product.subtotal;
+          existing.usageCount++;
+        } else {
+          productMap.set(product.productId, {
+            name: product.productName,
+            brandName: product.brandName,
+            quantity: product.quantity,
+            revenue: product.subtotal,
+            usageCount: 1
+          });
+        }
+      });
+    });
+    const topProducts = Array.from(productMap.entries()).map(([productId, productData]) => ({
+      productId,
+      productName: productData.name,
+      brandName: productData.brandName,
+      totalQuantity: productData.quantity,
+      totalRevenue: productData.revenue,
+      usageCount: productData.usageCount
+    })).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,
+      entityType,
+      totalProductsUsed: productMap.size,
+      uniqueProducts: productMap.size,
+      totalProductRevenue,
+      totalProductQuantity,
+      averageProductsPerAppointment: entityCompleted.length > 0 ? productMap.size / entityCompleted.length : 0,
+      topProducts,
+      ...practitionerId && { practitionerId },
+      ...practitionerName && { practitionerName }
+    };
+  });
+}
+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,
+      entityType,
+      totalAppointments: entityCompleted.length,
+      appointmentsWithActualTime: timeMetrics.appointmentsWithActualTime,
+      averageBookedDuration: timeMetrics.averageBookedDuration,
+      averageActualDuration: timeMetrics.averageActualDuration,
+      averageEfficiency: timeMetrics.averageEfficiency,
+      totalOverrun: timeMetrics.totalOverrun,
+      totalUnderutilization: timeMetrics.totalUnderutilization,
+      averageOverrun: timeMetrics.averageOverrun,
+      averageUnderutilization: timeMetrics.averageUnderutilization,
+      ...practitionerId && { practitionerId },
+      ...practitionerName && { practitionerName }
+    };
+  });
+}
+function calculateGroupedPatientBehaviorMetrics(appointments, entityType) {
+  const entityMap = groupAppointmentsByEntity(appointments, entityType);
+  const canceled = getCanceledAppointments(appointments);
+  const noShow = getNoShowAppointments(appointments);
+  return Array.from(entityMap.entries()).map(([entityId, data]) => {
+    const entityAppointments = data.appointments;
+    const patientMap = /* @__PURE__ */ new Map();
+    entityAppointments.forEach((appointment) => {
+      var _a;
+      const patientId = appointment.patientId;
+      const patientName = ((_a = appointment.patientInfo) == null ? void 0 : _a.fullName) || "Unknown";
+      if (!patientMap.has(patientId)) {
+        patientMap.set(patientId, {
+          name: patientName,
+          appointments: [],
+          noShows: [],
+          cancellations: []
+        });
+      }
+      const patientData = patientMap.get(patientId);
+      patientData.appointments.push(appointment);
+      if (noShow.some((ns) => ns.id === appointment.id)) {
+        patientData.noShows.push(appointment);
+      }
+      if (canceled.some((c) => c.id === appointment.id)) {
+        patientData.cancellations.push(appointment);
+      }
+    });
+    const patientMetrics = Array.from(patientMap.entries()).map(([patientId, patientData]) => ({
+      patientId,
+      patientName: patientData.name,
+      noShowCount: patientData.noShows.length,
+      cancellationCount: patientData.cancellations.length,
+      totalAppointments: patientData.appointments.length,
+      noShowRate: calculatePercentage(
+        patientData.noShows.length,
+        patientData.appointments.length
+      ),
+      cancellationRate: calculatePercentage(
+        patientData.cancellations.length,
+        patientData.appointments.length
+      )
+    }));
+    const patientsWithNoShows = patientMetrics.filter((p) => p.noShowCount > 0).length;
+    const patientsWithCancellations = patientMetrics.filter((p) => p.cancellationCount > 0).length;
+    const averageNoShowRate = patientMetrics.length > 0 ? patientMetrics.reduce((sum, p) => sum + p.noShowRate, 0) / patientMetrics.length : 0;
+    const averageCancellationRate = patientMetrics.length > 0 ? patientMetrics.reduce((sum, p) => sum + p.cancellationRate, 0) / patientMetrics.length : 0;
+    const topNoShowPatients = patientMetrics.filter((p) => p.noShowCount > 0).sort((a, b) => b.noShowRate - a.noShowRate).slice(0, 10).map((p) => ({
+      patientId: p.patientId,
+      patientName: p.patientName,
+      noShowCount: p.noShowCount,
+      totalAppointments: p.totalAppointments,
+      noShowRate: p.noShowRate
+    }));
+    const topCancellationPatients = patientMetrics.filter((p) => p.cancellationCount > 0).sort((a, b) => b.cancellationRate - a.cancellationRate).slice(0, 10).map((p) => ({
+      patientId: p.patientId,
+      patientName: p.patientName,
+      cancellationCount: p.cancellationCount,
+      totalAppointments: p.totalAppointments,
+      cancellationRate: p.cancellationRate
+    }));
+    const newPatients = patientMetrics.filter((p) => p.totalAppointments === 1).length;
+    const returningPatients = patientMetrics.filter((p) => p.totalAppointments > 1).length;
+    return {
+      entityId,
+      entityName: data.name,
+      entityType,
+      totalPatients: patientMap.size,
+      patientsWithNoShows,
+      patientsWithCancellations,
+      averageNoShowRate: Math.round(averageNoShowRate * 100) / 100,
+      averageCancellationRate: Math.round(averageCancellationRate * 100) / 100,
+      topNoShowPatients,
+      topCancellationPatients
+    };
+  });
+}
+
+// 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 {
+  /**
+   * Creates a new AnalyticsService instance.
+   *
+   * @param db Firestore instance
+   * @param auth Firebase Auth instance
+   * @param app Firebase App instance
+   * @param appointmentService Appointment service instance for querying appointments
+   */
+  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
+   *
+   * @param filters - Optional filters
+   * @param dateRange - Optional date range
+   * @returns Array of appointments
+   */
+  async fetchAppointments(filters, dateRange) {
+    try {
+      const constraints = [];
+      if (filters == null ? void 0 : filters.clinicBranchId) {
+        constraints.push(where2("clinicBranchId", "==", filters.clinicBranchId));
+      }
+      if (filters == null ? void 0 : filters.practitionerId) {
+        constraints.push(where2("practitionerId", "==", filters.practitionerId));
+      }
+      if (filters == null ? void 0 : filters.procedureId) {
+        constraints.push(where2("procedureId", "==", filters.procedureId));
+      }
+      if (filters == null ? void 0 : filters.patientId) {
+        constraints.push(where2("patientId", "==", filters.patientId));
+      }
+      if (dateRange) {
+        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;
+      if (filters == null ? void 0 : filters.practitionerId) searchParams.practitionerId = filters.practitionerId;
+      if (filters == null ? void 0 : filters.procedureId) searchParams.procedureId = filters.procedureId;
+      if (filters == null ? void 0 : filters.patientId) searchParams.patientId = filters.patientId;
+      if (dateRange) {
+        searchParams.startDate = dateRange.start;
+        searchParams.endDate = dateRange.end;
+      }
+      const result = await this.appointmentService.searchAppointments(searchParams);
+      return result.appointments;
+    } catch (error) {
+      console.error("[AnalyticsService] Error fetching appointments:", error);
+      throw error;
+    }
+  }
+  // ==========================================
+  // Practitioner Analytics
+  // ==========================================
+  /**
+   * Get practitioner performance metrics
+   * First checks for stored analytics, then calculates if not available or stale
+   *
+   * @param practitionerId - ID of the practitioner
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics
+   * @returns Practitioner analytics object
+   */
+  async getPractitionerAnalytics(practitionerId, dateRange, options) {
+    var _a;
+    if (dateRange && (options == null ? void 0 : options.useCache) !== false) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const clinicBranchId = options == null ? void 0 : options.clinicBranchId;
+      if (clinicBranchId) {
+        const stored = await readStoredPractitionerAnalytics(
+          this.db,
+          clinicBranchId,
+          practitionerId,
+          { ...options, period }
+        );
+        if (stored) {
+          const { metadata, ...analytics } = stored;
+          return analytics;
+        }
+      }
+    }
+    const appointments = await this.fetchAppointments({ practitionerId }, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const canceled = getCanceledAppointments(appointments);
+    const noShow = getNoShowAppointments(appointments);
+    const pending = filterAppointments(appointments, { practitionerId }).filter(
+      (a) => a.status === "pending" /* PENDING */
+    );
+    const confirmed = filterAppointments(appointments, { practitionerId }).filter(
+      (a) => a.status === "confirmed" /* CONFIRMED */
+    );
+    const { totalRevenue, currency } = calculateTotalRevenue(completed);
+    const timeMetrics = calculateAverageTimeMetrics(completed);
+    const uniquePatients = new Set(appointments.map((a) => a.patientId));
+    const returningPatients = new Set(
+      appointments.filter((a) => {
+        const patientAppointments = appointments.filter((ap) => ap.patientId === a.patientId);
+        return patientAppointments.length > 1;
+      }).map((a) => a.patientId)
+    );
+    const procedureMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      var _a2;
+      const procId = appointment.procedureId;
+      const procName = ((_a2 = appointment.procedureInfo) == null ? void 0 : _a2.name) || "Unknown";
+      const cost = calculateAppointmentCost(appointment).cost;
+      if (procedureMap.has(procId)) {
+        const existing = procedureMap.get(procId);
+        existing.count++;
+        existing.revenue += cost;
+      } else {
+        procedureMap.set(procId, { name: procName, count: 1, revenue: cost });
+      }
+    });
+    const topProcedures = Array.from(procedureMap.entries()).map(([procedureId, data]) => ({
+      procedureId,
+      procedureName: data.name,
+      count: data.count,
+      revenue: data.revenue
+    })).sort((a, b) => b.count - a.count).slice(0, 10);
+    const practitionerName = appointments.length > 0 ? ((_a = appointments[0].practitionerInfo) == null ? void 0 : _a.name) || "Unknown" : "Unknown";
+    return {
+      total: appointments.length,
+      dateRange,
+      practitionerId,
+      practitionerName,
+      totalAppointments: appointments.length,
+      completedAppointments: completed.length,
+      canceledAppointments: canceled.length,
+      noShowAppointments: noShow.length,
+      pendingAppointments: pending.length,
+      confirmedAppointments: confirmed.length,
+      cancellationRate: calculatePercentage(canceled.length, appointments.length),
+      noShowRate: calculatePercentage(noShow.length, appointments.length),
+      averageBookedTime: timeMetrics.averageBookedDuration,
+      averageActualTime: timeMetrics.averageActualDuration,
+      timeEfficiency: timeMetrics.averageEfficiency,
+      totalRevenue,
+      averageRevenuePerAppointment: completed.length > 0 ? totalRevenue / completed.length : 0,
+      currency,
+      topProcedures,
+      patientRetentionRate: calculatePercentage(returningPatients.size, uniquePatients.size),
+      uniquePatients: uniquePatients.size
+    };
+  }
+  // ==========================================
+  // Procedure Analytics
+  // ==========================================
+  /**
+   * Get procedure performance metrics
+   * First checks for stored analytics, then calculates if not available or stale
+   *
+   * @param procedureId - ID of the procedure (optional, if not provided returns all)
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics
+   * @returns Procedure analytics object or array
+   */
+  async getProcedureAnalytics(procedureId, dateRange, options) {
+    if (procedureId && dateRange && (options == null ? void 0 : options.useCache) !== false) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const clinicBranchId = options == null ? void 0 : options.clinicBranchId;
+      if (clinicBranchId) {
+        const stored = await readStoredProcedureAnalytics(
+          this.db,
+          clinicBranchId,
+          procedureId,
+          { ...options, period }
+        );
+        if (stored) {
+          const { metadata, ...analytics } = stored;
+          return analytics;
+        }
+      }
+    }
+    const appointments = await this.fetchAppointments(procedureId ? { procedureId } : void 0, dateRange);
+    if (procedureId) {
+      return this.calculateProcedureAnalytics(appointments, procedureId);
+    }
+    const procedureMap = /* @__PURE__ */ new Map();
+    appointments.forEach((appointment) => {
+      const procId = appointment.procedureId;
+      if (!procedureMap.has(procId)) {
+        procedureMap.set(procId, []);
+      }
+      procedureMap.get(procId).push(appointment);
+    });
+    return Array.from(procedureMap.entries()).map(
+      ([procId, procAppointments]) => this.calculateProcedureAnalytics(procAppointments, procId)
+    );
+  }
+  /**
+   * Calculate analytics for a specific procedure
+   *
+   * @param appointments - Appointments for the procedure
+   * @param procedureId - Procedure ID
+   * @returns Procedure analytics
+   */
+  calculateProcedureAnalytics(appointments, procedureId) {
+    const completed = getCompletedAppointments(appointments);
+    const canceled = getCanceledAppointments(appointments);
+    const noShow = getNoShowAppointments(appointments);
+    const { totalRevenue, currency } = calculateTotalRevenue(completed);
+    const timeMetrics = calculateAverageTimeMetrics(completed);
+    const firstAppointment = appointments[0];
+    const procedureInfo = (firstAppointment == null ? void 0 : firstAppointment.procedureExtendedInfo) || (firstAppointment == null ? void 0 : firstAppointment.procedureInfo);
+    const productMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      const products = extractProductUsage(appointment);
+      products.forEach((product) => {
+        if (productMap.has(product.productId)) {
+          const existing = productMap.get(product.productId);
+          existing.quantity += product.quantity;
+          existing.revenue += product.subtotal;
+          existing.usageCount++;
+        } else {
+          productMap.set(product.productId, {
+            name: product.productName,
+            brandName: product.brandName,
+            quantity: product.quantity,
+            revenue: product.subtotal,
+            usageCount: 1
+          });
+        }
+      });
+    });
+    const productUsage = Array.from(productMap.entries()).map(([productId, data]) => ({
+      productId,
+      productName: data.name,
+      brandName: data.brandName,
+      totalQuantity: data.quantity,
+      totalRevenue: data.revenue,
+      usageCount: data.usageCount
+    }));
+    return {
+      total: appointments.length,
+      procedureId,
+      procedureName: (procedureInfo == null ? void 0 : procedureInfo.name) || "Unknown",
+      procedureFamily: (procedureInfo == null ? void 0 : procedureInfo.procedureFamily) || "",
+      categoryName: (procedureInfo == null ? void 0 : procedureInfo.procedureCategoryName) || "",
+      subcategoryName: (procedureInfo == null ? void 0 : procedureInfo.procedureSubCategoryName) || "",
+      technologyName: (procedureInfo == null ? void 0 : procedureInfo.procedureTechnologyName) || "",
+      totalAppointments: appointments.length,
+      completedAppointments: completed.length,
+      canceledAppointments: canceled.length,
+      noShowAppointments: noShow.length,
+      cancellationRate: calculatePercentage(canceled.length, appointments.length),
+      noShowRate: calculatePercentage(noShow.length, appointments.length),
+      averageCost: completed.length > 0 ? totalRevenue / completed.length : 0,
+      totalRevenue,
+      averageRevenuePerAppointment: completed.length > 0 ? totalRevenue / completed.length : 0,
+      currency,
+      averageBookedDuration: timeMetrics.averageBookedDuration,
+      averageActualDuration: timeMetrics.averageActualDuration,
+      productUsage
+    };
+  }
+  /**
+   * Get procedure popularity metrics
+   *
+   * @param dateRange - Optional date range filter
+   * @param limit - Number of top procedures to return
+   * @returns Array of procedure popularity metrics
+   */
+  async getProcedurePopularity(dateRange, limit = 10) {
+    const appointments = await this.fetchAppointments(void 0, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const procedureMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      const procId = appointment.procedureId;
+      const procInfo = appointment.procedureExtendedInfo || appointment.procedureInfo;
+      if (procedureMap.has(procId)) {
+        procedureMap.get(procId).count++;
+      } else {
+        procedureMap.set(procId, {
+          name: (procInfo == null ? void 0 : procInfo.name) || "Unknown",
+          category: (procInfo == null ? void 0 : procInfo.procedureCategoryName) || "",
+          subcategory: (procInfo == null ? void 0 : procInfo.procedureSubCategoryName) || "",
+          technology: (procInfo == null ? void 0 : procInfo.procedureTechnologyName) || "",
+          count: 1
+        });
+      }
+    });
+    return Array.from(procedureMap.entries()).map(([procedureId, data]) => ({
+      procedureId,
+      procedureName: data.name,
+      categoryName: data.category,
+      subcategoryName: data.subcategory,
+      technologyName: data.technology,
+      appointmentCount: data.count,
+      completedCount: data.count,
+      rank: 0
+      // Will be set after sorting
+    })).sort((a, b) => b.appointmentCount - a.appointmentCount).slice(0, limit).map((item, index) => ({ ...item, rank: index + 1 }));
+  }
+  /**
+   * Get procedure profitability metrics
+   *
+   * @param dateRange - Optional date range filter
+   * @param limit - Number of top procedures to return
+   * @returns Array of procedure profitability metrics
+   */
+  async getProcedureProfitability(dateRange, limit = 10) {
+    const appointments = await this.fetchAppointments(void 0, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const procedureMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      const procId = appointment.procedureId;
+      const procInfo = appointment.procedureExtendedInfo || appointment.procedureInfo;
+      const cost = calculateAppointmentCost(appointment).cost;
+      if (procedureMap.has(procId)) {
+        const existing = procedureMap.get(procId);
+        existing.revenue += cost;
+        existing.count++;
+      } else {
+        procedureMap.set(procId, {
+          name: (procInfo == null ? void 0 : procInfo.name) || "Unknown",
+          category: (procInfo == null ? void 0 : procInfo.procedureCategoryName) || "",
+          subcategory: (procInfo == null ? void 0 : procInfo.procedureSubCategoryName) || "",
+          technology: (procInfo == null ? void 0 : procInfo.procedureTechnologyName) || "",
+          revenue: cost,
+          count: 1
+        });
+      }
+    });
+    return Array.from(procedureMap.entries()).map(([procedureId, data]) => ({
+      procedureId,
+      procedureName: data.name,
+      categoryName: data.category,
+      subcategoryName: data.subcategory,
+      technologyName: data.technology,
+      totalRevenue: data.revenue,
+      averageRevenue: data.count > 0 ? data.revenue / data.count : 0,
+      appointmentCount: data.count,
+      rank: 0
+      // Will be set after sorting
+    })).sort((a, b) => b.totalRevenue - a.totalRevenue).slice(0, limit).map((item, index) => ({ ...item, rank: index + 1 }));
+  }
+  // ==========================================
+  // Time Efficiency Analytics
+  // ==========================================
+  /**
+   * Get time efficiency metrics grouped by clinic, practitioner, procedure, patient, or technology
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'procedure' | 'patient' | 'technology'
+   * @param dateRange - Optional date range filter
+   * @param filters - Optional additional filters
+   * @returns Grouped time efficiency metrics
+   */
+  async getTimeEfficiencyMetricsByEntity(groupBy, dateRange, filters) {
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    return calculateGroupedTimeEfficiencyMetrics(appointments, groupBy);
+  }
+  /**
+   * Get time efficiency metrics for appointments
+   * First checks for stored analytics, then calculates if not available or stale
+   *
+   * @param filters - Optional filters
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics
+   * @returns Time efficiency metrics
+   */
+  async getTimeEfficiencyMetrics(filters, dateRange, options) {
+    if ((filters == null ? void 0 : filters.clinicBranchId) && dateRange && (options == null ? void 0 : options.useCache) !== false) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const stored = await readStoredTimeEfficiencyMetrics(
+        this.db,
+        filters.clinicBranchId,
+        { ...options, period }
+      );
+      if (stored) {
+        const { metadata, ...metrics } = stored;
+        return metrics;
+      }
+    }
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const timeMetrics = calculateAverageTimeMetrics(completed);
+    const efficiencyDistribution = calculateEfficiencyDistribution(completed);
+    return {
+      totalAppointments: completed.length,
+      appointmentsWithActualTime: timeMetrics.appointmentsWithActualTime,
+      averageBookedDuration: timeMetrics.averageBookedDuration,
+      averageActualDuration: timeMetrics.averageActualDuration,
+      averageEfficiency: timeMetrics.averageEfficiency,
+      totalOverrun: timeMetrics.totalOverrun,
+      totalUnderutilization: timeMetrics.totalUnderutilization,
+      averageOverrun: timeMetrics.averageOverrun,
+      averageUnderutilization: timeMetrics.averageUnderutilization,
+      efficiencyDistribution
+    };
+  }
+  // ==========================================
+  // Cancellation & No-Show Analytics
+  // ==========================================
+  /**
+   * Get cancellation metrics
+   * First checks for stored analytics when grouping by clinic, then calculates if not available or stale
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'patient' | 'procedure' | 'technology'
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics (requires clinicBranchId for cache)
+   * @returns Cancellation metrics grouped by specified entity
+   */
+  async getCancellationMetrics(groupBy, dateRange, options) {
+    if (groupBy === "clinic" && dateRange && (options == null ? void 0 : options.useCache) !== false && (options == null ? void 0 : options.clinicBranchId)) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const stored = await readStoredCancellationMetrics(
+        this.db,
+        options.clinicBranchId,
+        "clinic",
+        { ...options, period }
+      );
+      if (stored) {
+        const { metadata, ...metrics } = stored;
+        return metrics;
+      }
+    }
+    const appointments = await this.fetchAppointments(void 0, dateRange);
+    const canceled = getCanceledAppointments(appointments);
+    if (groupBy === "clinic") {
+      return this.groupCancellationsByClinic(canceled, appointments);
+    } else if (groupBy === "practitioner") {
+      return this.groupCancellationsByPractitioner(canceled, appointments);
+    } else if (groupBy === "patient") {
+      return this.groupCancellationsByPatient(canceled, appointments);
+    } else if (groupBy === "technology") {
+      return this.groupCancellationsByTechnology(canceled, appointments);
+    } else {
+      return this.groupCancellationsByProcedure(canceled, appointments);
+    }
+  }
+  /**
+   * Group cancellations by clinic
+   */
+  groupCancellationsByClinic(canceled, allAppointments) {
+    const clinicMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const clinicId = appointment.clinicBranchId;
+      const clinicName = ((_a = appointment.clinicInfo) == null ? void 0 : _a.name) || "Unknown";
+      if (!clinicMap.has(clinicId)) {
+        clinicMap.set(clinicId, { name: clinicName, canceled: [], all: [] });
+      }
+      clinicMap.get(clinicId).all.push(appointment);
+    });
+    canceled.forEach((appointment) => {
+      const clinicId = appointment.clinicBranchId;
+      if (clinicMap.has(clinicId)) {
+        clinicMap.get(clinicId).canceled.push(appointment);
+      }
+    });
+    return Array.from(clinicMap.entries()).map(
+      ([clinicId, data]) => this.calculateCancellationMetrics(clinicId, data.name, "clinic", data.canceled, data.all)
+    );
+  }
+  /**
+   * Group cancellations by practitioner
+   */
+  groupCancellationsByPractitioner(canceled, allAppointments) {
+    const practitionerMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const practitionerId = appointment.practitionerId;
+      const practitionerName = ((_a = appointment.practitionerInfo) == null ? void 0 : _a.name) || "Unknown";
+      if (!practitionerMap.has(practitionerId)) {
+        practitionerMap.set(practitionerId, { name: practitionerName, canceled: [], all: [] });
+      }
+      practitionerMap.get(practitionerId).all.push(appointment);
+    });
+    canceled.forEach((appointment) => {
+      const practitionerId = appointment.practitionerId;
+      if (practitionerMap.has(practitionerId)) {
+        practitionerMap.get(practitionerId).canceled.push(appointment);
+      }
+    });
+    return Array.from(practitionerMap.entries()).map(
+      ([practitionerId, data]) => this.calculateCancellationMetrics(
+        practitionerId,
+        data.name,
+        "practitioner",
+        data.canceled,
+        data.all
+      )
+    );
+  }
+  /**
+   * Group cancellations by patient
+   */
+  groupCancellationsByPatient(canceled, allAppointments) {
+    const patientMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const patientId = appointment.patientId;
+      const patientName = ((_a = appointment.patientInfo) == null ? void 0 : _a.fullName) || "Unknown";
+      if (!patientMap.has(patientId)) {
+        patientMap.set(patientId, { name: patientName, canceled: [], all: [] });
+      }
+      patientMap.get(patientId).all.push(appointment);
+    });
+    canceled.forEach((appointment) => {
+      const patientId = appointment.patientId;
+      if (patientMap.has(patientId)) {
+        patientMap.get(patientId).canceled.push(appointment);
+      }
+    });
+    return Array.from(patientMap.entries()).map(
+      ([patientId, data]) => this.calculateCancellationMetrics(patientId, data.name, "patient", data.canceled, data.all)
+    );
+  }
+  /**
+   * Group cancellations by procedure
+   */
+  groupCancellationsByProcedure(canceled, allAppointments) {
+    const procedureMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      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: [],
+          practitionerId: appointment.practitionerId,
+          practitionerName: (_b = appointment.practitionerInfo) == null ? void 0 : _b.name
+        });
+      }
+      procedureMap.get(procedureId).all.push(appointment);
+    });
+    canceled.forEach((appointment) => {
+      const procedureId = appointment.procedureId;
+      if (procedureMap.has(procedureId)) {
+        procedureMap.get(procedureId).canceled.push(appointment);
+      }
+    });
+    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
+   * Aggregates all procedures using the same technology across all doctors
+   */
+  groupCancellationsByTechnology(canceled, allAppointments) {
+    const technologyMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a, _b, _c;
+      const technologyId = ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+      const technologyName = ((_b = appointment.procedureExtendedInfo) == null ? void 0 : _b.procedureTechnologyName) || ((_c = appointment.procedureInfo) == null ? void 0 : _c.technologyName) || "Unknown";
+      if (!technologyMap.has(technologyId)) {
+        technologyMap.set(technologyId, { name: technologyName, canceled: [], all: [] });
+      }
+      technologyMap.get(technologyId).all.push(appointment);
+    });
+    canceled.forEach((appointment) => {
+      var _a;
+      const technologyId = ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+      if (technologyMap.has(technologyId)) {
+        technologyMap.get(technologyId).canceled.push(appointment);
+      }
+    });
+    return Array.from(technologyMap.entries()).map(
+      ([technologyId, data]) => this.calculateCancellationMetrics(
+        technologyId,
+        data.name,
+        "technology",
+        data.canceled,
+        data.all
+      )
+    );
+  }
+  /**
+   * Calculate cancellation metrics for a specific entity
+   */
+  calculateCancellationMetrics(entityId, entityName, entityType, canceled, all) {
+    const canceledByPatient = canceled.filter(
+      (a) => a.status === "canceled_patient" /* CANCELED_PATIENT */
+    ).length;
+    const canceledByClinic = canceled.filter(
+      (a) => a.status === "canceled_clinic" /* CANCELED_CLINIC */
+    ).length;
+    const canceledRescheduled = canceled.filter(
+      (a) => a.status === "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */
+    ).length;
+    const leadTimes = canceled.map((a) => calculateCancellationLeadTime(a)).filter((lt) => lt !== null);
+    const averageLeadTime = leadTimes.length > 0 ? leadTimes.reduce((a, b) => a + b, 0) / leadTimes.length : 0;
+    const reasonMap = /* @__PURE__ */ new Map();
+    canceled.forEach((appointment) => {
+      const reason = appointment.cancellationReason || "No reason provided";
+      reasonMap.set(reason, (reasonMap.get(reason) || 0) + 1);
+    });
+    const cancellationReasons = Array.from(reasonMap.entries()).map(([reason, count]) => ({
+      reason,
+      count,
+      percentage: calculatePercentage(count, canceled.length)
+    }));
+    return {
+      entityId,
+      entityName,
+      entityType,
+      totalAppointments: all.length,
+      canceledAppointments: canceled.length,
+      cancellationRate: calculatePercentage(canceled.length, all.length),
+      canceledByPatient,
+      canceledByClinic,
+      canceledByPractitioner: 0,
+      // Not tracked in current status enum
+      canceledRescheduled,
+      averageCancellationLeadTime: Math.round(averageLeadTime * 100) / 100,
+      cancellationReasons
+    };
+  }
+  /**
+   * Get no-show metrics
+   * First checks for stored analytics when grouping by clinic, then calculates if not available or stale
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'patient' | 'procedure' | 'technology'
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics (requires clinicBranchId for cache)
+   * @returns No-show metrics grouped by specified entity
+   */
+  async getNoShowMetrics(groupBy, dateRange, options) {
+    if (groupBy === "clinic" && dateRange && (options == null ? void 0 : options.useCache) !== false && (options == null ? void 0 : options.clinicBranchId)) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const stored = await readStoredNoShowMetrics(
+        this.db,
+        options.clinicBranchId,
+        "clinic",
+        { ...options, period }
+      );
+      if (stored) {
+        const { metadata, ...metrics } = stored;
+        return metrics;
+      }
+    }
+    const appointments = await this.fetchAppointments(void 0, dateRange);
+    const noShow = getNoShowAppointments(appointments);
+    if (groupBy === "clinic") {
+      return this.groupNoShowsByClinic(noShow, appointments);
+    } else if (groupBy === "practitioner") {
+      return this.groupNoShowsByPractitioner(noShow, appointments);
+    } else if (groupBy === "patient") {
+      return this.groupNoShowsByPatient(noShow, appointments);
+    } else if (groupBy === "technology") {
+      return this.groupNoShowsByTechnology(noShow, appointments);
+    } else {
+      return this.groupNoShowsByProcedure(noShow, appointments);
+    }
+  }
+  /**
+   * Group no-shows by clinic
+   */
+  groupNoShowsByClinic(noShow, allAppointments) {
+    const clinicMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const clinicId = appointment.clinicBranchId;
+      const clinicName = ((_a = appointment.clinicInfo) == null ? void 0 : _a.name) || "Unknown";
+      if (!clinicMap.has(clinicId)) {
+        clinicMap.set(clinicId, { name: clinicName, noShow: [], all: [] });
+      }
+      clinicMap.get(clinicId).all.push(appointment);
+    });
+    noShow.forEach((appointment) => {
+      const clinicId = appointment.clinicBranchId;
+      if (clinicMap.has(clinicId)) {
+        clinicMap.get(clinicId).noShow.push(appointment);
+      }
+    });
+    return Array.from(clinicMap.entries()).map(([clinicId, data]) => ({
+      entityId: clinicId,
+      entityName: data.name,
+      entityType: "clinic",
+      totalAppointments: data.all.length,
+      noShowAppointments: data.noShow.length,
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length)
+    }));
+  }
+  /**
+   * Group no-shows by practitioner
+   */
+  groupNoShowsByPractitioner(noShow, allAppointments) {
+    const practitionerMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const practitionerId = appointment.practitionerId;
+      const practitionerName = ((_a = appointment.practitionerInfo) == null ? void 0 : _a.name) || "Unknown";
+      if (!practitionerMap.has(practitionerId)) {
+        practitionerMap.set(practitionerId, { name: practitionerName, noShow: [], all: [] });
+      }
+      practitionerMap.get(practitionerId).all.push(appointment);
+    });
+    noShow.forEach((appointment) => {
+      const practitionerId = appointment.practitionerId;
+      if (practitionerMap.has(practitionerId)) {
+        practitionerMap.get(practitionerId).noShow.push(appointment);
+      }
+    });
+    return Array.from(practitionerMap.entries()).map(([practitionerId, data]) => ({
+      entityId: practitionerId,
+      entityName: data.name,
+      entityType: "practitioner",
+      totalAppointments: data.all.length,
+      noShowAppointments: data.noShow.length,
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length)
+    }));
+  }
+  /**
+   * Group no-shows by patient
+   */
+  groupNoShowsByPatient(noShow, allAppointments) {
+    const patientMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a;
+      const patientId = appointment.patientId;
+      const patientName = ((_a = appointment.patientInfo) == null ? void 0 : _a.fullName) || "Unknown";
+      if (!patientMap.has(patientId)) {
+        patientMap.set(patientId, { name: patientName, noShow: [], all: [] });
+      }
+      patientMap.get(patientId).all.push(appointment);
+    });
+    noShow.forEach((appointment) => {
+      const patientId = appointment.patientId;
+      if (patientMap.has(patientId)) {
+        patientMap.get(patientId).noShow.push(appointment);
+      }
+    });
+    return Array.from(patientMap.entries()).map(([patientId, data]) => ({
+      entityId: patientId,
+      entityName: data.name,
+      entityType: "patient",
+      totalAppointments: data.all.length,
+      noShowAppointments: data.noShow.length,
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length)
+    }));
+  }
+  /**
+   * Group no-shows by procedure
+   */
+  groupNoShowsByProcedure(noShow, allAppointments) {
+    const procedureMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      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: [],
+          practitionerId: appointment.practitionerId,
+          practitionerName: (_b = appointment.practitionerInfo) == null ? void 0 : _b.name
+        });
+      }
+      procedureMap.get(procedureId).all.push(appointment);
+    });
+    noShow.forEach((appointment) => {
+      const procedureId = appointment.procedureId;
+      if (procedureMap.has(procedureId)) {
+        procedureMap.get(procedureId).noShow.push(appointment);
+      }
+    });
+    return Array.from(procedureMap.entries()).map(([procedureId, data]) => ({
+      entityId: procedureId,
+      entityName: data.name,
+      entityType: "procedure",
+      totalAppointments: data.all.length,
+      noShowAppointments: data.noShow.length,
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length),
+      ...data.practitionerId && { practitionerId: data.practitionerId },
+      ...data.practitionerName && { practitionerName: data.practitionerName }
+    }));
+  }
+  /**
+   * Group no-shows by technology
+   * Aggregates all procedures using the same technology across all doctors
+   */
+  groupNoShowsByTechnology(noShow, allAppointments) {
+    const technologyMap = /* @__PURE__ */ new Map();
+    allAppointments.forEach((appointment) => {
+      var _a, _b, _c;
+      const technologyId = ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+      const technologyName = ((_b = appointment.procedureExtendedInfo) == null ? void 0 : _b.procedureTechnologyName) || ((_c = appointment.procedureInfo) == null ? void 0 : _c.technologyName) || "Unknown";
+      if (!technologyMap.has(technologyId)) {
+        technologyMap.set(technologyId, { name: technologyName, noShow: [], all: [] });
+      }
+      technologyMap.get(technologyId).all.push(appointment);
+    });
+    noShow.forEach((appointment) => {
+      var _a;
+      const technologyId = ((_a = appointment.procedureExtendedInfo) == null ? void 0 : _a.procedureTechnologyId) || "unknown-technology";
+      if (technologyMap.has(technologyId)) {
+        technologyMap.get(technologyId).noShow.push(appointment);
+      }
+    });
+    return Array.from(technologyMap.entries()).map(([technologyId, data]) => ({
+      entityId: technologyId,
+      entityName: data.name,
+      entityType: "technology",
+      totalAppointments: data.all.length,
+      noShowAppointments: data.noShow.length,
+      noShowRate: calculatePercentage(data.noShow.length, data.all.length)
+    }));
+  }
+  // ==========================================
+  // Financial Analytics
+  // ==========================================
+  /**
+   * Get revenue metrics grouped by clinic, practitioner, procedure, patient, or technology
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'procedure' | 'patient' | 'technology'
+   * @param dateRange - Optional date range filter
+   * @param filters - Optional additional filters
+   * @returns Grouped revenue metrics
+   */
+  async getRevenueMetricsByEntity(groupBy, dateRange, filters) {
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    return calculateGroupedRevenueMetrics(appointments, groupBy);
+  }
+  /**
+   * 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
+   * @returns Revenue metrics
+   */
+  async getRevenueMetrics(filters, dateRange, options) {
+    if ((filters == null ? void 0 : filters.clinicBranchId) && dateRange && (options == null ? void 0 : options.useCache) !== false) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const stored = await readStoredRevenueMetrics(
+        this.db,
+        filters.clinicBranchId,
+        { ...options, period }
+      );
+      if (stored) {
+        const { metadata, ...metrics } = stored;
+        return metrics;
+      }
+    }
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const { totalRevenue, currency } = calculateTotalRevenue(completed);
+    const revenueByStatus = {};
+    const { totalRevenue: completedRevenue } = calculateTotalRevenue(completed);
+    revenueByStatus["completed" /* COMPLETED */] = completedRevenue;
+    const revenueByPaymentStatus = {};
+    Object.values(PaymentStatus).forEach((paymentStatus) => {
+      const paymentAppointments = completed.filter((a) => a.paymentStatus === paymentStatus);
+      const { totalRevenue: paymentRevenue } = calculateTotalRevenue(paymentAppointments);
+      revenueByPaymentStatus[paymentStatus] = paymentRevenue;
+    });
+    const unpaid = completed.filter((a) => a.paymentStatus === "unpaid" /* UNPAID */);
+    const refunded = completed.filter((a) => a.paymentStatus === "refunded" /* REFUNDED */);
+    const { totalRevenue: unpaidRevenue } = calculateTotalRevenue(unpaid);
+    const { totalRevenue: refundedRevenue } = calculateTotalRevenue(refunded);
+    let totalTax = 0;
+    let totalSubtotal = 0;
+    completed.forEach((appointment) => {
+      const costData = calculateAppointmentCost(appointment);
+      if (costData.source === "finalbilling") {
+        totalTax += costData.tax || 0;
+        totalSubtotal += costData.subtotal || 0;
+      } else {
+        totalSubtotal += costData.cost;
+      }
+    });
+    return {
+      totalRevenue,
+      averageRevenuePerAppointment: completed.length > 0 ? totalRevenue / completed.length : 0,
+      totalAppointments: appointments.length,
+      completedAppointments: completed.length,
+      currency,
+      revenueByStatus,
+      revenueByPaymentStatus,
+      unpaidRevenue,
+      refundedRevenue,
+      totalTax,
+      totalSubtotal
+    };
+  }
+  // ==========================================
+  // Product Usage Analytics
+  // ==========================================
+  /**
+   * Get product usage metrics grouped by clinic, practitioner, procedure, or patient
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'procedure' | 'patient'
+   * @param dateRange - Optional date range filter
+   * @param filters - Optional additional filters
+   * @returns Grouped product usage metrics
+   */
+  async getProductUsageMetricsByEntity(groupBy, dateRange, filters) {
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    return calculateGroupedProductUsageMetrics(appointments, groupBy);
+  }
+  /**
+   * 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, 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) => {
+        if (productId && product.productId !== productId) {
+          return;
+        }
+        if (!productMap.has(product.productId)) {
+          productMap.set(product.productId, {
+            name: product.productName,
+            brandId: product.brandId,
+            brandName: product.brandName,
+            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;
+        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
+            });
+          }
+        }
+      });
+    });
+    const results = Array.from(productMap.entries()).map(([productId2, data]) => ({
+      productId: productId2,
+      productName: data.name,
+      brandId: data.brandId,
+      brandName: data.brandName,
+      totalQuantity: data.quantity,
+      totalRevenue: data.revenue,
+      averagePrice: data.usageCount > 0 ? data.revenue / data.quantity : 0,
+      currency: "CHF",
+      // Could be extracted from products
+      usageCount: data.usageCount,
+      averageQuantityPerAppointment: data.usageCount > 0 ? data.quantity / data.usageCount : 0,
+      usageByProcedure: Array.from(data.procedureMap.entries()).map(([procId, procData]) => ({
+        procedureId: procId,
+        procedureName: procData.name,
+        count: procData.count,
+        totalQuantity: procData.quantity
+      }))
+    }));
+    return productId ? results[0] : results;
+  }
+  // ==========================================
+  // Patient Analytics
+  // ==========================================
+  /**
+   * Get patient behavior metrics grouped by clinic, practitioner, procedure, or technology
+   * Shows patient no-show and cancellation patterns per entity
+   *
+   * @param groupBy - Group by 'clinic' | 'practitioner' | 'procedure' | 'technology'
+   * @param dateRange - Optional date range filter
+   * @param filters - Optional additional filters
+   * @returns Grouped patient behavior metrics
+   */
+  async getPatientBehaviorMetricsByEntity(groupBy, dateRange, filters) {
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    return calculateGroupedPatientBehaviorMetrics(appointments, groupBy);
+  }
+  /**
+   * Get patient analytics
+   *
+   * @param patientId - Optional patient ID (if not provided, returns aggregate)
+   * @param dateRange - Optional date range filter
+   * @returns Patient analytics
+   */
+  async getPatientAnalytics(patientId, dateRange) {
+    const appointments = await this.fetchAppointments(patientId ? { patientId } : void 0, dateRange);
+    if (patientId) {
+      return this.calculatePatientAnalytics(appointments, patientId);
+    }
+    const patientMap = /* @__PURE__ */ new Map();
+    appointments.forEach((appointment) => {
+      const patId = appointment.patientId;
+      if (!patientMap.has(patId)) {
+        patientMap.set(patId, []);
+      }
+      patientMap.get(patId).push(appointment);
+    });
+    return Array.from(patientMap.entries()).map(
+      ([patId, patAppointments]) => this.calculatePatientAnalytics(patAppointments, patId)
+    );
+  }
+  /**
+   * Calculate analytics for a specific patient
+   */
+  calculatePatientAnalytics(appointments, patientId) {
+    var _a;
+    const completed = getCompletedAppointments(appointments);
+    const canceled = getCanceledAppointments(appointments);
+    const noShow = getNoShowAppointments(appointments);
+    const { totalRevenue, currency } = calculateTotalRevenue(completed);
+    const appointmentDates = appointments.map((a) => a.appointmentStartTime.toDate()).sort((a, b) => a.getTime() - b.getTime());
+    const firstAppointmentDate = appointmentDates.length > 0 ? appointmentDates[0] : null;
+    const lastAppointmentDate = appointmentDates.length > 0 ? appointmentDates[appointmentDates.length - 1] : null;
+    let averageDaysBetween = null;
+    if (appointmentDates.length > 1) {
+      const intervals = [];
+      for (let i = 1; i < appointmentDates.length; i++) {
+        const diffMs = appointmentDates[i].getTime() - appointmentDates[i - 1].getTime();
+        intervals.push(diffMs / (1e3 * 60 * 60 * 24));
+      }
+      averageDaysBetween = intervals.reduce((a, b) => a + b, 0) / intervals.length;
+    }
+    const uniquePractitioners = new Set(appointments.map((a) => a.practitionerId));
+    const uniqueClinics = new Set(appointments.map((a) => a.clinicBranchId));
+    const procedureMap = /* @__PURE__ */ new Map();
+    completed.forEach((appointment) => {
+      var _a2, _b;
+      const procId = appointment.procedureId;
+      const procName = ((_a2 = appointment.procedureInfo) == null ? void 0 : _a2.name) || "Unknown";
+      procedureMap.set(procId, {
+        name: procName,
+        count: (((_b = procedureMap.get(procId)) == null ? void 0 : _b.count) || 0) + 1
+      });
+    });
+    const favoriteProcedures = Array.from(procedureMap.entries()).map(([procedureId, data]) => ({
+      procedureId,
+      procedureName: data.name,
+      count: data.count
+    })).sort((a, b) => b.count - a.count).slice(0, 5);
+    const patientName = appointments.length > 0 ? ((_a = appointments[0].patientInfo) == null ? void 0 : _a.fullName) || "Unknown" : "Unknown";
+    return {
+      patientId,
+      patientName,
+      totalAppointments: appointments.length,
+      completedAppointments: completed.length,
+      canceledAppointments: canceled.length,
+      noShowAppointments: noShow.length,
+      cancellationRate: calculatePercentage(canceled.length, appointments.length),
+      noShowRate: calculatePercentage(noShow.length, appointments.length),
+      totalRevenue,
+      averageRevenuePerAppointment: completed.length > 0 ? totalRevenue / completed.length : 0,
+      currency,
+      lifetimeValue: totalRevenue,
+      firstAppointmentDate,
+      lastAppointmentDate,
+      averageDaysBetweenAppointments: averageDaysBetween ? Math.round(averageDaysBetween) : null,
+      uniquePractitioners: uniquePractitioners.size,
+      uniqueClinics: uniqueClinics.size,
+      favoriteProcedures
+    };
+  }
+  // ==========================================
+  // Dashboard Analytics
+  // ==========================================
+  /**
+   * Determines analytics period from date range
+   */
+  determinePeriodFromDateRange(dateRange) {
+    const diffMs = dateRange.end.getTime() - dateRange.start.getTime();
+    const diffDays = diffMs / (1e3 * 60 * 60 * 24);
+    if (diffDays <= 1) return "daily";
+    if (diffDays <= 7) return "weekly";
+    if (diffDays <= 31) return "monthly";
+    if (diffDays <= 365) return "yearly";
+    return "all_time";
+  }
+  /**
+   * Get comprehensive dashboard data
+   * First checks for stored analytics, then calculates if not available or stale
+   *
+   * @param filters - Optional filters
+   * @param dateRange - Optional date range filter
+   * @param options - Options for reading stored analytics
+   * @returns Complete dashboard analytics
+   */
+  async getDashboardData(filters, dateRange, options) {
+    if ((filters == null ? void 0 : filters.clinicBranchId) && dateRange && (options == null ? void 0 : options.useCache) !== false) {
+      const period = this.determinePeriodFromDateRange(dateRange);
+      const stored = await readStoredDashboardAnalytics(
+        this.db,
+        filters.clinicBranchId,
+        { ...options, period }
+      );
+      if (stored) {
+        const { metadata, ...analytics } = stored;
+        return analytics;
+      }
+    }
+    const appointments = await this.fetchAppointments(filters, dateRange);
+    const completed = getCompletedAppointments(appointments);
+    const canceled = getCanceledAppointments(appointments);
+    const noShow = getNoShowAppointments(appointments);
+    const pending = appointments.filter((a) => a.status === "pending" /* PENDING */);
+    const confirmed = appointments.filter((a) => a.status === "confirmed" /* CONFIRMED */);
+    const { totalRevenue, currency } = calculateTotalRevenue(completed);
+    const uniquePatients = new Set(appointments.map((a) => a.patientId));
+    const uniquePractitioners = new Set(appointments.map((a) => a.practitionerId));
+    const uniqueProcedures = new Set(appointments.map((a) => a.procedureId));
+    const practitionerMetrics = await Promise.all(
+      Array.from(uniquePractitioners).slice(0, 5).map((practitionerId) => this.getPractitionerAnalytics(practitionerId, dateRange))
+    );
+    const procedureMetricsResults = await Promise.all(
+      Array.from(uniqueProcedures).slice(0, 5).map((procedureId) => this.getProcedureAnalytics(procedureId, dateRange))
+    );
+    const procedureMetrics = procedureMetricsResults.filter(
+      (result) => !Array.isArray(result)
+    );
+    const cancellationMetrics = await this.getCancellationMetrics("clinic", dateRange);
+    const noShowMetrics = await this.getNoShowMetrics("clinic", dateRange);
+    const timeEfficiency = await this.getTimeEfficiencyMetrics(filters, dateRange);
+    const productMetrics = await this.getProductUsageMetrics(void 0, dateRange);
+    const topProducts = Array.isArray(productMetrics) ? productMetrics.sort((a, b) => b.totalRevenue - a.totalRevenue).slice(0, 5) : [];
+    const recentActivity = appointments.sort((a, b) => b.appointmentStartTime.toMillis() - a.appointmentStartTime.toMillis()).slice(0, 10).map((appointment) => {
+      var _a, _b, _c, _d, _e;
+      let type = "appointment";
+      let description = "";
+      if (appointment.status === "completed" /* COMPLETED */) {
+        type = "completion";
+        description = `Appointment completed: ${((_a = appointment.procedureInfo) == null ? void 0 : _a.name) || "Unknown procedure"}`;
+      } else if (appointment.status === "canceled_patient" /* CANCELED_PATIENT */ || appointment.status === "canceled_clinic" /* CANCELED_CLINIC */ || appointment.status === "canceled_patient_rescheduled" /* CANCELED_PATIENT_RESCHEDULED */) {
+        type = "cancellation";
+        description = `Appointment canceled: ${((_b = appointment.procedureInfo) == null ? void 0 : _b.name) || "Unknown procedure"}`;
+      } else if (appointment.status === "no_show" /* NO_SHOW */) {
+        type = "no_show";
+        description = `No-show: ${((_c = appointment.procedureInfo) == null ? void 0 : _c.name) || "Unknown procedure"}`;
+      } else {
+        description = `Appointment ${appointment.status}: ${((_d = appointment.procedureInfo) == null ? void 0 : _d.name) || "Unknown procedure"}`;
+      }
+      return {
+        type,
+        date: appointment.appointmentStartTime.toDate(),
+        description,
+        entityId: appointment.practitionerId,
+        entityName: ((_e = appointment.practitionerInfo) == null ? void 0 : _e.name) || "Unknown"
+      };
+    });
+    return {
+      overview: {
+        totalAppointments: appointments.length,
+        completedAppointments: completed.length,
+        canceledAppointments: canceled.length,
+        noShowAppointments: noShow.length,
+        pendingAppointments: pending.length,
+        confirmedAppointments: confirmed.length,
+        totalRevenue,
+        averageRevenuePerAppointment: completed.length > 0 ? totalRevenue / completed.length : 0,
+        currency,
+        uniquePatients: uniquePatients.size,
+        uniquePractitioners: uniquePractitioners.size,
+        uniqueProcedures: uniqueProcedures.size,
+        cancellationRate: calculatePercentage(canceled.length, appointments.length),
+        noShowRate: calculatePercentage(noShow.length, appointments.length)
+      },
+      practitionerMetrics: Array.isArray(practitionerMetrics) ? practitionerMetrics : [],
+      procedureMetrics: Array.isArray(procedureMetrics) ? procedureMetrics : [],
+      cancellationMetrics: Array.isArray(cancellationMetrics) ? cancellationMetrics[0] : cancellationMetrics,
+      noShowMetrics: Array.isArray(noShowMetrics) ? noShowMetrics[0] : noShowMetrics,
+      revenueTrends: [],
+      // TODO: Implement revenue trends
+      timeEfficiency,
+      topProducts,
+      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
+var AnalyticsAdminService = class {
+  /**
+   * Creates a new AnalyticsAdminService instance
+   *
+   * @param firestore - Admin Firestore instance (optional, defaults to admin.firestore())
+   */
+  constructor(firestore19) {
+    this.db = firestore19 || admin14.firestore();
+    const mockApp = {
+      name: "[DEFAULT]",
+      options: {},
+      automaticDataCollectionEnabled: false
+    };
+    const mockAuth = {};
+    const appointmentService = this.createAppointmentServiceAdapter();
+    this.analyticsService = new AnalyticsService(
+      this.db,
+      // Cast admin Firestore to client Firestore type
+      mockAuth,
+      mockApp,
+      appointmentService
+    );
+  }
+  /**
+   * Creates an adapter for AppointmentService to work with admin SDK
+   */
+  createAppointmentServiceAdapter() {
+    return {
+      searchAppointments: async (params) => {
+        let query3 = this.db.collection(APPOINTMENTS_COLLECTION);
+        if (params.clinicBranchId) {
+          query3 = query3.where("clinicBranchId", "==", params.clinicBranchId);
+        }
+        if (params.practitionerId) {
+          query3 = query3.where("practitionerId", "==", params.practitionerId);
+        }
+        if (params.procedureId) {
+          query3 = query3.where("procedureId", "==", params.procedureId);
+        }
+        if (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);
+          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);
+          query3 = query3.where("appointmentStartTime", "<=", endTimestamp);
+        }
+        const snapshot = await query3.get();
+        const appointments = snapshot.docs.map((doc3) => ({
+          id: doc3.id,
+          ...doc3.data()
+        }));
+        return {
+          appointments,
+          total: appointments.length
+        };
+      }
+    };
+  }
+  // Delegate all methods to the underlying AnalyticsService
+  // We expose them here so they can be called with admin SDK context
+  async getPractitionerAnalytics(practitionerId, dateRange, options) {
+    return this.analyticsService.getPractitionerAnalytics(practitionerId, dateRange, options);
+  }
+  async getProcedureAnalytics(procedureId, dateRange, options) {
+    return this.analyticsService.getProcedureAnalytics(procedureId, dateRange, options);
+  }
+  async getTimeEfficiencyMetrics(filters, dateRange, options) {
+    return this.analyticsService.getTimeEfficiencyMetrics(filters, dateRange, options);
+  }
+  async getTimeEfficiencyMetricsByEntity(groupBy, dateRange, filters) {
+    return this.analyticsService.getTimeEfficiencyMetricsByEntity(groupBy, dateRange, filters);
+  }
+  async getCancellationMetrics(groupBy, dateRange, options) {
+    return this.analyticsService.getCancellationMetrics(groupBy, dateRange, options);
+  }
+  async getNoShowMetrics(groupBy, dateRange, options) {
+    return this.analyticsService.getNoShowMetrics(groupBy, dateRange, options);
+  }
+  async getRevenueMetrics(filters, dateRange, options) {
+    return this.analyticsService.getRevenueMetrics(filters, dateRange, options);
+  }
+  async getRevenueMetricsByEntity(groupBy, dateRange, filters) {
+    return this.analyticsService.getRevenueMetricsByEntity(groupBy, dateRange, filters);
+  }
+  async getProductUsageMetrics(productId, dateRange) {
+    return this.analyticsService.getProductUsageMetrics(productId, dateRange);
+  }
+  async getProductUsageMetricsByEntity(groupBy, dateRange, filters) {
+    return this.analyticsService.getProductUsageMetricsByEntity(groupBy, dateRange, filters);
+  }
+  async getPatientAnalytics(patientId, dateRange) {
+    return this.analyticsService.getPatientAnalytics(patientId, dateRange);
+  }
+  async getPatientBehaviorMetricsByEntity(groupBy, dateRange, filters) {
+    return this.analyticsService.getPatientBehaviorMetricsByEntity(groupBy, dateRange, filters);
+  }
+  async getClinicAnalytics(clinicBranchId, dateRange) {
+    const dashboard = await this.analyticsService.getDashboardData(
+      { clinicBranchId },
+      dateRange
+    );
+    const clinicDoc = await this.db.collection("clinics").doc(clinicBranchId).get();
+    const clinicData = clinicDoc.data();
+    const clinicName = (clinicData == null ? void 0 : clinicData.name) || "Unknown";
+    return {
+      clinicBranchId,
+      clinicName,
+      totalAppointments: dashboard.overview.totalAppointments,
+      completedAppointments: dashboard.overview.completedAppointments,
+      canceledAppointments: dashboard.overview.canceledAppointments,
+      noShowAppointments: dashboard.overview.noShowAppointments,
+      cancellationRate: dashboard.overview.cancellationRate,
+      noShowRate: dashboard.overview.noShowRate,
+      totalRevenue: dashboard.overview.totalRevenue,
+      averageRevenuePerAppointment: dashboard.overview.averageRevenuePerAppointment,
+      currency: dashboard.overview.currency,
+      practitionerCount: dashboard.overview.uniquePractitioners,
+      patientCount: dashboard.overview.uniquePatients,
+      procedureCount: dashboard.overview.uniqueProcedures,
+      topPractitioners: dashboard.practitionerMetrics.slice(0, 5).map((p) => ({
+        practitionerId: p.practitionerId,
+        practitionerName: p.practitionerName,
+        appointmentCount: p.totalAppointments,
+        revenue: p.totalRevenue
+      })),
+      topProcedures: dashboard.procedureMetrics.slice(0, 5).map((p) => ({
+        procedureId: p.procedureId,
+        procedureName: p.procedureName,
+        appointmentCount: p.totalAppointments,
+        revenue: p.totalRevenue
+      }))
+    };
+  }
+  async getDashboardData(filters, dateRange, options) {
+    return this.analyticsService.getDashboardData(filters, dateRange, options);
+  }
+  /**
+   * Expose fetchAppointments for direct access if needed
+   * This method is used internally by AnalyticsService
+   */
+  async fetchAppointments(filters, dateRange) {
+    return this.analyticsService.fetchAppointments(filters, dateRange);
+  }
+};
+
+// src/admin/booking/booking.calculator.ts
+import { Timestamp as Timestamp4 } from "firebase/firestore";
+import { DateTime as DateTime2 } from "luxon";
+var BookingAvailabilityCalculator = class {
+  /**
+   * Calculate available booking slots based on the provided data
+   *
+   * @param request - The request containing all necessary data for calculation
+   * @returns Response with available booking slots
+   */
+  static calculateSlots(request) {
+    const {
+      clinic,
+      practitioner,
+      procedure,
+      timeframe,
+      clinicCalendarEvents,
+      practitionerCalendarEvents,
+      tz
+    } = request;
+    const schedulingIntervalMinutes = clinic.schedulingInterval || this.DEFAULT_INTERVAL_MINUTES;
+    const procedureDurationMinutes = procedure.duration;
+    console.log(
+      `Calculating slots with interval: ${schedulingIntervalMinutes}min and procedure duration: ${procedureDurationMinutes}min`
+    );
+    let availableIntervals = [
+      { start: timeframe.start, end: timeframe.end }
+    ];
+    availableIntervals = this.applyClinicWorkingHours(
+      availableIntervals,
+      clinic.workingHours,
+      timeframe,
+      tz
+    );
+    availableIntervals = this.subtractBlockingEvents(
+      availableIntervals,
+      clinicCalendarEvents
+    );
+    availableIntervals = this.applyPractitionerWorkingHours(
+      availableIntervals,
+      practitioner,
+      clinic.id,
+      timeframe,
+      tz
+    );
+    availableIntervals = this.subtractPractitionerBusyTimes(
+      availableIntervals,
+      practitionerCalendarEvents
+    );
+    console.log(
+      `After all filters, have ${availableIntervals.length} available intervals`
+    );
+    const availableSlots = this.generateAvailableSlots(
+      availableIntervals,
+      schedulingIntervalMinutes,
+      procedureDurationMinutes,
+      tz
+    );
+    return { availableSlots };
+  }
+  /**
+   * Apply clinic working hours to available intervals
+   *
+   * @param intervals - Current available intervals
+   * @param workingHours - Clinic working hours
+   * @param timeframe - Overall timeframe being considered
+   * @param tz - IANA timezone of the clinic
+   * @returns Intervals filtered by clinic working hours
+   */
+  static applyClinicWorkingHours(intervals, workingHours, timeframe, tz) {
+    if (!intervals.length) return [];
+    console.log(
+      `Applying clinic working hours to ${intervals.length} intervals`
+    );
+    const workingIntervals = this.createWorkingHoursIntervals(
+      workingHours,
+      timeframe.start.toDate(),
+      timeframe.end.toDate(),
+      tz
+    );
+    return this.intersectIntervals(intervals, workingIntervals);
+  }
+  /**
+   * Create time intervals for working hours across multiple days
+   *
+   * @param workingHours - Working hours definition
+   * @param startDate - Start date of the overall timeframe
+   * @param endDate - End date of the overall timeframe
+   * @param tz - IANA timezone of the clinic
+   * @returns Array of time intervals representing working hours
+   */
+  static createWorkingHoursIntervals(workingHours, startDate, endDate, tz) {
+    const workingIntervals = [];
+    let start = DateTime2.fromMillis(startDate.getTime(), { zone: tz });
+    const end = DateTime2.fromMillis(endDate.getTime(), { zone: tz });
+    while (start <= end) {
+      const dayOfWeek = start.weekday;
+      const dayName = [
+        "monday",
+        "tuesday",
+        "wednesday",
+        "thursday",
+        "friday",
+        "saturday",
+        "sunday"
+      ][dayOfWeek - 1];
+      if (dayName && workingHours[dayName]) {
+        const daySchedule = workingHours[dayName];
+        if (daySchedule) {
+          const [openHours, openMinutes] = daySchedule.open.split(":").map(Number);
+          const [closeHours, closeMinutes] = daySchedule.close.split(":").map(Number);
+          let workStart = start.set({
+            hour: openHours,
+            minute: openMinutes,
+            second: 0,
+            millisecond: 0
+          });
+          let workEnd = start.set({
+            hour: closeHours,
+            minute: closeMinutes,
+            second: 0,
+            millisecond: 0
+          });
+          if (workEnd.toMillis() > startDate.getTime() && workStart.toMillis() < endDate.getTime()) {
+            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: Timestamp4.fromMillis(intervalStart.toMillis()),
+              end: Timestamp4.fromMillis(intervalEnd.toMillis())
+            });
+            if (daySchedule.breaks && daySchedule.breaks.length > 0) {
+              for (const breakTime of daySchedule.breaks) {
+                const [breakStartHours, breakStartMinutes] = breakTime.start.split(":").map(Number);
+                const [breakEndHours, breakEndMinutes] = breakTime.end.split(":").map(Number);
+                const breakStart = start.set({
+                  hour: breakStartHours,
+                  minute: breakStartMinutes
+                });
+                const breakEnd = start.set({
+                  hour: breakEndHours,
+                  minute: breakEndMinutes
+                });
+                workingIntervals.splice(
+                  -1,
+                  1,
+                  ...this.subtractInterval(
+                    workingIntervals[workingIntervals.length - 1],
+                    {
+                      start: Timestamp4.fromMillis(breakStart.toMillis()),
+                      end: Timestamp4.fromMillis(breakEnd.toMillis())
+                    }
+                  )
+                );
+              }
+            }
+          }
+        }
+      }
+      start = start.plus({ days: 1 });
+    }
+    return workingIntervals;
+  }
+  /**
+   * Subtract blocking events from available intervals
+   *
+   * @param intervals - Current available intervals
+   * @param events - Calendar events to subtract
+   * @returns Available intervals after removing blocking events
+   */
+  static subtractBlockingEvents(intervals, events) {
+    if (!intervals.length) return [];
+    console.log(`Subtracting ${events.length} blocking events`);
+    const blockingEvents = events.filter(
+      (event) => event.eventType === "blocking" /* BLOCKING */ || event.eventType === "break" /* BREAK */ || event.eventType === "free_day" /* FREE_DAY */
+    );
+    let result = [...intervals];
+    for (const event of blockingEvents) {
+      const { start, end } = event.eventTime;
+      const blockingInterval = { start, end };
+      const newResult = [];
+      for (const interval of result) {
+        const remainingIntervals = this.subtractInterval(
+          interval,
+          blockingInterval
+        );
+        newResult.push(...remainingIntervals);
+      }
+      result = newResult;
+    }
+    return result;
+  }
+  /**
+   * Apply practitioner's specific working hours for the given clinic
+   *
+   * @param intervals - Current available intervals
+   * @param practitioner - Practitioner object
+   * @param clinicId - ID of the clinic
+   * @param timeframe - Overall timeframe being considered
+   * @param tz - IANA timezone of the clinic
+   * @returns Intervals filtered by practitioner's working hours
+   */
+  static applyPractitionerWorkingHours(intervals, practitioner, clinicId, timeframe, tz) {
+    if (!intervals.length) return [];
+    console.log(`Applying practitioner working hours for clinic ${clinicId}`);
+    const clinicWorkingHours = practitioner.clinicWorkingHours.find(
+      (hours) => hours.clinicId === clinicId && hours.isActive
+    );
+    if (!clinicWorkingHours) {
+      console.log(
+        `No working hours found for practitioner at clinic ${clinicId}`
+      );
+      return [];
+    }
+    const workingIntervals = this.createPractitionerWorkingHoursIntervals(
+      clinicWorkingHours.workingHours,
+      timeframe.start.toDate(),
+      timeframe.end.toDate(),
+      tz
+    );
+    return this.intersectIntervals(intervals, workingIntervals);
   }
   /**
    * Create time intervals for practitioner's working hours across multiple days
@@ -7126,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: Timestamp.fromMillis(intervalStart.toMillis()),
-              end: Timestamp.fromMillis(intervalEnd.toMillis())
+              start: Timestamp4.fromMillis(intervalStart.toMillis()),
+              end: Timestamp4.fromMillis(intervalEnd.toMillis())
             });
           }
         }
@@ -7207,7 +10433,7 @@ var BookingAvailabilityCalculator = class {
         const isInFuture = slotStart >= earliestBookableTime;
         if (isInFuture && this.isSlotFullyAvailable(slotStart, slotEnd, intervals, tz)) {
           slots.push({
-            start: Timestamp.fromMillis(slotStart.toMillis())
+            start: Timestamp4.fromMillis(slotStart.toMillis())
           });
         }
         slotStart = slotStart.plus({ minutes: intervalMinutes });
@@ -7326,13 +10552,13 @@ var BookingAvailabilityCalculator = class {
 BookingAvailabilityCalculator.DEFAULT_INTERVAL_MINUTES = 15;
 
 // src/admin/booking/booking.admin.ts
-import * as admin15 from "firebase-admin";
+import * as admin16 from "firebase-admin";
 
 // src/admin/documentation-templates/document-manager.admin.ts
-import * as admin14 from "firebase-admin";
+import * as admin15 from "firebase-admin";
 var DocumentManagerAdminService = class {
-  constructor(firestore18) {
-    this.db = firestore18;
+  constructor(firestore19) {
+    this.db = firestore19;
   }
   /**
    * Adds operations to a Firestore batch to initialize all linked forms for a new appointment
@@ -7435,10 +10661,10 @@ var DocumentManagerAdminService = class {
       };
     }
     const templateIds = technologyTemplates.map((t) => t.templateId);
-    const templatesSnapshot = await this.db.collection(DOCUMENTATION_TEMPLATES_COLLECTION).where(admin14.firestore.FieldPath.documentId(), "in", templateIds).get();
+    const templatesSnapshot = await this.db.collection(DOCUMENTATION_TEMPLATES_COLLECTION).where(admin15.firestore.FieldPath.documentId(), "in", templateIds).get();
     const templatesMap = /* @__PURE__ */ new Map();
-    templatesSnapshot.forEach((doc) => {
-      templatesMap.set(doc.id, doc.data());
+    templatesSnapshot.forEach((doc3) => {
+      templatesMap.set(doc3.id, doc3.data());
     });
     for (const templateRef of technologyTemplates) {
       const template = templatesMap.get(templateRef.templateId);
@@ -7501,8 +10727,8 @@ var BookingAdmin = class {
    * Creates a new BookingAdmin instance
    * @param firestore - Firestore instance provided by the caller
    */
-  constructor(firestore18) {
-    this.db = firestore18 || admin15.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin16.firestore();
     this.documentManagerAdmin = new DocumentManagerAdminService(this.db);
   }
   /**
@@ -7524,8 +10750,8 @@ var BookingAdmin = class {
         timeframeStart: timeframe.start instanceof Date ? timeframe.start.toISOString() : timeframe.start.toDate().toISOString(),
         timeframeEnd: timeframe.end instanceof Date ? timeframe.end.toISOString() : timeframe.end.toDate().toISOString()
       });
-      const start = timeframe.start instanceof Date ? admin15.firestore.Timestamp.fromDate(timeframe.start) : timeframe.start;
-      const end = timeframe.end instanceof Date ? admin15.firestore.Timestamp.fromDate(timeframe.end) : timeframe.end;
+      const start = timeframe.start instanceof Date ? admin16.firestore.Timestamp.fromDate(timeframe.start) : timeframe.start;
+      const end = timeframe.end instanceof Date ? admin16.firestore.Timestamp.fromDate(timeframe.end) : timeframe.end;
       Logger.debug("[BookingAdmin] Fetching clinic data", { clinicId });
       const clinicDoc = await this.db.collection("clinics").doc(clinicId).get();
       if (!clinicDoc.exists) {
@@ -7611,7 +10837,7 @@ var BookingAdmin = class {
       const result = BookingAvailabilityCalculator.calculateSlots(request);
       const availableSlotsResult = {
         availableSlots: result.availableSlots.map((slot) => ({
-          start: admin15.firestore.Timestamp.fromMillis(slot.start.toMillis())
+          start: admin16.firestore.Timestamp.fromMillis(slot.start.toMillis())
         }))
       };
       Logger.info(
@@ -7674,14 +10900,14 @@ var BookingAdmin = class {
         endTime: end.toDate().toISOString()
       });
       const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
-      const queryStart = admin15.firestore.Timestamp.fromMillis(
+      const queryStart = admin16.firestore.Timestamp.fromMillis(
         start.toMillis() - MAX_EVENT_DURATION_MS
       );
       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((doc) => ({
-        ...doc.data(),
-        id: doc.id
+      const events = snapshot.docs.map((doc3) => ({
+        ...doc3.data(),
+        id: doc3.id
       })).filter((event) => {
         return event.eventTime.end.toMillis() > start.toMillis();
       });
@@ -7720,14 +10946,14 @@ var BookingAdmin = class {
         endTime: end.toDate().toISOString()
       });
       const MAX_EVENT_DURATION_MS = 24 * 60 * 60 * 1e3;
-      const queryStart = admin15.firestore.Timestamp.fromMillis(
+      const queryStart = admin16.firestore.Timestamp.fromMillis(
         start.toMillis() - MAX_EVENT_DURATION_MS
       );
       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((doc) => ({
-        ...doc.data(),
-        id: doc.id
+      const events = snapshot.docs.map((doc3) => ({
+        ...doc3.data(),
+        id: doc3.id
       })).filter((event) => {
         return event.eventTime.end.toMillis() > start.toMillis();
       });
@@ -7789,8 +11015,8 @@ var BookingAdmin = class {
       `[BookingAdmin] Orchestrating appointment creation for patient ${data.patientId} by user ${authenticatedUserId}`
     );
     const batch = this.db.batch();
-    const adminTsNow = admin15.firestore.Timestamp.now();
-    const serverTimestampValue = admin15.firestore.FieldValue.serverTimestamp();
+    const adminTsNow = admin16.firestore.Timestamp.now();
+    const serverTimestampValue = admin16.firestore.FieldValue.serverTimestamp();
     try {
       if (!data.patientId || !data.procedureId || !data.appointmentStartTime || !data.appointmentEndTime) {
         return {
@@ -7887,7 +11113,7 @@ var BookingAdmin = class {
         fullName: `${(patientSensitiveData == null ? void 0 : patientSensitiveData.firstName) || ""} ${(patientSensitiveData == null ? void 0 : patientSensitiveData.lastName) || ""}`.trim() || patientProfileData.displayName,
         email: (patientSensitiveData == null ? void 0 : patientSensitiveData.email) || "",
         phone: (patientSensitiveData == null ? void 0 : patientSensitiveData.phoneNumber) || patientProfileData.phoneNumber || null,
-        dateOfBirth: (patientSensitiveData == null ? void 0 : patientSensitiveData.dateOfBirth) || patientProfileData.dateOfBirth || admin15.firestore.Timestamp.now(),
+        dateOfBirth: (patientSensitiveData == null ? void 0 : patientSensitiveData.dateOfBirth) || patientProfileData.dateOfBirth || admin16.firestore.Timestamp.now(),
         gender: (patientSensitiveData == null ? void 0 : patientSensitiveData.gender) || "other" /* OTHER */
       };
       const newAppointmentId = this.db.collection(APPOINTMENTS_COLLECTION).doc().id;
@@ -8152,7 +11378,7 @@ var BookingAdmin = class {
 };
 
 // src/admin/free-consultation/free-consultation-utils.admin.ts
-import * as admin16 from "firebase-admin";
+import * as admin17 from "firebase-admin";
 
 // src/backoffice/types/category.types.ts
 var CATEGORIES_COLLECTION = "backoffice_categories";
@@ -8165,10 +11391,10 @@ var TECHNOLOGIES_COLLECTION = "technologies";
 
 // src/admin/free-consultation/free-consultation-utils.admin.ts
 async function freeConsultationInfrastructure(db) {
-  const firestore18 = db || admin16.firestore();
+  const firestore19 = db || admin17.firestore();
   try {
     console.log("[freeConsultationInfrastructure] Checking free consultation infrastructure...");
-    const technologyRef = firestore18.collection(TECHNOLOGIES_COLLECTION).doc("free-consultation-tech");
+    const technologyRef = firestore19.collection(TECHNOLOGIES_COLLECTION).doc("free-consultation-tech");
     const technologyDoc = await technologyRef.get();
     if (technologyDoc.exists) {
       console.log(
@@ -8177,7 +11403,7 @@ async function freeConsultationInfrastructure(db) {
       return true;
     }
     console.log("[freeConsultationInfrastructure] Creating free consultation infrastructure...");
-    await createFreeConsultationInfrastructure(firestore18);
+    await createFreeConsultationInfrastructure(firestore19);
     console.log(
       "[freeConsultationInfrastructure] Successfully created free consultation infrastructure"
     );
@@ -8374,8 +11600,8 @@ var PractitionerInviteMailingService = class extends BaseMailingService {
    * @param firestore Firestore instance provided by the caller
    * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
    */
-  constructor(firestore18, mailgunClient) {
-    super(firestore18, mailgunClient);
+  constructor(firestore19, mailgunClient) {
+    super(firestore19, mailgunClient);
     this.DEFAULT_REGISTRATION_URL = "https://metaesthetics.net/register";
     this.DEFAULT_SUBJECT = "You've Been Invited to Join as a Practitioner";
     this.DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
@@ -9238,8 +12464,8 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
    * @param firestore Firestore instance provided by the caller
    * @param mailgunClient Mailgun client instance (mailgun.js v10+) provided by the caller
    */
-  constructor(firestore18, mailgunClient) {
-    super(firestore18, mailgunClient);
+  constructor(firestore19, mailgunClient) {
+    super(firestore19, mailgunClient);
     this.DEFAULT_MAILGUN_DOMAIN = "mg.metaesthetics.net";
     this.DEFAULT_FROM_ADDRESS = "MetaEstetics <no-reply@mg.metaesthetics.net>";
   }
@@ -9582,8 +12808,8 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
    */
   async fetchPractitionerById(practitionerId) {
     try {
-      const doc = await this.db.collection(PRACTITIONERS_COLLECTION).doc(practitionerId).get();
-      return doc.exists ? doc.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:",
@@ -9599,8 +12825,8 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
    */
   async fetchClinicById(clinicId) {
     try {
-      const doc = await this.db.collection(CLINICS_COLLECTION).doc(clinicId).get();
-      return doc.exists ? doc.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:",
@@ -9612,14 +12838,14 @@ var ExistingPractitionerInviteMailingService = class extends BaseMailingService
 };
 
 // src/admin/users/user-profile.admin.ts
-import * as admin17 from "firebase-admin";
+import * as admin18 from "firebase-admin";
 var UserProfileAdminService = class {
   /**
    * Constructor for UserProfileAdminService
    * @param firestore Optional Firestore instance. If not provided, uses the default admin SDK instance.
    */
-  constructor(firestore18) {
-    this.db = firestore18 || admin17.firestore();
+  constructor(firestore19) {
+    this.db = firestore19 || admin18.firestore();
   }
   /**
    * Creates a blank user profile with minimal information
@@ -9636,9 +12862,9 @@ var UserProfileAdminService = class {
       roles: [],
       // Empty roles array as requested
       isAnonymous: authUserData.isAnonymous,
-      createdAt: admin17.firestore.FieldValue.serverTimestamp(),
-      updatedAt: admin17.firestore.FieldValue.serverTimestamp(),
-      lastLoginAt: admin17.firestore.FieldValue.serverTimestamp()
+      createdAt: admin18.firestore.FieldValue.serverTimestamp(),
+      updatedAt: admin18.firestore.FieldValue.serverTimestamp(),
+      lastLoginAt: admin18.firestore.FieldValue.serverTimestamp()
     };
     try {
       const userRef = this.db.collection(USERS_COLLECTION).doc(authUserData.uid);
@@ -9714,8 +12940,8 @@ var UserProfileAdminService = class {
           clinics: mergedProfileData.clinics || [],
           doctorIds: mergedProfileData.doctorIds || [],
           clinicIds: mergedProfileData.clinicIds || [],
-          createdAt: admin17.firestore.FieldValue.serverTimestamp(),
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          createdAt: admin18.firestore.FieldValue.serverTimestamp(),
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
         };
         await patientProfileRef.set(patientProfileData);
         patientProfile = {
@@ -9754,8 +12980,8 @@ var UserProfileAdminService = class {
         };
         const sensitiveInfoData = {
           ...mergedSensitiveData,
-          createdAt: admin17.firestore.FieldValue.serverTimestamp(),
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          createdAt: admin18.firestore.FieldValue.serverTimestamp(),
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
           // Leave dateOfBirth as is
         };
         await sensitiveInfoRef.set(sensitiveInfoData);
@@ -9781,7 +13007,7 @@ var UserProfileAdminService = class {
           contraindications: [],
           allergies: [],
           currentMedications: [],
-          lastUpdated: admin17.firestore.FieldValue.serverTimestamp(),
+          lastUpdated: admin18.firestore.FieldValue.serverTimestamp(),
           updatedBy: userId
         };
         await medicalInfoRef.set(medicalInfoData);
@@ -9798,14 +13024,14 @@ var UserProfileAdminService = class {
       const batch = this.db.batch();
       if (!userData.roles.includes("patient" /* PATIENT */)) {
         batch.update(userRef, {
-          roles: admin17.firestore.FieldValue.arrayUnion("patient" /* PATIENT */),
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          roles: admin18.firestore.FieldValue.arrayUnion("patient" /* PATIENT */),
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
         });
       }
       if (!userData.patientProfile) {
         batch.update(userRef, {
           patientProfile: patientProfileId,
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
         });
       }
       await batch.commit();
@@ -9846,8 +13072,8 @@ var UserProfileAdminService = class {
       const userData = userDoc.data();
       if (!userData.roles.includes("clinic_admin" /* CLINIC_ADMIN */)) {
         await userRef.update({
-          roles: admin17.firestore.FieldValue.arrayUnion("clinic_admin" /* CLINIC_ADMIN */),
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          roles: admin18.firestore.FieldValue.arrayUnion("clinic_admin" /* CLINIC_ADMIN */),
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
         });
       }
       const updatedUserDoc = await userRef.get();
@@ -9878,8 +13104,8 @@ var UserProfileAdminService = class {
       const userData = userDoc.data();
       if (!userData.roles.includes("practitioner" /* PRACTITIONER */)) {
         await userRef.update({
-          roles: admin17.firestore.FieldValue.arrayUnion("practitioner" /* PRACTITIONER */),
-          updatedAt: admin17.firestore.FieldValue.serverTimestamp()
+          roles: admin18.firestore.FieldValue.arrayUnion("practitioner" /* PRACTITIONER */),
+          updatedAt: admin18.firestore.FieldValue.serverTimestamp()
         });
       }
       const updatedUserDoc = await userRef.get();
@@ -9898,6 +13124,8 @@ var UserProfileAdminService = class {
 console.log("[Admin Module] Initialized and services exported.");
 TimestampUtils.enableServerMode();
 export {
+  ANALYTICS_COLLECTION,
+  AnalyticsAdminService,
   AppointmentAggregationService,
   AppointmentMailingService,
   AppointmentStatus,
@@ -9905,19 +13133,26 @@ export {
   BillingTransactionType,
   BookingAdmin,
   BookingAvailabilityCalculator,
+  CANCELLATION_ANALYTICS_SUBCOLLECTION,
+  CLINICS_COLLECTION,
+  CLINIC_ANALYTICS_SUBCOLLECTION,
   CalendarAdminService,
   ClinicAggregationService,
+  DASHBOARD_ANALYTICS_SUBCOLLECTION,
   DocumentManagerAdminService,
   ExistingPractitionerInviteMailingService,
   FilledFormsAggregationService,
   Logger,
   NOTIFICATIONS_COLLECTION,
+  NO_SHOW_ANALYTICS_SUBCOLLECTION,
   NotificationStatus,
   NotificationType,
   NotificationsAdmin,
   PATIENTS_COLLECTION,
   PATIENT_REQUIREMENTS_SUBCOLLECTION_NAME,
   PATIENT_SENSITIVE_INFO_COLLECTION,
+  PRACTITIONER_ANALYTICS_SUBCOLLECTION,
+  PROCEDURE_ANALYTICS_SUBCOLLECTION,
   PatientAggregationService,
   PatientInstructionStatus,
   PatientRequirementOverallStatus,
@@ -9928,8 +13163,10 @@ export {
   PractitionerInviteStatus,
   PractitionerTokenStatus,
   ProcedureAggregationService,
+  REVENUE_ANALYTICS_SUBCOLLECTION,
   ReviewsAggregationService,
   SubscriptionStatus,
+  TIME_EFFICIENCY_ANALYTICS_SUBCOLLECTION,
   UserProfileAdminService,
   UserRole,
   freeConsultationInfrastructure