Update app.py

app.py

@@ -11,8 +11,10 @@ import threading
 import time
 from datetime import datetime, date
 from io import BytesIO
-from typing import Tuple, Optional, List
+from typing import Tuple, Optional, List, Dict, Any
 import pickle
+import sqlite3
+from pathlib import Path
 
 # Third-Party Imports
 import cv2
@@ -28,8 +30,15 @@ from simple_salesforce import Salesforce
 
 # --- CONFIGURATION ---
 
-# Setup logging
-logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")
+# Setup logging with better formatting
+logging.basicConfig(
+    level=logging.INFO, 
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler("attendance_system.log"),
+        logging.StreamHandler()
+    ]
+)
 logger = logging.getLogger(__name__)
 
 # Load environment variables from .env file
@@ -47,6 +56,156 @@ SF_CREDENTIALS = {
     "domain": os.getenv("SF_DOMAIN", "login")
 }
 
+# System configuration
+FACE_RECOGNITION_THRESHOLD = float(os.getenv("FACE_THRESHOLD", "10.0"))
+CONFIDENCE_THRESHOLD = float(os.getenv("CONFIDENCE_THRESHOLD", "0.95"))
+RECOGNITION_COOLDOWN = int(os.getenv("RECOGNITION_COOLDOWN", "5"))
+
+# --- DATABASE SETUP ---
+
+class LocalDatabase:
+    """Local SQLite database for offline functionality and backup."""
+    
+    def __init__(self, db_path: str = "data/attendance.db"):
+        self.db_path = db_path
+        Path(db_path).parent.mkdir(parents=True, exist_ok=True)
+        self._init_database()
+    
+    def _init_database(self):
+        """Initialize database tables."""
+        with sqlite3.connect(self.db_path) as conn:
+            cursor = conn.cursor()
+            
+            # Workers table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS workers (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    worker_id TEXT UNIQUE NOT NULL,
+                    name TEXT NOT NULL,
+                    face_embedding TEXT NOT NULL,
+                    image_path TEXT,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    synced_to_sf BOOLEAN DEFAULT FALSE
+                )
+            ''')
+            
+            # Attendance table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS attendance (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    worker_id TEXT NOT NULL,
+                    worker_name TEXT NOT NULL,
+                    date TEXT NOT NULL,
+                    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    status TEXT DEFAULT 'Present',
+                    synced_to_sf BOOLEAN DEFAULT FALSE,
+                    UNIQUE(worker_id, date)
+                )
+            ''')
+            
+            # System logs table
+            cursor.execute('''
+                CREATE TABLE IF NOT EXISTS system_logs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+                    level TEXT NOT NULL,
+                    message TEXT NOT NULL,
+                    module TEXT
+                )
+            ''')
+            
+            conn.commit()
+    
+    def add_worker(self, worker_id: str, name: str, embedding: List[float], image_path: str = None) -> bool:
+        """Add a new worker to the database."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute('''
+                    INSERT INTO workers (worker_id, name, face_embedding, image_path)
+                    VALUES (?, ?, ?, ?)
+                ''', (worker_id, name, json.dumps(embedding), image_path))
+                conn.commit()
+                return True
+        except sqlite3.IntegrityError:
+            logger.warning(f"Worker {worker_id} already exists in database")
+            return False
+        except Exception as e:
+            logger.error(f"Error adding worker to database: {e}")
+            return False
+    
+    def get_all_workers(self) -> List[Dict[str, Any]]:
+        """Get all workers from the database."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute('SELECT worker_id, name, face_embedding, image_path FROM workers')
+                workers = []
+                for row in cursor.fetchall():
+                    workers.append({
+                        'worker_id': row[0],
+                        'name': row[1],
+                        'embedding': json.loads(row[2]),
+                        'image_path': row[3]
+                    })
+                return workers
+        except Exception as e:
+            logger.error(f"Error fetching workers from database: {e}")
+            return []
+    
+    def mark_attendance(self, worker_id: str, worker_name: str, date_str: str) -> bool:
+        """Mark attendance for a worker."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute('''
+                    INSERT OR IGNORE INTO attendance (worker_id, worker_name, date)
+                    VALUES (?, ?, ?)
+                ''', (worker_id, worker_name, date_str))
+                conn.commit()
+                return cursor.rowcount > 0
+        except Exception as e:
+            logger.error(f"Error marking attendance: {e}")
+            return False
+    
+    def has_attended_today(self, worker_id: str, date_str: str) -> bool:
+        """Check if worker has already attended today."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                cursor = conn.cursor()
+                cursor.execute('''
+                    SELECT COUNT(*) FROM attendance 
+                    WHERE worker_id = ? AND date = ?
+                ''', (worker_id, date_str))
+                return cursor.fetchone()[0] > 0
+        except Exception as e:
+            logger.error(f"Error checking attendance: {e}")
+            return False
+    
+    def get_attendance_report(self, start_date: str = None, end_date: str = None) -> pd.DataFrame:
+        """Get attendance report as pandas DataFrame."""
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                query = 'SELECT * FROM attendance'
+                params = []
+                
+                if start_date and end_date:
+                    query += ' WHERE date BETWEEN ? AND ?'
+                    params = [start_date, end_date]
+                elif start_date:
+                    query += ' WHERE date >= ?'
+                    params = [start_date]
+                elif end_date:
+                    query += ' WHERE date <= ?'
+                    params = [end_date]
+                
+                query += ' ORDER BY timestamp DESC'
+                
+                return pd.read_sql_query(query, conn, params=params)
+        except Exception as e:
+            logger.error(f"Error generating attendance report: {e}")
+            return pd.DataFrame()
+
 # --- SALESFORCE CONNECTION ---
 
 @retry(stop_max_attempt_number=3, wait_fixed=2000)
@@ -59,13 +218,13 @@ def connect_to_salesforce() -> Optional[Salesforce]:
         return sf
     except Exception as e:
         logger.error(f"❌ Salesforce connection failed: {e}")
-        raise
+        return None  # Don't raise, allow offline mode
 
 # --- CORE LOGIC ---
 
 class AttendanceSystem:
     """
-    Manages all backend logic for the face recognition attendance system.
+    Enhanced attendance system with improved error handling, offline support, and new features.
     """
     def __init__(self):
         # State Management
@@ -73,8 +232,14 @@ class AttendanceSystem:
         self.is_processing = threading.Event()
         self.frame_queue = queue.Queue(maxsize=10)
         self.error_message = None 
-        self.last_processed_frame = None # Holds the final frame after processing
-        self.final_log = None # Holds the final log after processing
+        self.last_processed_frame = None
+        self.final_log = None
+        self.processing_stats = {
+            'frames_processed': 0,
+            'faces_detected': 0,
+            'workers_recognized': 0,
+            'new_registrations': 0
+        }
 
         # Data Storage
         self.known_face_embeddings: List[np.ndarray] = []
@@ -84,298 +249,569 @@ class AttendanceSystem:
         
         # Session Tracking
         self.last_recognition_time = {}
-        self.recognition_cooldown = 5
+        self.recognition_cooldown = RECOGNITION_COOLDOWN
         self.session_log: List[str] = []
 
-        # Initialize
+        # Initialize components
+        self.db = LocalDatabase()
         self.sf = connect_to_salesforce()
         self._create_directories()
         self.load_worker_data()
 
     def _create_directories(self):
-        os.makedirs("data/faces", exist_ok=True)
+        """Create necessary directories."""
+        directories = ["data/faces", "data/reports", "data/backups"]
+        for directory in directories:
+            os.makedirs(directory, exist_ok=True)
 
     def load_worker_data(self):
+        """Load worker data with improved error handling and offline support."""
         logger.info("Loading worker data...")
+        
+        # First try to load from local database
+        local_workers = self.db.get_all_workers()
+        if local_workers:
+            self._load_workers_from_list(local_workers)
+            logger.info(f"✅ Loaded {len(local_workers)} workers from local database.")
+        
+        # Then sync with Salesforce if available
         if self.sf:
             try:
-                workers = self.sf.query_all("SELECT Worker_ID__c, Name, Face_Embedding__c FROM Worker__c")['records']
-                if not workers:
-                    self._load_local_worker_data()
-                    return
-
-                temp_embeddings, temp_names, temp_ids, max_id = [], [], [], 0
-                for worker in workers:
-                    if worker.get('Face_Embedding__c'):
-                        temp_embeddings.append(np.array(json.loads(worker['Face_Embedding__c'])))
-                        temp_names.append(worker['Name'])
-                        temp_ids.append(worker['Worker_ID__c'])
-                        try:
-                            worker_num = int(worker['Worker_ID__c'][1:])
-                            if worker_num > max_id:
-                                max_id = worker_num
-                        except (ValueError, TypeError):
-                            continue
-                
-                self.known_face_embeddings = temp_embeddings
-                self.known_face_names = temp_names
-                self.known_face_ids = temp_ids
-                self.next_worker_id = max_id + 1
-                self.save_local_worker_data()
-                logger.info(f"✅ Loaded {len(self.known_face_ids)} workers from Salesforce.")
+                self._sync_with_salesforce()
             except Exception as e:
-                logger.error(f"❌ Error loading from Salesforce: {e}. Attempting local load.")
-                self._load_local_worker_data()
+                logger.error(f"❌ Error syncing with Salesforce: {e}")
         else:
-            logger.warning("Salesforce not connected. Loading from local cache.")
-            self._load_local_worker_data()
+            logger.warning("Salesforce not connected. Running in offline mode.")
 
-    def _load_local_worker_data(self):
-        try:
-            if os.path.exists("data/workers.pkl"):
-                with open("data/workers.pkl", "rb") as f: data = pickle.load(f)
-                self.known_face_embeddings = data.get("embeddings", [])
-                self.known_face_names = data.get("names", [])
-                self.known_face_ids = data.get("ids", [])
-                self.next_worker_id = data.get("next_id", 1)
-                logger.info(f"✅ Loaded {len(self.known_face_ids)} workers from local cache.")
-        except Exception as e:
-            logger.error(f"❌ Error loading local data: {e}")
+    def _load_workers_from_list(self, workers: List[Dict[str, Any]]):
+        """Load workers from a list of worker dictionaries."""
+        temp_embeddings, temp_names, temp_ids, max_id = [], [], [], 0
+        
+        for worker in workers:
+            temp_embeddings.append(np.array(worker['embedding']))
+            temp_names.append(worker['name'])
+            temp_ids.append(worker['worker_id'])
+            
+            try:
+                worker_num = int(worker['worker_id'][1:])
+                if worker_num > max_id:
+                    max_id = worker_num
+            except (ValueError, TypeError):
+                continue
+        
+        self.known_face_embeddings = temp_embeddings
+        self.known_face_names = temp_names
+        self.known_face_ids = temp_ids
+        self.next_worker_id = max_id + 1
 
-    def save_local_worker_data(self):
+    def _sync_with_salesforce(self):
+        """Sync data with Salesforce."""
         try:
-            worker_data = {"embeddings": self.known_face_embeddings, "names": self.known_face_names, "ids": self.known_face_ids, "next_id": self.next_worker_id}
-            with open("data/workers.pkl", "wb") as f: pickle.dump(worker_data, f)
+            workers = self.sf.query_all("SELECT Worker_ID__c, Name, Face_Embedding__c FROM Worker__c")['records']
+            
+            for worker in workers:
+                if worker.get('Face_Embedding__c'):
+                    # Add to local database if not exists
+                    self.db.add_worker(
+                        worker['Worker_ID__c'],
+                        worker['Name'],
+                        json.loads(worker['Face_Embedding__c'])
+                    )
+            
+            logger.info(f"✅ Synced {len(workers)} workers from Salesforce.")
         except Exception as e:
-            logger.error(f"❌ Error saving local worker data: {e}")
-    
-    # --- Registration and Attendance ---
+            logger.error(f"❌ Salesforce sync error: {e}")
+
     def register_worker_manual(self, image: Image.Image, name: str) -> Tuple[str, str]:
+        """Register a worker manually with enhanced validation."""
         if image is None or not name.strip():
             return "❌ Please provide both image and name!", self.get_registered_workers_info()
+        
         try:
+            # Validate image quality
             image_array = np.array(image)
-            DeepFace.analyze(img_path=image_array, actions=['emotion'], enforce_detection=True)
-            embedding = DeepFace.represent(img_path=image_array, model_name='Facenet')[0]['embedding']
+            if image_array.shape[0] < 100 or image_array.shape[1] < 100:
+                return "❌ Image resolution too low. Please use a higher quality image!", self.get_registered_workers_info()
+            
+            # Detect face
+            face_analysis = DeepFace.analyze(
+                img_path=image_array, 
+                actions=['emotion'], 
+                enforce_detection=True
+            )
+            
+            # Get embedding
+            embedding = DeepFace.represent(
+                img_path=image_array, 
+                model_name='Facenet'
+            )[0]['embedding']
+            
+            # Check for duplicates
             if self._is_duplicate_face(embedding):
-                 return f"❌ Face matches an existing worker!", self.get_registered_workers_info()
+                return f"❌ Face matches an existing worker!", self.get_registered_workers_info()
 
             worker_id = f"W{self.next_worker_id:04d}"
             name = name.strip().title()
-            self._add_worker_to_system(worker_id, name, embedding, image_array)
-            self.save_local_worker_data()
-            self.load_worker_data()
-            return f"✅ {name} registered with ID: {worker_id}!", self.get_registered_workers_info()
-        except ValueError:
-            return "❌ No face detected in the image!", self.get_registered_workers_info()
+            
+            # Add to system
+            success = self._add_worker_to_system(worker_id, name, embedding, image_array)
+            if success:
+                return f"✅ {name} registered with ID: {worker_id}!", self.get_registered_workers_info()
+            else:
+                return f"❌ Failed to register worker!", self.get_registered_workers_info()
+                
+        except ValueError as e:
+            return "❌ No face detected in the image! Please ensure the face is clearly visible.", self.get_registered_workers_info()
         except Exception as e:
-            return f"❌ Registration error: {e}", self.get_registered_workers_info()
+            logger.error(f"Registration error: {e}")
+            return f"❌ Registration error: {str(e)}", self.get_registered_workers_info()
 
     def _register_worker_auto(self, face_image: np.ndarray) -> Optional[Tuple[str, str]]:
+        """Auto-register a new worker with improved validation."""
         try:
-            embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
-            if self._is_duplicate_face(embedding): return None
+            # Skip very small faces
+            if face_image.shape[0] < 50 or face_image.shape[1] < 50:
+                return None
+            
+            embedding = DeepFace.represent(
+                img_path=face_image, 
+                model_name='Facenet', 
+                enforce_detection=False
+            )[0]['embedding']
+            
+            if self._is_duplicate_face(embedding): 
+                return None
+            
             worker_id = f"W{self.next_worker_id:04d}"
             worker_name = f"Unknown Worker {self.next_worker_id}"
-            self._add_worker_to_system(worker_id, worker_name, embedding, face_image)
-            self.save_local_worker_data()
-            log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} ({worker_id})"
-            self.session_log.append(log_msg)
-            logger.info(log_msg)
-            return worker_id, worker_name
+            
+            success = self._add_worker_to_system(worker_id, worker_name, embedding, face_image)
+            if success:
+                log_msg = f"🆕 [{datetime.now().strftime('%H:%M:%S')}] Auto-registered: {worker_name} ({worker_id})"
+                self.session_log.append(log_msg)
+                logger.info(log_msg)
+                self.processing_stats['new_registrations'] += 1
+                return worker_id, worker_name
+            
         except Exception as e:
             logger.error(f"❌ Auto-registration error: {e}")
-            return None
+        
+        return None
 
-    def _add_worker_to_system(self, worker_id: str, name: str, embedding: List[float], image_array: np.ndarray):
-        self.known_face_embeddings.append(np.array(embedding))
-        self.known_face_names.append(name)
-        self.known_face_ids.append(worker_id)
-        self.next_worker_id += 1
-        face_pil = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
-        face_pil.save(f"data/faces/{worker_id}.jpg")
-        caption = self._get_image_caption(face_pil)
-        if self.sf:
-            try:
-                worker_record = self.sf.Worker__c.create({'Name': name, 'Worker_ID__c': worker_id, 'Face_Embedding__c': json.dumps(embedding), 'Image_Caption__c': caption})
-                image_url = self._upload_image_to_salesforce(face_pil, worker_record['id'], worker_id)
-                if image_url: self.sf.Worker__c.update(worker_record['id'], {'Image_URL__c': image_url})
-                logger.info(f"✅ Worker {worker_id} synced to Salesforce.")
-            except Exception as e:
-                logger.error(f"❌ Salesforce sync error for {worker_id}: {e}")
+    def _add_worker_to_system(self, worker_id: str, name: str, embedding: List[float], image_array: np.ndarray) -> bool:
+        """Add worker to system with improved error handling."""
+        try:
+            # Add to memory
+            self.known_face_embeddings.append(np.array(embedding))
+            self.known_face_names.append(name)
+            self.known_face_ids.append(worker_id)
+            self.next_worker_id += 1
+            
+            # Save face image
+            face_pil = Image.fromarray(cv2.cvtColor(image_array, cv2.COLOR_BGR2RGB))
+            image_path = f"data/faces/{worker_id}.jpg"
+            face_pil.save(image_path)
+            
+            # Add to local database
+            db_success = self.db.add_worker(worker_id, name, embedding, image_path)
+            
+            # Sync to Salesforce if available
+            if self.sf:
+                try:
+                    caption = self._get_image_caption(face_pil)
+                    worker_record = self.sf.Worker__c.create({
+                        'Name': name, 
+                        'Worker_ID__c': worker_id, 
+                        'Face_Embedding__c': json.dumps(embedding), 
+                        'Image_Caption__c': caption
+                    })
+                    
+                    image_url = self._upload_image_to_salesforce(face_pil, worker_record['id'], worker_id)
+                    if image_url: 
+                        self.sf.Worker__c.update(worker_record['id'], {'Image_URL__c': image_url})
+                    
+                    logger.info(f"✅ Worker {worker_id} synced to Salesforce.")
+                except Exception as e:
+                    logger.error(f"❌ Salesforce sync error for {worker_id}: {e}")
+            
+            return db_success
+            
+        except Exception as e:
+            logger.error(f"❌ Error adding worker to system: {e}")
+            return False
 
-    def _is_duplicate_face(self, embedding: List[float], threshold: float = 10.0) -> bool:
-        if not self.known_face_embeddings: return False
-        distances = [np.linalg.norm(np.array(embedding) - known_embedding) for known_embedding in self.known_face_embeddings]
+    def _is_duplicate_face(self, embedding: List[float], threshold: float = None) -> bool:
+        """Check for duplicate faces with configurable threshold."""
+        if not self.known_face_embeddings: 
+            return False
+        
+        threshold = threshold or FACE_RECOGNITION_THRESHOLD
+        distances = [
+            np.linalg.norm(np.array(embedding) - known_embedding) 
+            for known_embedding in self.known_face_embeddings
+        ]
         return min(distances) < threshold
 
     def mark_attendance(self, worker_id: str, worker_name: str) -> bool:
+        """Mark attendance with improved tracking."""
         today_str = date.today().isoformat()
-        if self._has_attended_today(worker_id, today_str): return False
-        current_time = datetime.now()
+        
+        # Check cooldown period
+        last_seen = self.last_recognition_time.get(worker_id)
+        if last_seen and (time.time() - last_seen < self.recognition_cooldown):
+            return False
+        
+        # Check if already attended today
+        if self.db.has_attended_today(worker_id, today_str):
+            return False
+        
+        # Mark attendance in local database
+        db_success = self.db.mark_attendance(worker_id, worker_name, today_str)
+        
+        # Sync to Salesforce if available
         if self.sf:
             try:
-                self.sf.Attendance__c.create({'Worker_ID__c': worker_id, 'Name__c': worker_name, 'Date__c': today_str, 'Timestamp__c': current_time.isoformat(), 'Status__c': "Present"})
+                current_time = datetime.now()
+                self.sf.Attendance__c.create({
+                    'Worker_ID__c': worker_id, 
+                    'Name__c': worker_name, 
+                    'Date__c': today_str, 
+                    'Timestamp__c': current_time.isoformat(), 
+                    'Status__c': "Present"
+                })
             except Exception as e:
                 logger.error(f"❌ Error saving attendance to Salesforce: {e}")
-        log_msg = f"✅ [{current_time.strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
-        self.session_log.append(log_msg)
-        return True
-
-    def _has_attended_today(self, worker_id: str, today_str: str) -> bool:
-        last_seen = self.last_recognition_time.get(worker_id)
-        if last_seen and (time.time() - last_seen < self.recognition_cooldown): return True
-        if self.sf:
-            try:
-                if self.sf.query(f"SELECT Id FROM Attendance__c WHERE Worker_ID__c = '{worker_id}' AND Date__c = {today_str}")['totalSize'] > 0:
-                    return True
-            except Exception: pass
-        return False
+        
+        if db_success:
+            current_time = datetime.now()
+            log_msg = f"✅ [{current_time.strftime('%H:%M:%S')}] Marked Present: {worker_name} ({worker_id})"
+            self.session_log.append(log_msg)
+            self.processing_stats['workers_recognized'] += 1
+        
+        return db_success
 
-    # --- Video Processing ---
     def process_frame(self, frame: np.ndarray) -> np.ndarray:
-        """
-        Main function to process a single video frame with the unpacking bug fixed.
-        """
+        """Enhanced frame processing with better error handling and statistics."""
         try:
-            face_objs = DeepFace.extract_faces(img_path=frame, detector_backend='opencv', enforce_detection=False)
+            self.processing_stats['frames_processed'] += 1
+            
+            # Extract faces with improved error handling
+            try:
+                face_objs = DeepFace.extract_faces(
+                    img_path=frame, 
+                    detector_backend='opencv', 
+                    enforce_detection=False
+                )
+            except Exception as e:
+                logger.warning(f"Face extraction error: {e}")
+                return frame
 
             if face_objs:
-                print(f"\n--- Frame Processed: Found {len(face_objs)} faces. ---")
+                self.processing_stats['faces_detected'] += len(face_objs)
+                logger.debug(f"Found {len(face_objs)} faces in frame")
 
             for i, face_obj in enumerate(face_objs):
-                confidence = face_obj['confidence']
-                print(f"  Face #{i+1}: Confidence Score = {confidence:.2f}")
-
-                if confidence < 0.95:
-                    print("    -> Confidence too low, skipping.")
-                    continue
-
-                # --- THIS IS THE FIX ---
-                # Instead of unpacking all values, we now access them by their specific keys.
-                facial_area = face_obj['facial_area']
-                x, y, w, h = facial_area['x'], facial_area['y'], facial_area['w'], facial_area['h']
-                # --- END OF FIX ---
-                
-                face_image = frame[y:y+h, x:x+w]
-                
-                if face_image.size == 0: continue
-
-                embedding = DeepFace.represent(img_path=face_image, model_name='Facenet', enforce_detection=False)[0]['embedding']
-                
-                if not self.known_face_embeddings:
-                    print("    -> No known faces in database to compare against.")
+                try:
+                    confidence = face_obj.get('confidence', 0)
+                    
+                    if confidence < CONFIDENCE_THRESHOLD:
+                        continue
+
+                    # Extract facial area coordinates
+                    facial_area = face_obj['facial_area']
+                    x, y, w, h = facial_area['x'], facial_area['y'], facial_area['w'], facial_area['h']
+                    
+                    # Validate coordinates
+                    if x < 0 or y < 0 or w <= 0 or h <= 0:
+                        continue
+                    
+                    face_image = frame[y:y+h, x:x+w]
+                    
+                    if face_image.size == 0: 
+                        continue
+
+                    # Get face embedding
+                    try:
+                        embedding = DeepFace.represent(
+                            img_path=face_image, 
+                            model_name='Facenet', 
+                            enforce_detection=False
+                        )[0]['embedding']
+                    except Exception as e:
+                        logger.warning(f"Embedding extraction error: {e}")
+                        continue
+                    
+                    # Face recognition
+                    color, worker_id, worker_name = self._recognize_face(embedding, face_image)
+                    
+                    # Draw bounding box and label
+                    label = f"{worker_name}" + (f" ({worker_id})" if worker_id else "")
+                    cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
+                    
+                    # Add background for text
+                    label_size = cv2.getTextSize(label, cv2.FONT_HERSHEY_SIMPLEX, 0.7, 2)[0]
+                    cv2.rectangle(frame, (x, y-30), (x + label_size[0], y), color, -1)
+                    cv2.putText(frame, label, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (255, 255, 255), 2)
+                    
+                except Exception as e:
+                    logger.warning(f"Error processing face {i}: {e}")
                     continue
 
-                distances = [np.linalg.norm(np.array(embedding) - known) for known in self.known_face_embeddings]
-                min_dist = min(distances)
-                match_index = distances.index(min_dist) if min_dist < 10.0 else -1
-
-                print(f"    -> Comparing to DB... Minimum Distance Found: {min_dist:.4f}")
-
-                color, worker_id, worker_name = (0, 0, 255), None, "Unknown"
-                
-                if match_index != -1:
-                    worker_id = self.known_face_ids[match_index]
-                    worker_name = self.known_face_names[match_index]
-                    color = (0, 255, 0) # Green
-                    print(f"    ✓ MATCH! (Threshold: 10.0). Recognized as {worker_name}")
-                    if self.mark_attendance(worker_id, worker_name):
-                        self.last_recognition_time[worker_id] = time.time()
-                else:
-                    color = (0, 165, 255) # Orange for potential new worker
-                    print(f"    ✗ NO MATCH (Threshold: 10.0). Attempting to register as new worker...")
-                    new_worker = self._register_worker_auto(face_image)
-                    if new_worker:
-                        worker_id, worker_name = new_worker[0], new_worker[1]
-                        if self.mark_attendance(worker_id, worker_name):
-                            self.last_recognition_time[worker_id] = time.time()
-                
-                label = f"{worker_name}" + (f" ({worker_id})" if worker_id else "")
-                cv2.rectangle(frame, (x, y), (x+w, y+h), color, 2)
-                cv2.putText(frame, label, (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.7, color, 2)
-
             return frame
+            
         except Exception as e:
-            print(f"ERROR in process_frame: {e}")
+            logger.error(f"ERROR in process_frame: {e}")
             return frame
 
+    def _recognize_face(self, embedding: List[float], face_image: np.ndarray) -> Tuple[Tuple[int, int, int], Optional[str], str]:
+        """Recognize face and return color, worker_id, and worker_name."""
+        if not self.known_face_embeddings:
+            return (0, 0, 255), None, "Unknown"  # Red for unknown
+
+        distances = [
+            np.linalg.norm(np.array(embedding) - known) 
+            for known in self.known_face_embeddings
+        ]
+        min_dist = min(distances)
+        match_index = distances.index(min_dist) if min_dist < FACE_RECOGNITION_THRESHOLD else -1
+
+        if match_index != -1:
+            worker_id = self.known_face_ids[match_index]
+            worker_name = self.known_face_names[match_index]
+            
+            # Mark attendance
+            if self.mark_attendance(worker_id, worker_name):
+                self.last_recognition_time[worker_id] = time.time()
+            
+            return (0, 255, 0), worker_id, worker_name  # Green for recognized
+        else:
+            # Try auto-registration
+            new_worker = self._register_worker_auto(face_image)
+            if new_worker:
+                worker_id, worker_name = new_worker[0], new_worker[1]
+                if self.mark_attendance(worker_id, worker_name):
+                    self.last_recognition_time[worker_id] = time.time()
+                return (0, 165, 255), worker_id, worker_name  # Orange for new
+            
+            return (0, 0, 255), None, "Unknown"  # Red for unknown
+
     def _processing_loop(self, source):
-        video_capture = cv2.VideoCapture(source)
-        if not video_capture.isOpened():
-            err_msg = f"❌ **Error:** Could not open video source. The file may be corrupt or in an unsupported format. Please try converting it to a standard MP4."
-            self.error_message = err_msg
+        """Enhanced processing loop with better error handling."""
+        video_capture = None
+        try:
+            video_capture = cv2.VideoCapture(source)
+            if not video_capture.isOpened():
+                err_msg = f"❌ **Error:** Could not open video source. Please check the source and try again."
+                self.error_message = err_msg
+                self.is_processing.clear()
+                return
+
+            # Reset statistics
+            self.processing_stats = {
+                'frames_processed': 0,
+                'faces_detected': 0,
+                'workers_recognized': 0,
+                'new_registrations': 0
+            }
+
+            while self.is_processing.is_set():
+                ret, frame = video_capture.read()
+                if not ret: 
+                    break
+                
+                processed_frame = self.process_frame(frame)
+                
+                if not self.frame_queue.full(): 
+                    self.frame_queue.put(processed_frame)
+                
+                self.last_processed_frame = processed_frame
+                time.sleep(0.05)  # Control frame rate
+                
+        except Exception as e:
+            logger.error(f"Processing loop error: {e}")
+            self.error_message = f"❌ Processing error: {str(e)}"
+        finally:
+            if video_capture:
+                video_capture.release()
+            
+            self.final_log = self.session_log.copy()
             self.is_processing.clear()
-            return
-        while self.is_processing.is_set():
-            ret, frame = video_capture.read()
-            if not ret: break
-            processed_frame = self.process_frame(frame)
-            if not self.frame_queue.full(): self.frame_queue.put(processed_frame)
-            self.last_processed_frame = processed_frame # Continuously update last frame
-            time.sleep(0.05)
-        self.final_log = self.session_log.copy() # Save the final log
-        video_capture.release()
-        self.is_processing.clear()
 
     def start_processing(self, source) -> str:
-        if self.is_processing.is_set(): return "⚠️ Processing is already active."
+        """Start processing with enhanced validation."""
+        if self.is_processing.is_set(): 
+            return "⚠️ Processing is already active."
+        
+        if source is None:
+            return "❌ Please provide a valid input source."
+        
         # Reset states for the new session
-        self.session_log.clear(); self.last_recognition_time.clear()
-        self.error_message = None; self.last_processed_frame = None; self.final_log = None
+        self.session_log.clear()
+        self.last_recognition_time.clear()
+        self.error_message = None
+        self.last_processed_frame = None
+        self.final_log = None
+        
         self.is_processing.set()
-        self.processing_thread = threading.Thread(target=self._processing_loop, args=(source,)); self.processing_thread.daemon = True
+        self.processing_thread = threading.Thread(target=self._processing_loop, args=(source,))
+        self.processing_thread.daemon = True
         self.processing_thread.start()
-        return f"✅ Started processing..."
+        
+        return f"✅ Started processing from source: {source}"
 
     def stop_processing(self) -> str:
-        # Reset states when stopping manually
-        self.is_processing.clear(); self.error_message = None
-        self.last_processed_frame = None; self.final_log = None
-        return "✅ Processing stopped by user."
+        """Stop processing and generate summary."""
+        if not self.is_processing.is_set():
+            return "⚠️ No processing is currently active."
+        
+        self.is_processing.clear()
+        
+        # Generate processing summary
+        stats = self.processing_stats
+        summary = f"""✅ Processing stopped.
+📊 Session Summary:
+- Frames processed: {stats['frames_processed']}
+- Faces detected: {stats['faces_detected']}
+- Workers recognized: {stats['workers_recognized']}
+- New registrations: {stats['new_registrations']}"""
+        
+        return summary
+
+    def get_processing_stats(self) -> str:
+        """Get current processing statistics."""
+        stats = self.processing_stats
+        return f"""📊 **Processing Statistics:**
+- Frames processed: {stats['frames_processed']}
+- Faces detected: {stats['faces_detected']}
+- Workers recognized: {stats['workers_recognized']}
+- New registrations: {stats['new_registrations']}"""
+
+    def generate_attendance_report(self, start_date: str = None, end_date: str = None) -> pd.DataFrame:
+        """Generate attendance report."""
+        return self.db.get_attendance_report(start_date, end_date)
+
+    def export_attendance_csv(self, start_date: str = None, end_date: str = None) -> str:
+        """Export attendance data to CSV."""
+        try:
+            df = self.generate_attendance_report(start_date, end_date)
+            if df.empty:
+                return "❌ No attendance data found for the specified period."
+            
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"data/reports/attendance_report_{timestamp}.csv"
+            df.to_csv(filename, index=False)
+            
+            return f"✅ Attendance report exported to: {filename}"
+        except Exception as e:
+            logger.error(f"Error exporting attendance report: {e}")
+            return f"❌ Error exporting report: {str(e)}"
+
+    def backup_system_data(self) -> str:
+        """Create a backup of system data."""
+        try:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_dir = f"data/backups/backup_{timestamp}"
+            os.makedirs(backup_dir, exist_ok=True)
+            
+            # Backup database
+            import shutil
+            shutil.copy2(self.db.db_path, f"{backup_dir}/attendance.db")
+            
+            # Backup face images
+            if os.path.exists("data/faces"):
+                shutil.copytree("data/faces", f"{backup_dir}/faces")
+            
+            return f"✅ System backup created: {backup_dir}"
+        except Exception as e:
+            logger.error(f"Backup error: {e}")
+            return f"❌ Backup failed: {str(e)}"
 
     # --- Helper & Reporting ---
     def _get_image_caption(self, image: Image.Image) -> str:
-        if not HF_API_TOKEN: return "Hugging Face API token not configured."
+        """Generate image caption using Hugging Face API."""
+        if not HF_API_TOKEN: 
+            return "Hugging Face API token not configured."
+        
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
             img_data = buffered.getvalue()
             headers = {"Authorization": f"Bearer {HF_API_TOKEN}"}
-            response = requests.post(HF_API_URL, headers=headers, data=img_data)
+            
+            response = requests.post(HF_API_URL, headers=headers, data=img_data, timeout=30)
             response.raise_for_status()
             result = response.json()
+            
             return result[0].get("generated_text", "No caption found.")
+        except requests.exceptions.Timeout:
+            return "Caption generation timed out."
         except Exception as e:
             logger.error(f"Hugging Face API error: {e}")
             return "Caption generation failed."
 
     def _upload_image_to_salesforce(self, image: Image.Image, record_id: str, worker_id: str) -> Optional[str]:
-        if not self.sf: return None
+        """Upload image to Salesforce with error handling."""
+        if not self.sf: 
+            return None
+        
         try:
             buffered = BytesIO()
             image.save(buffered, format="JPEG")
             encoded_image = base64.b64encode(buffered.getvalue()).decode('utf-8')
-            cv = self.sf.ContentVersion.create({'Title': f'Image_{worker_id}', 'PathOnClient': f'{worker_id}.jpg', 'VersionData': encoded_image, 'FirstPublishLocationId': record_id})
-            return f"/{cv['id']}" # Relative URL
+            
+            cv = self.sf.ContentVersion.create({
+                'Title': f'Image_{worker_id}', 
+                'PathOnClient': f'{worker_id}.jpg', 
+                'VersionData': encoded_image, 
+                'FirstPublishLocationId': record_id
+            })
+            
+            return f"/{cv['id']}"  # Relative URL
         except Exception as e:
             logger.error(f"Salesforce image upload error: {e}")
             return None
 
     def get_registered_workers_info(self) -> str:
-        if not self.sf: return "❌ Salesforce not connected."
+        """Get information about registered workers."""
         try:
-            records = self.sf.query_all("SELECT Name, Worker_ID__c FROM Worker__c ORDER BY Name")['records']
-            if not records: return "No workers registered."
-            return f"**👥 Registered Workers ({len(records)})**\n" + "\n".join([f"- **{w['Name']}** (ID: {w['Worker_ID__c']})" for w in records])
-        except Exception as e: return f"Error: {e}"
+            workers = self.db.get_all_workers()
+            if not workers: 
+                return "No workers registered."
+            
+            worker_list = "\n".join([
+                f"- **{w['name']}** (ID: {w['worker_id']})" 
+                for w in workers
+            ])
+            
+            return f"**👥 Registered Workers ({len(workers)})**\n{worker_list}"
+        except Exception as e: 
+            return f"Error: {e}"
+
+    def get_system_status(self) -> str:
+        """Get comprehensive system status."""
+        sf_status = "✅ Connected" if self.sf else "❌ Offline"
+        db_workers = len(self.db.get_all_workers())
+        
+        status = f"""🔧 **System Status:**
+- Salesforce: {sf_status}
+- Registered Workers: {db_workers}
+- Recognition Threshold: {FACE_RECOGNITION_THRESHOLD}
+- Confidence Threshold: {CONFIDENCE_THRESHOLD}
+- Processing: {'✅ Active' if self.is_processing.is_set() else '⏹️ Stopped'}"""
         
+        return status
+
 # --- GRADIO UI ---
 attendance_system = AttendanceSystem()
+
 def create_interface():
-    with gr.Blocks(theme=gr.themes.Soft(), title="Attendance System") as demo:
+    """Create enhanced Gradio interface with new features."""
+    with gr.Blocks(theme=gr.themes.Soft(), title="Advanced Attendance System") as demo:
         gr.Markdown("# 🎯 Advanced Face Recognition Attendance System")
+        gr.Markdown("*Enhanced with offline support, statistics, and reporting features*")
+        
         with gr.Tabs():
+            # Main Controls Tab
             with gr.Tab("⚙️ Controls & Status"):
                 gr.Markdown("### 1. Choose Input Source & Start Processing")
                 with gr.Row():
@@ -390,9 +826,17 @@ def create_interface():
                         start_btn = gr.Button("▶️ Start Processing", variant="primary")
                         stop_btn = gr.Button("⏹️ Stop Processing", variant="stop")
                         status_box = gr.Textbox(label="Status", interactive=False, value="System Ready.")
-                gr.Markdown("### 2. View Results in the 'Output & Log' Tab")
+                
+                gr.Markdown("### 2. System Information")
+                with gr.Row():
+                    system_status = gr.Markdown(value=attendance_system.get_system_status())
+                    processing_stats = gr.Markdown(value="📊 **Processing Statistics:** Not started")
+                    refresh_status_btn = gr.Button("🔄 Refresh Status")
+                
+                gr.Markdown("### 3. View Results in the 'Output & Log' Tab")
                 gr.Markdown("**🎨 Color Coding:** <font color='green'>Green</font> = Known, <font color='orange'>Orange</font> = New, <font color='red'>Red</font> = Unknown")
             
+            # Output Tab
             with gr.Tab("📊 Output & Log"):
                 with gr.Row():
                     with gr.Column(scale=2):
@@ -400,6 +844,7 @@ def create_interface():
                     with gr.Column(scale=1):
                         session_log_display = gr.Markdown(label="📋 Session Log", value="System is ready.")
 
+            # Worker Management Tab
             with gr.Tab("👤 Worker Management"):
                 with gr.Row():
                     with gr.Column():
@@ -411,30 +856,135 @@ def create_interface():
                         registered_workers_info = gr.Markdown(value=attendance_system.get_registered_workers_info())
                         refresh_workers_btn = gr.Button("🔄 Refresh List")
 
+            # Reports Tab
+            with gr.Tab("📈 Reports & Analytics"):
+                gr.Markdown("### Attendance Reports")
+                with gr.Row():
+                    start_date = gr.Textbox(label="Start Date (YYYY-MM-DD)", placeholder="2024-01-01")
+                    end_date = gr.Textbox(label="End Date (YYYY-MM-DD)", placeholder="2024-12-31")
+                
+                with gr.Row():
+                    generate_report_btn = gr.Button("📊 Generate Report", variant="primary")
+                    export_csv_btn = gr.Button("💾 Export CSV")
+                
+                report_output = gr.Dataframe(label="Attendance Report")
+                export_status = gr.Textbox(label="Export Status", interactive=False)
+
+            # System Management Tab
+            with gr.Tab("🔧 System Management"):
+                gr.Markdown("### System Operations")
+                with gr.Row():
+                    backup_btn = gr.Button("💾 Create Backup", variant="secondary")
+                    backup_status = gr.Textbox(label="Backup Status", interactive=False)
+                
+                gr.Markdown("### System Configuration")
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown(f"**Current Settings:**")
+                        gr.Markdown(f"- Face Recognition Threshold: {FACE_RECOGNITION_THRESHOLD}")
+                        gr.Markdown(f"- Confidence Threshold: {CONFIDENCE_THRESHOLD}")
+                        gr.Markdown(f"- Recognition Cooldown: {RECOGNITION_COOLDOWN}s")
+                    with gr.Column():
+                        gr.Markdown("**System Directories:**")
+                        gr.Markdown("- Faces: `data/faces/`")
+                        gr.Markdown("- Reports: `data/reports/`")
+                        gr.Markdown("- Backups: `data/backups/`")
+
         # --- Event Handlers ---
-        def on_tab_select(evt: gr.SelectData): return evt.index
+        def on_tab_select(evt: gr.SelectData): 
+            return evt.index
+        
         video_tabs.select(fn=on_tab_select, inputs=None, outputs=[selected_tab_index])
+        
         def start_wrapper(tab_index, cam_src, vid_path):
             source = cam_src if tab_index == 0 else vid_path
-            return "Please provide an input source." if source is None else attendance_system.start_processing(source)
-        start_btn.click(fn=start_wrapper, inputs=[selected_tab_index, camera_source, video_file], outputs=[status_box])
-        stop_btn.click(fn=attendance_system.stop_processing, inputs=None, outputs=[status_box])
-        register_btn.click(fn=attendance_system.register_worker_manual, inputs=[register_image, register_name], outputs=[register_output, registered_workers_info])
-        refresh_workers_btn.click(fn=attendance_system.get_registered_workers_info, outputs=[registered_workers_info])
+            if source is None:
+                return "❌ Please provide an input source."
+            return attendance_system.start_processing(source)
+        
+        def stop_wrapper():
+            return attendance_system.stop_processing()
+        
+        def refresh_status():
+            return attendance_system.get_system_status(), attendance_system.get_processing_stats()
+        
+        def generate_report(start_date_val, end_date_val):
+            try:
+                df = attendance_system.generate_attendance_report(
+                    start_date_val if start_date_val else None,
+                    end_date_val if end_date_val else None
+                )
+                return df
+            except Exception as e:
+                logger.error(f"Report generation error: {e}")
+                return pd.DataFrame()
+        
+        def export_csv_wrapper(start_date_val, end_date_val):
+            return attendance_system.export_attendance_csv(
+                start_date_val if start_date_val else None,
+                end_date_val if end_date_val else None
+            )
+        
+        # Connect event handlers
+        start_btn.click(
+            fn=start_wrapper, 
+            inputs=[selected_tab_index, camera_source, video_file], 
+            outputs=[status_box]
+        )
+        
+        stop_btn.click(fn=stop_wrapper, inputs=None, outputs=[status_box])
+        
+        register_btn.click(
+            fn=attendance_system.register_worker_manual, 
+            inputs=[register_image, register_name], 
+            outputs=[register_output, registered_workers_info]
+        )
         
+        refresh_workers_btn.click(
+            fn=attendance_system.get_registered_workers_info, 
+            outputs=[registered_workers_info]
+        )
+        
+        refresh_status_btn.click(
+            fn=refresh_status,
+            outputs=[system_status, processing_stats]
+        )
+        
+        generate_report_btn.click(
+            fn=generate_report,
+            inputs=[start_date, end_date],
+            outputs=[report_output]
+        )
+        
+        export_csv_btn.click(
+            fn=export_csv_wrapper,
+            inputs=[start_date, end_date],
+            outputs=[export_status]
+        )
+        
+        backup_btn.click(
+            fn=attendance_system.backup_system_data,
+            outputs=[backup_status]
+        )
+        
+        # UI Update Generator
         def update_ui_generator():
             while True:
                 if attendance_system.error_message:
                     yield None, attendance_system.error_message
-                    time.sleep(2); attendance_system.error_message = None
+                    time.sleep(2)
+                    attendance_system.error_message = None
                     continue
+                
                 if attendance_system.is_processing.is_set():
                     frame, log_md = None, "\n".join(reversed(attendance_system.session_log)) or "Processing..."
                     try:
                         if not attendance_system.frame_queue.empty():
                             frame = attendance_system.frame_queue.get_nowait()
-                            if frame is not None: frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
-                    except queue.Empty: pass
+                            if frame is not None: 
+                                frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+                    except queue.Empty: 
+                        pass
                     yield frame, log_md
                 else:
                     if attendance_system.last_processed_frame is not None:
@@ -443,12 +993,24 @@ def create_interface():
                         yield final_frame, final_log_md
                     else:
                         yield None, "System stopped. Go to 'Controls & Status' to start."
+                
                 time.sleep(0.1)
 
         demo.load(fn=update_ui_generator, outputs=[video_output, session_log_display])
+    
     return demo
 
 if __name__ == "__main__":
-    app = create_interface()
-    app.queue()
-    app.launch(server_name="0.0.0.0", server_port=7860, show_error=True, debug=True)
+    try:
+        app = create_interface()
+        app.queue()
+        app.launch(
+            server_name="0.0.0.0", 
+            server_port=7860, 
+            show_error=True, 
+            debug=True,
+            share=False  # Set to True if you want to create a public link
+        )
+    except Exception as e:
+        logger.error(f"Failed to launch application: {e}")
+        print(f"❌ Application failed to start: {e}")