matrice-analytics 0.1.70__py3-none-any.whl → 0.1.96__py3-none-any.whl

matrice_analytics/post_processing/usecases/advanced_customer_service.py

@@ -26,6 +26,11 @@ from ..utils import (
     BBoxSmoothingConfig,
     BBoxSmoothingTracker,
 )
+# Import business metrics manager for publishing aggregated metrics every 5 minutes
+from ..utils.business_metrics_manager_utils import (
+    BUSINESS_METRICS_MANAGER,
+    BusinessMetricsManagerFactory
+)
 
 def assign_person_by_area(detections, customer_areas, staff_areas):
     """
@@ -65,94 +70,269 @@ def assign_person_by_area(detections, customer_areas, staff_areas):
             det['category'] = 'staff'
 
 class AdvancedCustomerServiceUseCase(BaseProcessor):
-    def _format_timestamp_for_video(self, timestamp: float) -> str:
-        """Format timestamp for video chunks (HH:MM:SS.ms format)."""
-        hours = int(timestamp // 3600)
-        minutes = int((timestamp % 3600) // 60)
-        seconds = round(float(timestamp % 60), 2)
-        return f"{hours:02d}:{minutes:02d}:{seconds:04.1f}"
+    def __init__(self):
+        """Initialize advanced customer service use case."""
+        super().__init__("advanced_customer_service")
+        self.category = "sales"
+        self.CASE_TYPE: Optional[str] = 'advanced_customer_service'
+        self.CASE_VERSION: Optional[str] = '1.3'
 
-    def _format_timestamp_for_stream(self, timestamp: float) -> str:
-        dt = datetime.fromtimestamp(timestamp, tz=timezone.utc)
-        return dt.strftime('%Y:%m:%d %H:%M:%S')
+        # Advanced tracking structures
+        self.customer_occupancy = {}
+        self.staff_occupancy = {}
+        self.service_occupancy = {}
+        self.customer_queue_times = {}
+        self.customer_service_times = {}
+        self.customer_journey = {}
+        self.staff_availability = {}
+        self.staff_service_count = defaultdict(int)
+        self.staff_active_services = {}
 
-    def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str]=None) -> str:
-        """Get formatted current timestamp based on stream type."""
-        if not stream_info:
-            return "00:00:00.00"
-        input_settings = stream_info.get("input_settings", {})
-        if precision:
-            if input_settings.get("start_frame", "na") != "na":
-                if frame_id is not None:
-                    start_time = int(frame_id)/input_settings.get("original_fps", 30)
-                else:
-                    start_time = input_settings.get("start_frame", 30)/input_settings.get("original_fps", 30)
-                return self._format_timestamp_for_video(start_time)
-            else:
-                return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+        # Persistent unique staff tracking
+        self.global_staff_ids = set()
+        self.global_staff_ids_by_area = defaultdict(set)
 
-        if input_settings.get("start_frame", "na") != "na":
-            if frame_id is not None:
-                start_time = int(frame_id)/input_settings.get("original_fps", 30)
-            else:
-                start_time = input_settings.get("start_frame", 30)/input_settings.get("original_fps", 30)
-            return self._format_timestamp_for_video(start_time)
-        else:
-            # For streams, use stream_time from stream_info
-            stream_time_str = input_settings.get("stream_info", {}).get("stream_time", "")
-            if stream_time_str:
-                try:
-                    timestamp_str = stream_time_str.replace(" UTC", "")
-                    dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
-                    timestamp = dt.replace(tzinfo=timezone.utc).timestamp()
-                    return self._format_timestamp_for_stream(timestamp)
-                except:
-                    return self._format_timestamp_for_stream(time.time())
+        # Persistent unique customer tracking
+        self.global_customer_ids = set()
+
+        # Persistent staff ID memory (for cross-frame staff identity)
+        self.persistent_staff_ids = set()
+
+        # Analytics
+        self.queue_wait_times = defaultdict(list)
+        self.service_times = defaultdict(list)
+        self.staff_efficiency = defaultdict(list)
+        self.peak_occupancy = defaultdict(int)
+
+        # Journey states
+        self.JOURNEY_STATES = {
+            'ENTERING': 'entering',
+            'QUEUING': 'queuing',
+            'BEING_SERVED': 'being_served',
+            'COMPLETED': 'completed',
+            'LEFT': 'left'
+        }
+
+        # Tracker initialization (for YOLOv8 frame-wise predictions)
+        self.tracker = None
+        self.smoothing_tracker = None
+        self._total_frame_counter = 0
+        self._global_frame_offset = 0
+        
+        # Track merging and aliasing (like people_counting)
+        self._track_aliases: Dict[Any, Any] = {}
+        self._canonical_tracks: Dict[Any, Dict[str, Any]] = {}
+        self._track_merge_iou_threshold: float = 0.05
+        self._track_merge_time_window: float = 7.0
+        
+        # Per-category track ID tracking
+        self._per_category_total_track_ids: Dict[str, set] = {}
+        self._current_frame_track_ids: Dict[str, set] = {}
+        
+        # Alert tracking
+        self._ascending_alert_list: List[int] = []
+        self.current_incident_end_timestamp: str = "N/A"
+        self.start_timer = None
+        
+        # Business metrics manager for publishing aggregated metrics every 5 minutes
+        self._business_metrics_manager_factory: Optional[BusinessMetricsManagerFactory] = None
+        self._business_metrics_manager: Optional[BUSINESS_METRICS_MANAGER] = None
+        self._business_metrics_manager_initialized: bool = False
+    
+    def process(self, data: Any, config: ConfigProtocol,
+                context: Optional[ProcessingContext] = None, stream_info: Optional[dict] = None) -> ProcessingResult:
+        """
+        Process advanced customer service analytics.
+        """
+        start_time = time.time()
+        print("-------------------CUS-STREAM_INFO------------------------------")
+        self.logger.info("-------------------CUS-STREAM_INFO------------------------------") 
+        self.logger.info(stream_info)
+        self.logger.info("-------------------CUS-STREAM_INFO------------------------------")
+        print("-------------------CUS-STREAM_INFO------------------------------")
+        print(stream_info)
+        print("-------------------CUS-STREAM_INFO------------------------------")
+
+        try:
+            if not isinstance(config, CustomerServiceConfig):
+                return self.create_error_result(
+                    "Invalid configuration type for advanced customer service",
+                    usecase=self.name,
+                    category=self.category,
+                    context=context
+                )
+
+            if stream_info is not None:
+                if context is None:
+                    context = ProcessingContext()
+                context.stream_info = stream_info
+
+            if context is None:
+                context = ProcessingContext()
+
+            self._service_proximity_threshold = config.service_proximity_threshold
+
+            # Initialize business metrics manager once (for publishing aggregated metrics)
+            if not self._business_metrics_manager_initialized:
+                self._initialize_business_metrics_manager_once(config)
+
+            input_format = match_results_structure(data)
+            context.input_format = input_format
+            context.confidence_threshold = config.confidence_threshold
+            context.enable_tracking = config.enable_tracking
+
+            self.logger.info(f"Processing advanced customer service with format: {input_format.value}")
+
+            self._initialize_areas(config.customer_areas, config.staff_areas, config.service_areas)
+
+            processed_data = data
+            if config.confidence_threshold is not None:
+                processed_data = filter_by_confidence(processed_data, config.confidence_threshold)
+                self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
+
+            if hasattr(config, 'index_to_category') and config.index_to_category:
+                processed_data = apply_category_mapping(processed_data, config.index_to_category)
+                self.logger.debug("Applied category mapping")
+
+            # --- Smoothing logic ---
+            if getattr(config, "enable_smoothing", False):
+                if not hasattr(self, "smoothing_tracker") or self.smoothing_tracker is None:
+                    smoothing_config = BBoxSmoothingConfig(
+                        smoothing_algorithm=getattr(config, "smoothing_algorithm", "observability"),
+                        window_size=getattr(config, "smoothing_window_size", 20),
+                        cooldown_frames=getattr(config, "smoothing_cooldown_frames", 5),
+                        confidence_threshold=getattr(config, "confidence_threshold", 0.5),
+                        confidence_range_factor=getattr(config, "smoothing_confidence_range_factor", 0.5),
+                        enable_smoothing=True
+                    )
+                    self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
+                processed_data = bbox_smoothing(processed_data, self.smoothing_tracker.config, self.smoothing_tracker)
+
+            # Extract detections from processed data
+            detections = self._extract_detections(processed_data)
+
+            # --- Apply AdvancedTracker for YOLOv8 frame-wise predictions (like people_counting) ---
+            try:
+                from ..advanced_tracker import AdvancedTracker
+                from ..advanced_tracker.config import TrackerConfig
+                if self.tracker is None:
+                    tracker_config = TrackerConfig(
+                        track_high_thresh=float(config.confidence_threshold) if config.confidence_threshold else 0.4,
+                        track_low_thresh=max(0.05, (float(config.confidence_threshold) / 2) if config.confidence_threshold else 0.05),
+                        new_track_thresh=float(config.confidence_threshold) if config.confidence_threshold else 0.3,
+                        match_thresh=0.8
+                    )
+                    self.tracker = AdvancedTracker(tracker_config)
+                    self.logger.info(f"Initialized AdvancedTracker with thresholds: high={tracker_config.track_high_thresh}, "
+                                     f"low={tracker_config.track_low_thresh}, new={tracker_config.new_track_thresh}")
+                # Apply tracker to get track_ids
+                detections = self.tracker.update(detections)
+                self.logger.debug(f"Applied AdvancedTracker, {len(detections)} detections with track_ids")
+            except Exception as e:
+                self.logger.warning(f"AdvancedTracker failed: {e}, continuing without tracking")
+
+            # Update tracking state (track merging, canonical IDs)
+            self._update_tracking_state(detections)
+            self._total_frame_counter += 1
+
+            # Assign person detections to staff/customer based on area polygons
+            assign_person_by_area(
+                detections,
+                getattr(config, 'customer_areas', {}),
+                getattr(config, 'staff_areas', {})
+            )
+            
+            # Categorize detections into staff and customers
+            staff_detections, customer_detections = self._categorize_detections(
+                detections, config.staff_categories, config.customer_categories
+            )
+            self.logger.debug(f"Extracted {len(staff_detections)} staff and {len(customer_detections)} customer detections")
+
+            self._maybe_reset_chunk()
+            self._update_chunk_tracking(customer_detections)
+
+            # Extract frame number from stream_info (like people_counting)
+            frame_number = None
+            if stream_info:
+                input_settings = stream_info.get("input_settings", {})
+                start_frame = input_settings.get("start_frame")
+                end_frame = input_settings.get("end_frame")
+                if start_frame is not None and end_frame is not None and start_frame == end_frame:
+                    frame_number = start_frame
+
+            current_time = time.time()
+            analytics_results = self._process_comprehensive_analytics(
+                staff_detections, customer_detections, config, current_time
+            )
+            
+            # Send business metrics to manager for aggregation and publishing
+            # The manager aggregates for 5 minutes and publishes mean/min/max/sum
+            business_metrics = analytics_results.get("business_metrics", {})
+            if business_metrics:
+                self.logger.debug(f"[BUSINESS_METRICS_MANAGER] Sending metrics: {list(business_metrics.keys())}")
+                self.logger.debug(f"[BUSINESS_METRICS_MANAGER] stream_info available: {stream_info is not None}")
+                if stream_info:
+                    self.logger.debug(f"[BUSINESS_METRICS_MANAGER] stream_info.topic: {stream_info.get('topic', 'N/A')}")
+                    self.logger.debug(f"[BUSINESS_METRICS_MANAGER] stream_info.camera_info: {stream_info.get('camera_info', {})}")
+                self._send_metrics_to_manager(business_metrics, stream_info)
             else:
-                return self._format_timestamp_for_stream(time.time())
+                self.logger.debug("[BUSINESS_METRICS_MANAGER] No business_metrics in analytics_results")
 
-    def _get_start_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False) -> str:
-        """Get formatted start timestamp for 'TOTAL SINCE' based on stream type."""
-        if not stream_info:
-            return "00:00:00"
-        input_settings = stream_info.get("input_settings", {})
-        if precision:
-            if input_settings.get("start_frame", "na") != "na":
-                return "00:00:00"
+            # --- FIX: Ensure agg_summary is top-level and events/tracking_stats are dicts ---
+            # Reconstruct processed_data dict with frame_number as key for per-frame analytics
+            if frame_number is not None:
+                processed_data_for_summary = {str(frame_number): detections}
+            elif isinstance(processed_data, dict):
+                processed_data_for_summary = processed_data
             else:
-                return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                processed_data_for_summary = {"0": detections}
+            
+            agg_summary = self._generate_per_frame_agg_summary(processed_data_for_summary, analytics_results, config, context, stream_info)
 
-        if input_settings.get("start_frame", "na") != "na":
-            return "00:00:00"
-        else:
-            if not hasattr(self, '_tracking_start_time') or self._tracking_start_time is None:
-                stream_time_str = input_settings.get("stream_info", {}).get("stream_time", "")
-                if stream_time_str:
-                    try:
-                        timestamp_str = stream_time_str.replace(" UTC", "")
-                        dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
-                        self._tracking_start_time = dt.replace(tzinfo=timezone.utc).timestamp()
-                    except:
-                        self._tracking_start_time = time.time()
-                else:
-                    self._tracking_start_time = time.time()
-            dt = datetime.fromtimestamp(self._tracking_start_time, tz=timezone.utc)
-            dt = dt.replace(minute=0, second=0, microsecond=0)
-            return dt.strftime('%Y:%m:%d %H:%M:%S')
-    def get_camera_info_from_stream(self, stream_info):
-        """Extract camera_info from stream_info, matching people_counting pattern."""
-        if not stream_info:
-            return {}
-        # Try to get camera_info directly
-        camera_info = stream_info.get("camera_info")
-        if camera_info:
-            return camera_info
-        # Fallback: try to extract from nested input_settings
-        input_settings = stream_info.get("input_settings", {})
-        for key in ["camera_info", "camera_id", "location", "site_id"]:
-            if key in input_settings:
-                return {key: input_settings[key]}
-        return {}
+            insights = self._generate_insights(analytics_results, config)
+            alerts = self._check_alerts(analytics_results, config)
+            summary = self._generate_summary(analytics_results, alerts)
+            predictions = self._extract_predictions(processed_data)
+
+            context.mark_completed()
+
+            # Compose result data with harmonized agg_summary structure
+            result = self.create_result(
+                data={"agg_summary": agg_summary},
+                usecase=self.name,
+                category=self.category,
+                context=context
+            )
+
+            result.summary = summary
+            result.insights = insights
+            result.predictions = predictions
+            result.metrics = analytics_results.get("business_metrics", {})
+
+            if not config.customer_areas and not config.staff_areas:
+                result.add_warning("No customer or staff areas defined - using global analysis only")
+
+            if config.service_proximity_threshold > 250:
+                result.add_warning(f"High service proximity threshold ({config.service_proximity_threshold}) may miss interactions")
+
+            self.logger.info(f"Advanced customer service analysis completed successfully in {result.processing_time:.2f}s")
+            return result
+
+        except Exception as e:
+            self.logger.error(f"Advanced customer service analysis failed: {str(e)}", exc_info=True)
+
+            if context:
+                context.mark_completed()
+
+            return self.create_error_result(
+                str(e),
+                type(e).__name__,
+                usecase=self.name,
+                category=self.category,
+                context=context
+            )
+
+    
     def _generate_per_frame_agg_summary(self, processed_data, analytics_results, config, context, stream_info=None):
         """
         Generate agg_summary dict with per-frame incidents, tracking_stats, business_analytics, alerts, human_text.
@@ -256,10 +436,10 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
             human_text_lines.append(f"CURRENT FRAME @ {current_timestamp}:")
             human_text_lines.append(f"\t- Active Customers: {queue_analytics.get('active_customers', 0)}")
             human_text_lines.append(f"\t\t- Queuing: {queue_analytics.get('customers_queuing', 0)}")
-            human_text_lines.append(f"\t\t- Being Served: {queue_analytics.get('customers_being_served', 0)}")
+            #human_text_lines.append(f"\t\t- Being Served: {queue_analytics.get('customers_being_served', 0)}")
             human_text_lines.append(f"\t- Active Staff: {staff_analytics.get('active_staff', 0)}")
-            human_text_lines.append(f"\t- Customer/Staff Ratio: {business_metrics.get('customer_to_staff_ratio', 0):.2f}")
-            human_text_lines.append(f"\t- Queue Performance: {business_metrics.get('queue_performance', 0)*100:.1f}%")
+            # human_text_lines.append(f"\t- Customer/Staff Ratio: {business_metrics.get('customer_to_staff_ratio', 0):.2f}")
+            # human_text_lines.append(f"\t- Queue Performance: {business_metrics.get('queue_performance', 0)*100:.1f}%")
             human_text_lines.append(f"\t- Service Areas: {len(service_analytics.get('service_areas_status', {}))}")
             for area_name, area_info in service_analytics.get('service_areas_status', {}).items():
                 customers = area_info.get("customers", 0)
@@ -267,22 +447,22 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
                 status = area_info.get("status", "inactive")
                 human_text_lines.append(f"\t\t- {area_name}: {status} with {customers} customers and {staff} staff")
             human_text_lines.append("")
-            human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
-            human_text_lines.append(f"\t- Total Customers: {journey_analytics.get('total_journeys', 0)}")
-            completed_count = journey_analytics.get("journey_states", {}).get("completed", 0)
-            human_text_lines.append(f"\t\t- Completed: {completed_count}")
-            human_text_lines.append(f"\t- Total Staff: {staff_analytics.get('total_staff', 0)}")
-            human_text_lines.append(f"\t- Average Staff Count: {staff_analytics.get('avg_staff_count', 0.0):.2f}")
-            human_text_lines.append(f"\t- Average Wait Time: {queue_analytics.get('average_wait_time', 0):.1f}s")
-            avg_service_time = 0.0
-            if analytics_results.get("service_times"):
-                times = [t.get("service_time", 0.0) for t in analytics_results["service_times"]]
-                if times:
-                    avg_service_time = sum(times) / len(times)
-            human_text_lines.append(f"\t- Average Service Time: {avg_service_time:.1f}s")
-            human_text_lines.append(f"\t- Business Metrics:")
-            human_text_lines.append(f"\t\t- Service Efficiency: {business_metrics.get('service_efficiency', 0)*100:.1f}%")
-            human_text_lines.append(f"\t\t- Staff Productivity: {business_metrics.get('staff_productivity', 0):.2f} services/staff")
+            # human_text_lines.append(f"TOTAL SINCE @ {start_timestamp}:")
+            # human_text_lines.append(f"\t- Total Customers: {journey_analytics.get('total_journeys', 0)}")
+            # completed_count = journey_analytics.get("journey_states", {}).get("completed", 0)
+            # human_text_lines.append(f"\t\t- Completed: {completed_count}")
+            # human_text_lines.append(f"\t- Total Staff: {staff_analytics.get('total_staff', 0)}")
+            # human_text_lines.append(f"\t- Average Staff Count: {staff_analytics.get('avg_staff_count', 0.0):.2f}")
+            # human_text_lines.append(f"\t- Average Wait Time: {queue_analytics.get('average_wait_time', 0):.1f}s")
+            # avg_service_time = 0.0
+            # if analytics_results.get("service_times"):
+            #     times = [t.get("service_time", 0.0) for t in analytics_results["service_times"]]
+            #     if times:
+            #         avg_service_time = sum(times) / len(times)
+            # human_text_lines.append(f"\t- Average Service Time: {avg_service_time:.1f}s")
+            # human_text_lines.append(f"\t- Business Metrics:")
+            # human_text_lines.append(f"\t\t- Service Efficiency: {business_metrics.get('service_efficiency', 0)*100:.1f}%")
+            # human_text_lines.append(f"\t\t- Staff Productivity: {business_metrics.get('staff_productivity', 0):.2f} services/staff")
             human_text = "\n".join(human_text_lines)
 
             # Build event in incident format
@@ -318,16 +498,17 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
             # Calculate current_counts (frame-wise counts)
             current_counts = [
                 {"category": "staff", "count": staff_analytics.get("active_staff", 0)},
-                {"category": "customer", "count": queue_analytics.get("active_customers", 0)}
+                {"category": "Active Customers", "count": queue_analytics.get("active_customers", 0)}
             ]
             # Detections: include all detections for this frame
             detection_objs = []
             for d in detections:
                 bbox = d.get("bounding_box", d.get("bbox", {}))
-                detection_objs.append({
-                    "category": d.get("category", "person"),
-                    "bounding_box": bbox
-                })
+                if d.get("category") == "customer" or d.get("category") == "staff" or d.get("category") == "person":
+                    detection_objs.append({
+                        "category": d.get("category", "person"),
+                        "bounding_box": bbox
+                    })
 
             # Harmonize reset_settings format 
             reset_settings = [
@@ -350,7 +531,8 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
                 "alerts": alerts,
                 "alert_settings": alert_settings,
                 "reset_settings": reset_settings,
-                "human_text": human_text
+                "human_text": human_text,
+                "target_categories": ['Staff', 'Active Customers']
             }
             # Patch: Build real_time_occupancy with correct service_areas info (not just empty lists)
             real_time_occupancy = analytics_results.get("real_time_occupancy", {}).copy()
@@ -379,12 +561,20 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
                 "alert_settings": alert_settings
             }
 
-            agg_summary[str(frame_id)] = {
+            # agg_summary[str(frame_id)] = {
+            #     "incidents": event,
+            #     "tracking_stats": tracking_stat,
+            #     "business_analytics": business_analytics,
+            #     "alerts": alerts,
+            #     "human_text": human_text
+            # }
+            frame_id = None
+            agg_summary = {str(frame_id) : {
                 "incidents": event,
                 "tracking_stats": tracking_stat,
                 "business_analytics": business_analytics,
                 "alerts": alerts,
-                "human_text": human_text
+                "human_text": human_text}
             }
         return agg_summary
     # --- Chunk tracking for per-chunk analytics ---
@@ -409,380 +599,125 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
                         if point_in_polygon(customer_center, polygon):
                             self._chunk_area_customer_ids[area_name].add(track_id)
 
-    def _maybe_reset_chunk(self):
-        if not hasattr(self, '_chunk_frame_count'):
-            self._init_chunk_tracking()
-        self._chunk_frame_count += 1
-        if self._chunk_frame_count > 1:
-            self._init_chunk_tracking()
-    def __init__(self):
-        """Initialize advanced customer service use case."""
-        super().__init__("advanced_customer_service")
-        self.category = "sales"
-
-        # Advanced tracking structures
-        self.customer_occupancy = {}
-        self.staff_occupancy = {}
-        self.service_occupancy = {}
-        self.customer_queue_times = {}
-        self.customer_service_times = {}
-        self.customer_journey = {}
-        self.staff_availability = {}
-        self.staff_service_count = defaultdict(int)
-        self.staff_active_services = {}
-
-        # Persistent unique staff tracking
-        self.global_staff_ids = set()
-        self.global_staff_ids_by_area = defaultdict(set)
-
-        # Persistent unique customer tracking
-        self.global_customer_ids = set()
-
-        # Persistent staff ID memory (for cross-frame staff identity)
-        self.persistent_staff_ids = set()
-
-        # Analytics
-        self.queue_wait_times = defaultdict(list)
-        self.service_times = defaultdict(list)
-        self.staff_efficiency = defaultdict(list)
-        self.peak_occupancy = defaultdict(int)
-
-        # Journey states
-        self.JOURNEY_STATES = {
-            'ENTERING': 'entering',
-            'QUEUING': 'queuing',
-            'BEING_SERVED': 'being_served',
-            'COMPLETED': 'completed',
-            'LEFT': 'left'
-        }
-    
-    def get_config_schema(self) -> Dict[str, Any]:
-        """Get configuration schema for advanced customer service."""
-        return {
-            "type": "object",
-            "properties": {
-                "confidence_threshold": {
-                    "type": "number",
-                    "minimum": 0.0, 
-                    "maximum": 1.0,
-                    "default": 0.5,
-                    "description": "Minimum confidence threshold for detections"
-                },
-                "customer_areas": {
-                    "type": "object",
-                    "additionalProperties": {
-                        "type": "array",
-                        "items": {
-                            "type": "array",
-                            "items": {"type": "number"},
-                            "minItems": 2,
-                            "maxItems": 2
-                        },
-                        "minItems": 3
-                    },
-                    "description": "Customer area definitions as polygons"
-                },
-                "staff_areas": {
-                    "type": "object", 
-                    "additionalProperties": {
-                        "type": "array",
-                        "items": {
-                            "type": "array",
-                            "items": {"type": "number"},
-                            "minItems": 2,
-                            "maxItems": 2
-                        },
-                        "minItems": 3
-                    },
-                    "description": "Staff area definitions as polygons"
-                },
-                "service_areas": {
-                    "type": "object",
-                    "additionalProperties": {
-                        "type": "array",
-                        "items": {
-                            "type": "array", 
-                            "items": {"type": "number"},
-                            "minItems": 2,
-                            "maxItems": 2
-                        },
-                        "minItems": 3
-                    },
-                    "description": "Service area definitions as polygons"
-                },
-                "staff_categories": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "default": ["staff", "employee"],
-                    "description": "Category names that represent staff"
-                },
-                "customer_categories": {
-                    "type": "array",
-                    "items": {"type": "string"},
-                    "default": ["customer", "person"],
-                    "description": "Category names that represent customers"
-                },
-                "service_proximity_threshold": {
-                    "type": "number",
-                    "minimum": 0.0,
-                    "default": 100.0,
-                    "description": "Distance threshold for service interactions"
-                },
-                "max_service_time": {
-                    "type": "number",
-                    "minimum": 0.0,
-                    "default": 1800.0,
-                    "description": "Maximum expected service time in seconds"
-                },
-                "buffer_time": {
-                    "type": "number",
-                    "minimum": 0.0,
-                    "default": 2.0,
-                    "description": "Buffer time for service calculations"
-                },
-                "enable_tracking": {
-                    "type": "boolean",
-                    "default": True,
-                    "description": "Enable advanced tracking for analytics"
-                },
-                "enable_journey_analysis": {
-                    "type": "boolean",
-                    "default": True,
-                    "description": "Enable customer journey analysis"
-                },
-                "enable_queue_analytics": {
-                    "type": "boolean",
-                    "default": True,
-                    "description": "Enable queue management analytics"
-                },
-                "tracking_config": {
-                    "type": "object",
-                    "properties": {
-                        "tracking_method": {
-                            "type": "string",
-                            "enum": ["kalman", "sort", "deepsort", "bytetrack"],
-                            "default": "kalman"
-                        },
-                        "max_age": {"type": "integer", "minimum": 1, "default": 30},
-                        "min_hits": {"type": "integer", "minimum": 1, "default": 3},
-                        "iou_threshold": {"type": "number", "minimum": 0.0, "maximum": 1.0, "default": 0.3}
-                    }
-                },
-                "enable_smoothing": {
-                    "type": "boolean",
-                    "default": True,
-                    "description": "Enable bounding box smoothing for detections"
-                },
-                "smoothing_algorithm": {
-                    "type": "string",
-                    "enum": ["observability", "kalman"],
-                    "default": "observability"
-                },
-                "smoothing_window_size": {
-                    "type": "integer",
-                    "minimum": 1,
-                    "default": 20
-                },
-                "smoothing_cooldown_frames": {
-                    "type": "integer",
-                    "minimum": 0,
-                    "default": 5
-                },
-                "smoothing_confidence_threshold": {
-                    "type": "number",
-                    "minimum": 0.0,
-                    "maximum": 1.0,
-                    "default": 0.5
-                },
-                "smoothing_confidence_range_factor": {
-                    "type": "number",
-                    "minimum": 0.0,
-                    "default": 0.5
-                },
-                "reset_interval_type": {
-                    "type": "string",
-                    "default": "daily",
-                    "description": "Interval type for resetting analytics (e.g., daily, weekly)"
-                },
-                "reset_time_value": {
-                    "type": "integer",
-                    "default": 9,
-                    "description": "Time value for reset (e.g., hour of day)"
-                },
-                "reset_time_unit": {
-                    "type": "string",
-                    "default": "hour",
-                    "description": "Time unit for reset (e.g., hour, minute)"
-                },
-                "alert_config": {
-                    "type": "object",
-                    "description": "Custom alert configuration settings"
-                },
-                "queue_length_threshold": {
-                    "type": "integer",
-                    "default": 10,
-                    "description": "Threshold for queue length alerts"
-                },
-                "service_efficiency_threshold": {
-                    "type": "number",
-                    "default": 0.0,
-                    "description": "Threshold for service efficiency alerts"
-                },
-                "email_address": {
-                    "type": "string",
-                    "default": "john.doe@gmail.com",
-                    "description": "Email address for alert notifications"
-                },
-            },
-            "required": ["confidence_threshold"],
-            "additionalProperties": False
-        }
-    
-    def create_default_config(self, **overrides) -> CustomerServiceConfig:
-        """Create default configuration with optional overrides."""
-        defaults = {
-            "category": self.category,
-            "usecase": self.name,
-            "confidence_threshold": 0.5,
-            "enable_tracking": True,
-            "enable_analytics": True,
-            "enable_journey_analysis": True,
-            "enable_queue_analytics": True,
-            "staff_categories": ["staff", "employee"],
-            "customer_categories": ["customer", "person"],
-            "service_proximity_threshold": 100.0,
-            "max_service_time": 1800.0,
-            "buffer_time": 2.0,
-            "stream_info": {},  
-        }
-        defaults.update(overrides)
-        return CustomerServiceConfig(**defaults)
-    
-    def process(self, data: Any, config: ConfigProtocol,
-                context: Optional[ProcessingContext] = None, stream_info: Optional[dict] = None) -> ProcessingResult:
+        
+    def _initialize_business_metrics_manager_once(self, config: CustomerServiceConfig) -> None:
         """
-        Process advanced customer service analytics.
+        Initialize business metrics manager ONCE with Redis OR Kafka clients (Environment based).
+        Called from process() on first invocation.
+        Uses config.session (existing session from pipeline) or creates from environment.
         """
-        start_time = time.time()
-
+        if self._business_metrics_manager_initialized:
+            self.logger.debug("[BUSINESS_METRICS_MANAGER] Already initialized, skipping")
+            return
+        
         try:
-            if not isinstance(config, CustomerServiceConfig):
-                return self.create_error_result(
-                    "Invalid configuration type for advanced customer service",
-                    usecase=self.name,
-                    category=self.category,
-                    context=context
-                )
-
-            if stream_info is not None:
-                if context is None:
-                    context = ProcessingContext()
-                context.stream_info = stream_info
-
-            if context is None:
-                context = ProcessingContext()
-
-            self._service_proximity_threshold = config.service_proximity_threshold
-
-            input_format = match_results_structure(data)
-            context.input_format = input_format
-            context.confidence_threshold = config.confidence_threshold
-            context.enable_tracking = config.enable_tracking
-
-            self.logger.info(f"Processing advanced customer service with format: {input_format.value}")
-
-            self._initialize_areas(config.customer_areas, config.staff_areas, config.service_areas)
-
-            processed_data = data
-            if config.confidence_threshold is not None:
-                processed_data = filter_by_confidence(processed_data, config.confidence_threshold)
-                self.logger.debug(f"Applied confidence filtering with threshold {config.confidence_threshold}")
-
-            if hasattr(config, 'index_to_category') and config.index_to_category:
-                processed_data = apply_category_mapping(processed_data, config.index_to_category)
-                self.logger.debug("Applied category mapping")
-
-            # --- Smoothing logic ---
-            if getattr(config, "enable_smoothing", False):
-                if not hasattr(self, "smoothing_tracker") or self.smoothing_tracker is None:
-                    smoothing_config = BBoxSmoothingConfig(
-                        smoothing_algorithm=getattr(config, "smoothing_algorithm", "observability"),
-                        window_size=getattr(config, "smoothing_window_size", 20),
-                        cooldown_frames=getattr(config, "smoothing_cooldown_frames", 5),
-                        confidence_threshold=getattr(config, "confidence_threshold", 0.5),
-                        confidence_range_factor=getattr(config, "smoothing_confidence_range_factor", 0.5),
-                        enable_smoothing=True
-                    )
-                    self.smoothing_tracker = BBoxSmoothingTracker(smoothing_config)
-                processed_data = bbox_smoothing(processed_data, self.smoothing_tracker.config, self.smoothing_tracker)
-
-            detections = self._extract_detections(processed_data)
-            assign_person_by_area(
-                detections,
-                getattr(config, 'customer_areas', {}),
-                getattr(config, 'staff_areas', {})
-            )
-            staff_detections, customer_detections = self._categorize_detections(
-                detections, config.staff_categories, config.customer_categories
-            )
-            self.logger.debug(f"Extracted {len(staff_detections)} staff and {len(customer_detections)} customer detections")
-
-            self._maybe_reset_chunk()
-            self._update_chunk_tracking(customer_detections)
-
-            current_time = time.time()
-            analytics_results = self._process_comprehensive_analytics(
-                staff_detections, customer_detections, config, current_time
+            self.logger.info("[BUSINESS_METRICS_MANAGER] ===== Starting business metrics manager initialization =====")
+            self.logger.info("[BUSINESS_METRICS_MANAGER] Aggregation interval: 300 seconds (5 minutes)")
+            
+            # Create factory if not exists
+            if self._business_metrics_manager_factory is None:
+                self._business_metrics_manager_factory = BusinessMetricsManagerFactory(logger=self.logger)
+                self.logger.debug("[BUSINESS_METRICS_MANAGER] Created BusinessMetricsManagerFactory")
+            
+            # Initialize using factory (handles session creation, Redis/Kafka setup)
+            # Aggregation interval: 300 seconds (5 minutes)
+            self._business_metrics_manager = self._business_metrics_manager_factory.initialize(
+                config,
+                aggregation_interval=300  # 5 minutes
             )
-
-            # --- FIX: Ensure agg_summary is top-level and events/tracking_stats are dicts ---
-            if isinstance(processed_data, dict):
-                agg_summary = self._generate_per_frame_agg_summary(processed_data, analytics_results, config, context, stream_info)
+            
+            if self._business_metrics_manager:
+                self.logger.info("[BUSINESS_METRICS_MANAGER] ✓ Business metrics manager initialized successfully")
+                self.logger.info(f"[BUSINESS_METRICS_MANAGER] Output topic: {self._business_metrics_manager.output_topic}")
+                self.logger.info(f"[BUSINESS_METRICS_MANAGER] Aggregation interval: {self._business_metrics_manager.aggregation_interval}s")
+                self.logger.info(f"[BUSINESS_METRICS_MANAGER] Redis client: {'Available' if self._business_metrics_manager.redis_client else 'Not available'}")
+                self.logger.info(f"[BUSINESS_METRICS_MANAGER] Kafka client: {'Available' if self._business_metrics_manager.kafka_client else 'Not available'}")
+                
+                # Log factory info
+                if self._business_metrics_manager_factory:
+                    self.logger.info(f"[BUSINESS_METRICS_MANAGER] Factory app_deployment_id: {self._business_metrics_manager_factory._app_deployment_id}")
+                    self.logger.info(f"[BUSINESS_METRICS_MANAGER] Factory action_id: {self._business_metrics_manager_factory._action_id}")
             else:
-                agg_summary = {"events": {}, "tracking_stats": {}}
-
-            insights = self._generate_insights(analytics_results, config)
-            alerts = self._check_alerts(analytics_results, config)
-            summary = self._generate_summary(analytics_results, alerts)
-            predictions = self._extract_predictions(processed_data)
-
-            context.mark_completed()
-
-            # Compose result data with harmonized agg_summary structure
-            result = self.create_result(
-                data={"agg_summary": agg_summary},
-                usecase=self.name,
-                category=self.category,
-                context=context
+                self.logger.warning("[BUSINESS_METRICS_MANAGER] ❌ Business metrics manager not available, metrics won't be published")
+                self.logger.warning("[BUSINESS_METRICS_MANAGER] Check if Redis/Kafka connection is properly configured")
+        
+        except Exception as e:
+            self.logger.error(f"[BUSINESS_METRICS_MANAGER] Business metrics manager initialization failed: {e}", exc_info=True)
+        finally:
+            self._business_metrics_manager_initialized = True  # Mark as initialized (don't retry every frame)
+            self.logger.info("[BUSINESS_METRICS_MANAGER] ===== Initialization complete =====")
+
+    def _send_metrics_to_manager(
+        self, 
+        business_metrics: Dict[str, Any], 
+        stream_info: Optional[Dict[str, Any]] = None
+    ) -> None:
+        """
+        Send business metrics to the business metrics manager for aggregation and publishing.
+        
+        The business metrics manager will:
+        1. Aggregate metrics for 5 minutes (300 seconds)
+        2. Publish aggregated metrics (mean/min/max/sum) to output topic
+        3. Reset all values after publishing
+        
+        Args:
+            business_metrics: Business metrics dictionary from _calculate_analytics
+            stream_info: Stream metadata containing camera info
+        """
+        if not self._business_metrics_manager:
+            self.logger.debug("[BUSINESS_METRICS_MANAGER] No business metrics manager available, skipping")
+            return
+        
+        self.logger.debug(f"[BUSINESS_METRICS_MANAGER] _send_metrics_to_manager called with stream_info keys: {list(stream_info.keys()) if stream_info else 'None'}")
+        
+        # Extract camera_id from stream_info
+        # Stream info structure: {'topic': '692d7bde42582ffde3611908_input_topic', 'camera_info': {'camera_name': '...'}, ...}
+        camera_id = ""
+        camera_name = ""
+        
+        if stream_info and isinstance(stream_info, dict):
+            # Method 1: Extract from topic field (e.g., "692d7bde42582ffde3611908_input_topic")
+            topic = stream_info.get("topic", "")
+            if topic and "_input_topic" in topic:
+                camera_id = topic.replace("_input_topic", "").strip()
+                self.logger.debug(f"[BUSINESS_METRICS_MANAGER] Extracted camera_id from topic: {camera_id}")
+            
+            # Method 2: Try camera_info dict
+            camera_info = stream_info.get("camera_info", {})
+            if isinstance(camera_info, dict):
+                if not camera_id:
+                    camera_id = camera_info.get("camera_id", "") or camera_info.get("cameraId", "")
+                camera_name = camera_info.get("camera_name", "")
+            
+            # Method 3: Try direct fields
+            if not camera_id:
+                camera_id = stream_info.get("camera_id", "") or stream_info.get("cameraId", "")
+        
+        if not camera_id:
+            # Fallback to a default identifier
+            camera_id = "default_camera"
+            self.logger.warning(f"[BUSINESS_METRICS_MANAGER] No camera_id found in stream_info, using default: {camera_id}")
+        else:
+            self.logger.info(f"[BUSINESS_METRICS_MANAGER] Using camera_id={camera_id}, camera_name={camera_name}")
+        
+        try:
+            self.logger.debug(f"[BUSINESS_METRICS_MANAGER] Calling process_metrics with camera_id={camera_id}")
+            
+            # Process the metrics through the manager
+            published = self._business_metrics_manager.process_metrics(
+                camera_id=camera_id,
+                metrics_data=business_metrics,
+                stream_info=stream_info
             )
-
-            result.summary = summary
-            result.insights = insights
-            result.predictions = predictions
-            result.metrics = analytics_results.get("business_metrics", {})
-
-            if not config.customer_areas and not config.staff_areas:
-                result.add_warning("No customer or staff areas defined - using global analysis only")
-
-            if config.service_proximity_threshold > 250:
-                result.add_warning(f"High service proximity threshold ({config.service_proximity_threshold}) may miss interactions")
-
-            self.logger.info(f"Advanced customer service analysis completed successfully in {result.processing_time:.2f}s")
-            return result
-
+            
+            if published:
+                self.logger.info(f"[BUSINESS_METRICS_MANAGER] ✓ Metrics published for camera: {camera_id}")
+            else:
+                self.logger.debug(f"[BUSINESS_METRICS_MANAGER] Metrics queued for aggregation (not yet published)")
         except Exception as e:
-            self.logger.error(f"Advanced customer service analysis failed: {str(e)}", exc_info=True)
+            self.logger.error(f"[BUSINESS_METRICS_MANAGER] Error sending metrics to manager: {e}", exc_info=True)
 
-            if context:
-                context.mark_completed()
-
-            return self.create_error_result(
-                str(e),
-                type(e).__name__,
-                usecase=self.name,
-                category=self.category,
-                context=context
-            )
+    
     
     def _initialize_areas(self, customer_areas: Dict, staff_areas: Dict, service_areas: Dict):
         """Initialize area tracking structures."""
@@ -858,16 +793,6 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
         # Compile comprehensive results
         return self._compile_analytics_results(current_time)
     
-    def _reset_current_state(self):
-        """Reset current state for new processing cycle."""
-        # Clear current occupancy (will be repopulated)
-        for area_name in self.customer_occupancy:
-            self.customer_occupancy[area_name] = []
-        for area_name in self.staff_occupancy:
-            self.staff_occupancy[area_name] = []
-        for area_name in self.service_occupancy:
-            self.service_occupancy[area_name] = []
-    
     def _process_staff_detections(self, staff_detections: List[Dict], current_time: float):
         """Process staff detections and update tracking."""
         for staff in staff_detections:
@@ -1475,38 +1400,322 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
                 insights.append("⚠️ Long customer journey times detected")
         
         return insights
+    
+    def _format_timestamp(self, timestamp: Any) -> str:
+        """Format a timestamp to match the current timestamp format: YYYY:MM:DD HH:MM:SS.
 
+        The input can be either:
+        1. A numeric Unix timestamp (``float`` / ``int``) – it will be converted to datetime.
+        2. A string in the format ``YYYY-MM-DD-HH:MM:SS.ffffff UTC``.
 
-    def _get_start_timestamp_str(self, stream_info: Optional[dict]) -> str:
-        """Get formatted start timestamp for 'TOTAL SINCE' based on stream type."""
-        # For video, use start_video_timestamp if available, else 00:00:00
+        The returned value will be in the format: YYYY:MM:DD HH:MM:SS (no milliseconds, no UTC suffix).
+
+        Example
+        -------
+        >>> self._format_timestamp("2025-10-27-19:31:20.187574 UTC")
+        '2025:10:27 19:31:20'
+        """
+
+        # Convert numeric timestamps to datetime first
+        if isinstance(timestamp, (int, float)):
+            dt = datetime.fromtimestamp(timestamp, timezone.utc)
+            return dt.strftime('%Y:%m:%d %H:%M:%S')
+
+        # Ensure we are working with a string from here on
+        if not isinstance(timestamp, str):
+            return str(timestamp)
+
+        # Remove ' UTC' suffix if present
+        timestamp_clean = timestamp.replace(' UTC', '').strip()
+
+        # Remove milliseconds if present (everything after the last dot)
+        if '.' in timestamp_clean:
+            timestamp_clean = timestamp_clean.split('.')[0]
+
+        # Parse the timestamp string and convert to desired format
+        try:
+            # Handle format: YYYY-MM-DD-HH:MM:SS
+            if timestamp_clean.count('-') >= 2:
+                # Replace first two dashes with colons for date part, third with space
+                parts = timestamp_clean.split('-')
+                if len(parts) >= 4:
+                    # parts = ['2025', '10', '27', '19:31:20']
+                    formatted = f"{parts[0]}:{parts[1]}:{parts[2]} {'-'.join(parts[3:])}"
+                    return formatted
+        except Exception:
+            pass
+
+        # If parsing fails, return the cleaned string as-is
+        return timestamp_clean
+
+    def _get_current_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False, frame_id: Optional[str]=None) -> str:
+        """Get formatted current timestamp based on stream type."""
+        
         if not stream_info:
             return "00:00:00.00"
-        input_settings = stream_info.get("input_settings", {})
-        stream_type = input_settings.get("stream_type", "video_file")
-        if stream_type == "video_file":
-            start_video_timestamp = stream_info.get("start_video_timestamp", None)
-            if start_video_timestamp:
-                return start_video_timestamp[:8]
+        if precision:
+            if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
+                if frame_id:
+                    start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                else:
+                    start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
+                stream_time_str = self._format_timestamp_for_video(start_time)
+                
+                return self._format_timestamp(stream_info.get("input_settings", {}).get("stream_time", "NA"))
+            else:
+                return datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+
+        if stream_info.get("input_settings", {}).get("start_frame", "na") != "na":
+            if frame_id:
+                start_time = int(frame_id)/stream_info.get("input_settings", {}).get("original_fps", 30)
             else:
-                return "00:00:00.00"
+                start_time = stream_info.get("input_settings", {}).get("start_frame", 30)/stream_info.get("input_settings", {}).get("original_fps", 30)
+
+            stream_time_str = self._format_timestamp_for_video(start_time)
+           
+
+            return self._format_timestamp(stream_info.get("input_settings", {}).get("stream_time", "NA"))
+        else:
+            stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+            if stream_time_str:
+                try:
+                    timestamp_str = stream_time_str.replace(" UTC", "")
+                    dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
+                    timestamp = dt.replace(tzinfo=timezone.utc).timestamp()
+                    return self._format_timestamp_for_stream(timestamp)
+                except:
+                    return self._format_timestamp_for_stream(time.time())
+            else:
+                return self._format_timestamp_for_stream(time.time())
+
+    def _get_start_timestamp_str(self, stream_info: Optional[Dict[str, Any]], precision=False) -> str:
+        """Get formatted start timestamp for 'TOTAL SINCE' based on stream type."""
+        if not stream_info:
+            return "00:00:00"
+        
+        if precision:
+            if self.start_timer is None:
+                candidate = stream_info.get("input_settings", {}).get("stream_time")
+                if not candidate or candidate == "NA":
+                    candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                self.start_timer = candidate
+                return self._format_timestamp(self.start_timer)
+            elif stream_info.get("input_settings", {}).get("start_frame", "na") == 1:
+                candidate = stream_info.get("input_settings", {}).get("stream_time")
+                if not candidate or candidate == "NA":
+                    candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                self.start_timer = candidate
+                return self._format_timestamp(self.start_timer)
+            else:
+                return self._format_timestamp(self.start_timer)
+
+        if self.start_timer is None:
+            # Prefer direct input_settings.stream_time if available and not NA
+            candidate = stream_info.get("input_settings", {}).get("stream_time")
+            if not candidate or candidate == "NA":
+                # Fallback to nested stream_info.stream_time used by current timestamp path
+                stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+                if stream_time_str:
+                    try:
+                        timestamp_str = stream_time_str.replace(" UTC", "")
+                        dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
+                        self._tracking_start_time = dt.replace(tzinfo=timezone.utc).timestamp()
+                        candidate = datetime.fromtimestamp(self._tracking_start_time, timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                    except:
+                        candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                else:
+                    candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+            self.start_timer = candidate
+            return self._format_timestamp(self.start_timer)
+        elif stream_info.get("input_settings", {}).get("start_frame", "na") == 1:
+            candidate = stream_info.get("input_settings", {}).get("stream_time")
+            if not candidate or candidate == "NA":
+                stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
+                if stream_time_str:
+                    try:
+                        timestamp_str = stream_time_str.replace(" UTC", "")
+                        dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
+                        ts = dt.replace(tzinfo=timezone.utc).timestamp()
+                        candidate = datetime.fromtimestamp(ts, timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                    except:
+                        candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+                else:
+                    candidate = datetime.now(timezone.utc).strftime("%Y-%m-%d-%H:%M:%S.%f UTC")
+            self.start_timer = candidate
+            return self._format_timestamp(self.start_timer)
+        
         else:
-            # For streams, persist the first stream_time as tracking start time
-            if not hasattr(self, "_tracking_start_time") or self._tracking_start_time is None:
-                stream_time_str = stream_info.get("stream_time", "")
+            if self.start_timer is not None and self.start_timer != "NA":
+                return self._format_timestamp(self.start_timer)
+
+            if self._tracking_start_time is None:
+                stream_time_str = stream_info.get("input_settings", {}).get("stream_info", {}).get("stream_time", "")
                 if stream_time_str:
                     try:
-                        from datetime import datetime, timezone
                         timestamp_str = stream_time_str.replace(" UTC", "")
                         dt = datetime.strptime(timestamp_str, "%Y-%m-%d-%H:%M:%S.%f")
                         self._tracking_start_time = dt.replace(tzinfo=timezone.utc).timestamp()
-                    except Exception:
+                    except:
                         self._tracking_start_time = time.time()
                 else:
                     self._tracking_start_time = time.time()
-            from datetime import datetime, timezone
+
             dt = datetime.fromtimestamp(self._tracking_start_time, tz=timezone.utc)
+            dt = dt.replace(minute=0, second=0, microsecond=0)
             return dt.strftime('%Y:%m:%d %H:%M:%S')
+
+
+    def _format_timestamp_for_video(self, timestamp: float) -> str:
+        """Format timestamp for video chunks (HH:MM:SS.ms format)."""
+        hours = int(timestamp // 3600)
+        minutes = int((timestamp % 3600) // 60)
+        seconds = round(float(timestamp % 60), 2)
+        return f"{hours:02d}:{minutes:02d}:{seconds:04.1f}"
+
+    def _format_timestamp_for_stream(self, timestamp: float) -> str:
+        dt = datetime.fromtimestamp(timestamp, tz=timezone.utc)
+        return dt.strftime('%Y:%m:%d %H:%M:%S')
+
+    def get_camera_info_from_stream(self, stream_info):
+        """Extract camera_info from stream_info, matching people_counting pattern."""
+        if not stream_info:
+            return {}
+        # Try to get camera_info directly
+        camera_info = stream_info.get("camera_info")
+        if camera_info:
+            return camera_info
+        # Fallback: try to extract from nested input_settings
+        input_settings = stream_info.get("input_settings", {})
+        for key in ["camera_info", "camera_id", "location", "site_id"]:
+            if key in input_settings:
+                return {key: input_settings[key]}
+        return {}
+    def _maybe_reset_chunk(self):
+        if not hasattr(self, '_chunk_frame_count'):
+            self._init_chunk_tracking()
+        self._chunk_frame_count += 1
+        if self._chunk_frame_count > 1:
+            self._init_chunk_tracking()
+    def _reset_current_state(self):
+        """Reset current state for new processing cycle."""
+        # Clear current occupancy (will be repopulated)
+        for area_name in self.customer_occupancy:
+            self.customer_occupancy[area_name] = []
+        for area_name in self.staff_occupancy:
+            self.staff_occupancy[area_name] = []
+        for area_name in self.service_occupancy:
+            self.service_occupancy[area_name] = []
+
+    def _compute_iou(self, box1: Any, box2: Any) -> float:
+        """Compute IoU between two bounding boxes."""
+        def _bbox_to_list(bbox):
+            if bbox is None:
+                return []
+            if isinstance(bbox, list):
+                return bbox[:4] if len(bbox) >= 4 else []
+            if isinstance(bbox, dict):
+                if "xmin" in bbox:
+                    return [bbox["xmin"], bbox["ymin"], bbox["xmax"], bbox["ymax"]]
+                if "x1" in bbox:
+                    return [bbox["x1"], bbox["y1"], bbox["x2"], bbox["y2"]]
+                values = [v for v in bbox.values() if isinstance(v, (int, float))]
+                return values[:4] if len(values) >= 4 else []
+            return []
+
+        l1 = _bbox_to_list(box1)
+        l2 = _bbox_to_list(box2)
+        if len(l1) < 4 or len(l2) < 4:
+            return 0.0
+        x1_min, y1_min, x1_max, y1_max = l1
+        x2_min, y2_min, x2_max, y2_max = l2
+        x1_min, x1_max = min(x1_min, x1_max), max(x1_min, x1_max)
+        y1_min, y1_max = min(y1_min, y1_max), max(y1_min, y1_max)
+        x2_min, x2_max = min(x2_min, x2_max), max(x2_min, x2_max)
+        y2_min, y2_max = min(y2_min, y2_max), max(y2_min, y2_max)
+        inter_x_min = max(x1_min, x2_min)
+        inter_y_min = max(y1_min, y2_min)
+        inter_x_max = min(x1_max, x2_max)
+        inter_y_max = min(y1_max, y2_max)
+        inter_w = max(0.0, inter_x_max - inter_x_min)
+        inter_h = max(0.0, inter_y_max - inter_y_min)
+        inter_area = inter_w * inter_h
+        area1 = (x1_max - x1_min) * (y1_max - y1_min)
+        area2 = (x2_max - x2_min) * (y2_max - y2_min)
+        union_area = area1 + area2 - inter_area
+        return (inter_area / union_area) if union_area > 0 else 0.0
+
+    def _merge_or_register_track(self, raw_id: Any, bbox: Any) -> Any:
+        """Return a stable canonical ID for a raw tracker ID."""
+        if raw_id is None or bbox is None:
+            return raw_id
+        now = time.time()
+        if raw_id in self._track_aliases:
+            canonical_id = self._track_aliases[raw_id]
+            track_info = self._canonical_tracks.get(canonical_id)
+            if track_info is not None:
+                track_info["last_bbox"] = bbox
+                track_info["last_update"] = now
+                track_info["raw_ids"].add(raw_id)
+            return canonical_id
+        for canonical_id, info in self._canonical_tracks.items():
+            if now - info["last_update"] > self._track_merge_time_window:
+                continue
+            iou = self._compute_iou(bbox, info["last_bbox"])
+            if iou >= self._track_merge_iou_threshold:
+                self._track_aliases[raw_id] = canonical_id
+                info["last_bbox"] = bbox
+                info["last_update"] = now
+                info["raw_ids"].add(raw_id)
+                return canonical_id
+        canonical_id = raw_id
+        self._track_aliases[raw_id] = canonical_id
+        self._canonical_tracks[canonical_id] = {
+            "last_bbox": bbox,
+            "last_update": now,
+            "raw_ids": {raw_id},
+        }
+        return canonical_id
+
+    def _update_tracking_state(self, detections: List[Dict]):
+        """Track unique track_ids per category (staff/customer)."""
+        target_categories = ['staff', 'customer', 'person']
+        if not hasattr(self, "_per_category_total_track_ids") or self._per_category_total_track_ids is None:
+            self._per_category_total_track_ids = {cat: set() for cat in target_categories}
+        self._current_frame_track_ids = {cat: set() for cat in target_categories}
+
+        for det in detections:
+            cat = det.get("category")
+            raw_track_id = det.get("track_id")
+            if cat not in target_categories or raw_track_id is None:
+                continue
+            bbox = det.get("bounding_box", det.get("bbox"))
+            canonical_id = self._merge_or_register_track(raw_track_id, bbox)
+            det["track_id"] = canonical_id
+            self._per_category_total_track_ids.setdefault(cat, set()).add(canonical_id)
+            self._current_frame_track_ids[cat].add(canonical_id)
+
+    def get_total_counts(self) -> Dict[str, int]:
+        """Return total unique track counts per category."""
+        return {cat: len(ids) for cat, ids in getattr(self, '_per_category_total_track_ids', {}).items()}
+
+    def _get_track_ids_info(self, detections: List[Dict]) -> Dict[str, Any]:
+        """Get detailed information about track IDs."""
+        frame_track_ids = set()
+        for det in detections:
+            tid = det.get('track_id')
+            if tid is not None:
+                frame_track_ids.add(tid)
+        total_track_ids = set()
+        for s in getattr(self, '_per_category_total_track_ids', {}).values():
+            total_track_ids.update(s)
+        return {
+            "total_count": len(total_track_ids),
+            "current_frame_count": len(frame_track_ids),
+            "total_unique_track_ids": len(total_track_ids),
+            "current_frame_track_ids": list(frame_track_ids),
+            "last_update_time": time.time(),
+            "total_frames_processed": getattr(self, '_total_frame_counter', 0)
+        }
     
     def _generate_summary(self, analytics_results: Dict, alerts: List) -> str:
         """Generate human-readable summary."""
@@ -1546,6 +1755,8 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
             return "\n".join(lines)
 
         summary = []
+        summary.append("Application Name: "+self.CASE_TYPE)
+        summary.append("Application Version: "+self.CASE_VERSION)
         summary.append(tabbed_section("customer_queue_analytics", queue_analytics, omit_keys={"wait_times_completed", "wait_times_ongoing"}))
         summary.append(tabbed_section("staff_management_analytics", staff_analytics, omit_keys={"staff_efficiency"}))
         summary.append(tabbed_section("service_area_analytics", service_analytics))
@@ -1562,6 +1773,208 @@ class AdvancedCustomerServiceUseCase(BaseProcessor):
                 summary.append(f"ALERTS: {len(alerts)} alert(s)")
 
         return "\n".join(summary)
+
+    def get_config_schema(self) -> Dict[str, Any]:
+        """Get configuration schema for advanced customer service."""
+        return {
+            "type": "object",
+            "properties": {
+                "confidence_threshold": {
+                    "type": "number",
+                    "minimum": 0.0, 
+                    "maximum": 1.0,
+                    "default": 0.5,
+                    "description": "Minimum confidence threshold for detections"
+                },
+                "customer_areas": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "type": "array",
+                        "items": {
+                            "type": "array",
+                            "items": {"type": "number"},
+                            "minItems": 2,
+                            "maxItems": 2
+                        },
+                        "minItems": 3
+                    },
+                    "description": "Customer area definitions as polygons"
+                },
+                "staff_areas": {
+                    "type": "object", 
+                    "additionalProperties": {
+                        "type": "array",
+                        "items": {
+                            "type": "array",
+                            "items": {"type": "number"},
+                            "minItems": 2,
+                            "maxItems": 2
+                        },
+                        "minItems": 3
+                    },
+                    "description": "Staff area definitions as polygons"
+                },
+                "service_areas": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "type": "array",
+                        "items": {
+                            "type": "array", 
+                            "items": {"type": "number"},
+                            "minItems": 2,
+                            "maxItems": 2
+                        },
+                        "minItems": 3
+                    },
+                    "description": "Service area definitions as polygons"
+                },
+                "staff_categories": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "default": ["staff", "employee"],
+                    "description": "Category names that represent staff"
+                },
+                "customer_categories": {
+                    "type": "array",
+                    "items": {"type": "string"},
+                    "default": ["customer", "person"],
+                    "description": "Category names that represent customers"
+                },
+                "service_proximity_threshold": {
+                    "type": "number",
+                    "minimum": 0.0,
+                    "default": 100.0,
+                    "description": "Distance threshold for service interactions"
+                },
+                "max_service_time": {
+                    "type": "number",
+                    "minimum": 0.0,
+                    "default": 1800.0,
+                    "description": "Maximum expected service time in seconds"
+                },
+                "buffer_time": {
+                    "type": "number",
+                    "minimum": 0.0,
+                    "default": 2.0,
+                    "description": "Buffer time for service calculations"
+                },
+                "enable_tracking": {
+                    "type": "boolean",
+                    "default": True,
+                    "description": "Enable advanced tracking for analytics"
+                },
+                "enable_journey_analysis": {
+                    "type": "boolean",
+                    "default": True,
+                    "description": "Enable customer journey analysis"
+                },
+                "enable_queue_analytics": {
+                    "type": "boolean",
+                    "default": True,
+                    "description": "Enable queue management analytics"
+                },
+                "tracking_config": {
+                    "type": "object",
+                    "properties": {
+                        "tracking_method": {
+                            "type": "string",
+                            "enum": ["kalman", "sort", "deepsort", "bytetrack"],
+                            "default": "kalman"
+                        },
+                        "max_age": {"type": "integer", "minimum": 1, "default": 30},
+                        "min_hits": {"type": "integer", "minimum": 1, "default": 3},
+                        "iou_threshold": {"type": "number", "minimum": 0.0, "maximum": 1.0, "default": 0.3}
+                    }
+                },
+                "enable_smoothing": {
+                    "type": "boolean",
+                    "default": True,
+                    "description": "Enable bounding box smoothing for detections"
+                },
+                "smoothing_algorithm": {
+                    "type": "string",
+                    "enum": ["observability", "kalman"],
+                    "default": "observability"
+                },
+                "smoothing_window_size": {
+                    "type": "integer",
+                    "minimum": 1,
+                    "default": 20
+                },
+                "smoothing_cooldown_frames": {
+                    "type": "integer",
+                    "minimum": 0,
+                    "default": 5
+                },
+                "smoothing_confidence_threshold": {
+                    "type": "number",
+                    "minimum": 0.0,
+                    "maximum": 1.0,
+                    "default": 0.5
+                },
+                "smoothing_confidence_range_factor": {
+                    "type": "number",
+                    "minimum": 0.0,
+                    "default": 0.5
+                },
+                "reset_interval_type": {
+                    "type": "string",
+                    "default": "daily",
+                    "description": "Interval type for resetting analytics (e.g., daily, weekly)"
+                },
+                "reset_time_value": {
+                    "type": "integer",
+                    "default": 9,
+                    "description": "Time value for reset (e.g., hour of day)"
+                },
+                "reset_time_unit": {
+                    "type": "string",
+                    "default": "hour",
+                    "description": "Time unit for reset (e.g., hour, minute)"
+                },
+                "alert_config": {
+                    "type": "object",
+                    "description": "Custom alert configuration settings"
+                },
+                "queue_length_threshold": {
+                    "type": "integer",
+                    "default": 10,
+                    "description": "Threshold for queue length alerts"
+                },
+                "service_efficiency_threshold": {
+                    "type": "number",
+                    "default": 0.0,
+                    "description": "Threshold for service efficiency alerts"
+                },
+                "email_address": {
+                    "type": "string",
+                    "default": "john.doe@gmail.com",
+                    "description": "Email address for alert notifications"
+                },
+            },
+            "required": ["confidence_threshold"],
+            "additionalProperties": False
+        }
+    
+    def create_default_config(self, **overrides) -> CustomerServiceConfig:
+        """Create default configuration with optional overrides."""
+        defaults = {
+            "category": self.category,
+            "usecase": self.name,
+            "confidence_threshold": 0.5,
+            "enable_tracking": True,
+            "enable_analytics": True,
+            "enable_journey_analysis": True,
+            "enable_queue_analytics": True,
+            "staff_categories": ["staff", "employee"],
+            "customer_categories": ["customer", "person"],
+            "service_proximity_threshold": 100.0,
+            "max_service_time": 1800.0,
+            "buffer_time": 2.0,
+            "stream_info": {},  
+        }
+        defaults.update(overrides)
+        return CustomerServiceConfig(**defaults)
     
     def _extract_predictions(self, data: Any) -> Dict[str, List[Dict[str, Any]]]:
         """Extract predictions from processed data for API compatibility, grouped by frame number if available."""