punimtag/photo_tagger.py

#!/usr/bin/env python3
"""
PunimTag CLI - Minimal Photo Face Tagger
Simple command-line tool for face recognition and photo tagging
"""

import os
import sqlite3
import argparse
import face_recognition
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont
from PIL.ExifTags import TAGS
import pickle
import numpy as np
from typing import List, Dict, Tuple, Optional
import sys
import tempfile
import subprocess
import threading
import time
from datetime import datetime
from functools import lru_cache
from contextlib import contextmanager


class PhotoTagger:
    def __init__(self, db_path: str = "data/photos.db", verbose: int = 0, debug: bool = False):
        """Initialize the photo tagger with database"""
        self.db_path = db_path
        self.verbose = verbose
        self.debug = debug
        self._face_encoding_cache = {}
        self._image_cache = {}
        self._db_connection = None
        self._db_lock = threading.Lock()
        self.init_database()
    
    @contextmanager
    def get_db_connection(self):
        """Context manager for database connections with connection pooling"""
        with self._db_lock:
            if self._db_connection is None:
                self._db_connection = sqlite3.connect(self.db_path)
                self._db_connection.row_factory = sqlite3.Row
            try:
                yield self._db_connection
            except Exception:
                self._db_connection.rollback()
                raise
            else:
                self._db_connection.commit()
    
    def close_db_connection(self):
        """Close database connection"""
        with self._db_lock:
            if self._db_connection:
                self._db_connection.close()
                self._db_connection = None
    
    @lru_cache(maxsize=1000)
    def _get_cached_face_encoding(self, face_id: int, encoding_bytes: bytes) -> np.ndarray:
        """Cache face encodings to avoid repeated numpy conversions"""
        return np.frombuffer(encoding_bytes, dtype=np.float64)
    
    def _clear_caches(self):
        """Clear all caches to free memory"""
        self._face_encoding_cache.clear()
        self._image_cache.clear()
        self._get_cached_face_encoding.cache_clear()
    
    def cleanup(self):
        """Clean up resources and close connections"""
        self._clear_caches()
        self.close_db_connection()
    
    def _cleanup_face_crops(self, current_face_crop_path=None):
        """Clean up face crop files and caches"""
        # Clean up current face crop if provided
        if current_face_crop_path and os.path.exists(current_face_crop_path):
            try:
                os.remove(current_face_crop_path)
            except:
                pass  # Ignore cleanup errors
        
        # Clean up all cached face crop files
        for cache_key, cached_path in list(self._image_cache.items()):
            if os.path.exists(cached_path):
                try:
                    os.remove(cached_path)
                except:
                    pass  # Ignore cleanup errors
        
        # Clear caches
        self._clear_caches()
    
    def _setup_window_size_saving(self, root, config_file="gui_config.json"):
        """Set up window size saving functionality"""
        import json
        import tkinter as tk
        
        # Load saved window size
        default_size = "600x500"
        saved_size = default_size
        
        if os.path.exists(config_file):
            try:
                with open(config_file, 'r') as f:
                    config = json.load(f)
                    saved_size = config.get('window_size', default_size)
            except:
                saved_size = default_size
        
        # Calculate center position before showing window
        try:
            width = int(saved_size.split('x')[0])
            height = int(saved_size.split('x')[1])
            x = (root.winfo_screenwidth() // 2) - (width // 2)
            y = (root.winfo_screenheight() // 2) - (height // 2)
            root.geometry(f"{saved_size}+{x}+{y}")
        except tk.TclError:
            # Fallback to default geometry if positioning fails
            root.geometry(saved_size)
        
        # Track previous size to detect actual resizing
        last_size = None
        
        def save_window_size(event=None):
            nonlocal last_size
            if event and event.widget == root:
                current_size = f"{root.winfo_width()}x{root.winfo_height()}"
                # Only save if size actually changed
                if current_size != last_size:
                    last_size = current_size
                    try:
                        config = {'window_size': current_size}
                        with open(config_file, 'w') as f:
                            json.dump(config, f)
                    except:
                        pass  # Ignore save errors
        
        # Bind resize event
        root.bind('<Configure>', save_window_size)
        return saved_size
    
    def init_database(self):
        """Create database tables if they don't exist"""
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            
            # Photos table
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS photos (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    path TEXT UNIQUE NOT NULL,
                    filename TEXT NOT NULL,
                    date_added DATETIME DEFAULT CURRENT_TIMESTAMP,
                    date_taken DATE,
                    processed BOOLEAN DEFAULT 0
                )
            ''')
            
            # People table
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS people (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    first_name TEXT NOT NULL,
                    last_name TEXT NOT NULL,
                    middle_name TEXT,
                    maiden_name TEXT,
                    date_of_birth DATE,
                    created_date DATETIME DEFAULT CURRENT_TIMESTAMP,
                    UNIQUE(first_name, last_name, middle_name, maiden_name, date_of_birth)
                )
            ''')
            
            # Faces table
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS faces (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    photo_id INTEGER NOT NULL,
                    person_id INTEGER,
                    encoding BLOB NOT NULL,
                    location TEXT NOT NULL,
                    confidence REAL DEFAULT 0.0,
                    quality_score REAL DEFAULT 0.0,
                    is_primary_encoding BOOLEAN DEFAULT 0,
                    FOREIGN KEY (photo_id) REFERENCES photos (id),
                    FOREIGN KEY (person_id) REFERENCES people (id)
                )
            ''')
            
            # Person encodings table for multiple encodings per person
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS person_encodings (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    person_id INTEGER NOT NULL,
                    face_id INTEGER NOT NULL,
                    encoding BLOB NOT NULL,
                    quality_score REAL DEFAULT 0.0,
                    created_date DATETIME DEFAULT CURRENT_TIMESTAMP,
                    FOREIGN KEY (person_id) REFERENCES people (id),
                    FOREIGN KEY (face_id) REFERENCES faces (id)
                )
            ''')
            
            # Tags table
            cursor.execute('''
                CREATE TABLE IF NOT EXISTS tags (
                    id INTEGER PRIMARY KEY AUTOINCREMENT,
                    photo_id INTEGER NOT NULL,
                    tag_name TEXT NOT NULL,
                    created_date DATETIME DEFAULT CURRENT_TIMESTAMP,
                    FOREIGN KEY (photo_id) REFERENCES photos (id)
                )
            ''')
            
            # Add indexes for better performance
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_faces_person_id ON faces(person_id)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_faces_photo_id ON faces(photo_id)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_photos_processed ON photos(processed)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_faces_quality ON faces(quality_score)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_person_encodings_person_id ON person_encodings(person_id)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_person_encodings_quality ON person_encodings(quality_score)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_photos_date_taken ON photos(date_taken)')
            cursor.execute('CREATE INDEX IF NOT EXISTS idx_photos_date_added ON photos(date_added)')
            
            # Migration: Add date_taken column to existing photos table if it doesn't exist
            try:
                cursor.execute('ALTER TABLE photos ADD COLUMN date_taken DATE')
                if self.verbose >= 1:
                    print("✅ Added date_taken column to photos table")
            except Exception:
                # Column already exists, ignore
                pass
            
            # Migration: Add date_added column to existing photos table if it doesn't exist
            try:
                cursor.execute('ALTER TABLE photos ADD COLUMN date_added DATETIME DEFAULT CURRENT_TIMESTAMP')
                if self.verbose >= 1:
                    print("✅ Added date_added column to photos table")
            except Exception:
                # Column already exists, ignore
                pass
            
            
        if self.verbose >= 1:
            print(f"✅ Database initialized: {self.db_path}")
    
    def _extract_photo_date(self, photo_path: str) -> Optional[str]:
        """Extract date taken from photo EXIF data"""
        try:
            with Image.open(photo_path) as image:
                exifdata = image.getexif()
                
                # Look for date taken in EXIF tags
                date_tags = [
                    306,  # DateTime
                    36867,  # DateTimeOriginal
                    36868,  # DateTimeDigitized
                ]
                
                for tag_id in date_tags:
                    if tag_id in exifdata:
                        date_str = exifdata[tag_id]
                        if date_str:
                            # Parse EXIF date format (YYYY:MM:DD HH:MM:SS)
                            try:
                                date_obj = datetime.strptime(date_str, '%Y:%m:%d %H:%M:%S')
                                return date_obj.strftime('%Y-%m-%d')
                            except ValueError:
                                # Try alternative format
                                try:
                                    date_obj = datetime.strptime(date_str, '%Y-%m-%d %H:%M:%S')
                                    return date_obj.strftime('%Y-%m-%d')
                                except ValueError:
                                    continue
                
                return None
        except Exception as e:
            if self.verbose >= 2:
                print(f"   ⚠️  Could not extract date from {os.path.basename(photo_path)}: {e}")
            return None
    
    def scan_folder(self, folder_path: str, recursive: bool = True) -> int:
        """Scan folder for photos and add to database"""
        # BREAKPOINT: Set breakpoint here for debugging
        
        
        if not os.path.exists(folder_path):
            print(f"❌ Folder not found: {folder_path}")
            return 0
        
        photo_extensions = {'.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff'}
        
        found_photos = []
        
        # BREAKPOINT: Set breakpoint here for debugging
        
        if recursive:
            for root, dirs, files in os.walk(folder_path):
                for file in files:
                    file_ext = Path(file).suffix.lower()
                    if file_ext in photo_extensions:
                        photo_path = os.path.join(root, file)
                        found_photos.append((photo_path, file))
        else:
            for file in os.listdir(folder_path):
                file_ext = Path(file).suffix.lower()
                if file_ext in photo_extensions:
                    photo_path = os.path.join(folder_path, file)
                    found_photos.append((photo_path, file))
        
        if not found_photos:
            print(f"📁 No photos found in {folder_path}")
            return 0
        
        # Add to database
        # BREAKPOINT: Set breakpoint here for debugging
        
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            added_count = 0
            
            for photo_path, filename in found_photos:
                try:
                    # Extract date taken from EXIF data
                    date_taken = self._extract_photo_date(photo_path)
                    
                    cursor.execute(
                        'INSERT OR IGNORE INTO photos (path, filename, date_taken) VALUES (?, ?, ?)',
                        (photo_path, filename, date_taken)
                    )
                    if cursor.rowcount > 0:
                        added_count += 1
                        if self.verbose >= 2:
                            date_info = f" (taken: {date_taken})" if date_taken else " (no date)"
                            print(f"   📸 Added: {filename}{date_info}")
                    elif self.verbose >= 3:
                        print(f"   📸 Already exists: {filename}")
                except Exception as e:
                    print(f"⚠️  Error adding {filename}: {e}")
        
        
        print(f"📁 Found {len(found_photos)} photos, added {added_count} new photos")
        return added_count
    
    
    def process_faces(self, limit: int = 50, model: str = "hog") -> int:
        """Process unprocessed photos for faces"""
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            
            cursor.execute(
                'SELECT id, path, filename FROM photos WHERE processed = 0 LIMIT ?',
                (limit,)
            )
            unprocessed = cursor.fetchall()
            
            if not unprocessed:
                print("✅ No unprocessed photos found")
                return 0
            
            print(f"🔍 Processing {len(unprocessed)} photos for faces...")
            processed_count = 0
            
            for photo_id, photo_path, filename in unprocessed:
                if not os.path.exists(photo_path):
                    print(f"❌ File not found: {filename}")
                    cursor.execute('UPDATE photos SET processed = 1 WHERE id = ?', (photo_id,))
                    continue
                
                try:
                    # Load image and find faces
                    if self.verbose >= 1:
                        print(f"📸 Processing: {filename}")
                    elif self.verbose == 0:
                        print(".", end="", flush=True)
                    
                    if self.verbose >= 2:
                        print(f"   🔍 Loading image: {photo_path}")
                    
                    image = face_recognition.load_image_file(photo_path)
                    face_locations = face_recognition.face_locations(image, model=model)
                    
                    if face_locations:
                        face_encodings = face_recognition.face_encodings(image, face_locations)
                        if self.verbose >= 1:
                            print(f"   👤 Found {len(face_locations)} faces")
                        
                        # Save faces to database with quality scores
                        for i, (encoding, location) in enumerate(zip(face_encodings, face_locations)):
                            # Calculate face quality score
                            quality_score = self._calculate_face_quality_score(image, location)
                            
                            cursor.execute(
                                'INSERT INTO faces (photo_id, encoding, location, quality_score) VALUES (?, ?, ?, ?)',
                                (photo_id, encoding.tobytes(), str(location), quality_score)
                            )
                            if self.verbose >= 3:
                                print(f"      Face {i+1}: {location} (quality: {quality_score:.2f})")
                    else:
                        if self.verbose >= 1:
                            print(f"   👤 No faces found")
                        elif self.verbose >= 2:
                            print(f"   👤 {filename}: No faces found")
                    
                    # Mark as processed
                    cursor.execute('UPDATE photos SET processed = 1 WHERE id = ?', (photo_id,))
                    processed_count += 1
                    
                except Exception as e:
                    print(f"❌ Error processing {filename}: {e}")
                    cursor.execute('UPDATE photos SET processed = 1 WHERE id = ?', (photo_id,))
        
        if self.verbose == 0:
            print()  # New line after dots
        print(f"✅ Processed {processed_count} photos")
        return processed_count
    
    def identify_faces(self, batch_size: int = 20, show_faces: bool = False, tolerance: float = 0.6, 
                      date_from: str = None, date_to: str = None, date_processed_from: str = None, date_processed_to: str = None) -> int:
        """Interactive face identification with optimized performance"""
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            
            # Build the SQL query with optional date filtering
            query = '''
                SELECT f.id, f.photo_id, p.path, p.filename, f.location 
                FROM faces f 
                JOIN photos p ON f.photo_id = p.id 
                WHERE f.person_id IS NULL 
            '''
            params = []
            
            # Add date taken filtering if specified
            if date_from:
                query += ' AND p.date_taken >= ?'
                params.append(date_from)
            
            if date_to:
                query += ' AND p.date_taken <= ?'
                params.append(date_to)
            
            # Add date processed filtering if specified
            if date_processed_from:
                query += ' AND DATE(p.date_added) >= ?'
                params.append(date_processed_from)
            
            if date_processed_to:
                query += ' AND DATE(p.date_added) <= ?'
                params.append(date_processed_to)
            
            query += ' LIMIT ?'
            params.append(batch_size)
            
            cursor.execute(query, params)
            
            unidentified = cursor.fetchall()
            
            if not unidentified:
                print("🎉 All faces have been identified!")
                return 0
        
        print(f"\n👤 Found {len(unidentified)} unidentified faces")
        print("Commands: [name] = identify, 's' = skip, 'q' = quit, 'list' = show people\n")
        
        # Pre-fetch all needed data to avoid repeated database queries
        print("📊 Pre-fetching data for optimal performance...")
        identify_data_cache = {}
        
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            
            # Pre-fetch all photo paths for unidentified faces
            photo_ids = [face[1] for face in unidentified]  # face[1] is photo_id
            if photo_ids:
                placeholders = ','.join('?' * len(photo_ids))
                cursor.execute(f'SELECT id, path, filename FROM photos WHERE id IN ({placeholders})', photo_ids)
                identify_data_cache['photo_paths'] = {row[0]: {'path': row[1], 'filename': row[2]} for row in cursor.fetchall()}
            
            # Pre-fetch all people names for dropdown
            cursor.execute('SELECT first_name, last_name, date_of_birth FROM people ORDER BY first_name, last_name')
            people = cursor.fetchall()
            identify_data_cache['people_names'] = [f"{first} {last}".strip() for first, last, dob in people]
            # Pre-fetch unique last names for autocomplete (no DB during typing)
            cursor.execute('SELECT DISTINCT last_name FROM people WHERE last_name IS NOT NULL AND TRIM(last_name) <> ""')
            _last_rows = cursor.fetchall()
            identify_data_cache['last_names'] = sorted({r[0].strip() for r in _last_rows if r and isinstance(r[0], str) and r[0].strip()})
        
        print(f"✅ Pre-fetched {len(identify_data_cache.get('photo_paths', {}))} photo paths and {len(identify_data_cache.get('people_names', []))} people names")
        
        identified_count = 0
        
        # Use integrated GUI with image and input
        import tkinter as tk
        from tkinter import ttk, messagebox
        from PIL import Image, ImageTk
        import json
        import os
        
        # Create the main window once
        root = tk.Tk()
        root.title("Face Identification")
        root.resizable(True, True)
        
        # Track window state to prevent multiple destroy calls
        window_destroyed = False
        selected_person_id = None
        force_exit = False
        
        # Track current face crop path for cleanup
        current_face_crop_path = None
        
        # Hide window initially to prevent flash at corner
        root.withdraw()
        
        def save_all_pending_identifications():
            """Save all pending identifications from face_person_names"""
            nonlocal identified_count
            saved_count = 0
            
            for face_id, person_data in face_person_names.items():
                # Handle person data dict format
                if isinstance(person_data, dict):
                    first_name = person_data.get('first_name', '').strip()
                    last_name = person_data.get('last_name', '').strip()
                    date_of_birth = person_data.get('date_of_birth', '').strip()
                    middle_name = person_data.get('middle_name', '').strip()
                    maiden_name = person_data.get('maiden_name', '').strip()
                    
                    # Only save if we have at least a first or last name
                    if first_name or last_name:
                        try:
                            with self.get_db_connection() as conn:
                                cursor = conn.cursor()
                                # Add person if doesn't exist
                                cursor.execute('INSERT OR IGNORE INTO people (first_name, last_name, middle_name, maiden_name, date_of_birth) VALUES (?, ?, ?, ?, ?)', (first_name, last_name, middle_name, maiden_name, date_of_birth))
                                cursor.execute('SELECT id FROM people WHERE first_name = ? AND last_name = ? AND middle_name = ? AND maiden_name = ? AND date_of_birth = ?', (first_name, last_name, middle_name, maiden_name, date_of_birth))
                                result = cursor.fetchone()
                                person_id = result[0] if result else None
                            
                                # Update people cache if new person was added
                                display_name = f"{last_name}, {first_name}" if last_name and first_name else (last_name or first_name)
                                if display_name not in identify_data_cache['people_names']:
                                    identify_data_cache['people_names'].append(display_name)
                                    identify_data_cache['people_names'].sort()  # Keep sorted
                                # Keep last names cache updated in-session
                                if last_name:
                                    if 'last_names' not in identify_data_cache:
                                        identify_data_cache['last_names'] = []
                                    if last_name not in identify_data_cache['last_names']:
                                        identify_data_cache['last_names'].append(last_name)
                                        identify_data_cache['last_names'].sort()
                                
                                # Assign face to person
                                cursor.execute(
                                    'UPDATE faces SET person_id = ? WHERE id = ?',
                                    (person_id, face_id)
                                )
                            
                            # Update person encodings
                            self._update_person_encodings(person_id)
                            saved_count += 1
                            display_name = f"{last_name}, {first_name}" if last_name and first_name else (last_name or first_name)
                            print(f"✅ Saved identification: {display_name}")
                            
                        except Exception as e:
                            display_name = f"{last_name}, {first_name}" if last_name and first_name else (last_name or first_name)
                            print(f"❌ Error saving identification for {display_name}: {e}")
                else:
                    # Handle legacy string format - skip for now as it doesn't have complete data
                    pass
            
            if saved_count > 0:
                identified_count += saved_count
                print(f"💾 Saved {saved_count} pending identifications")
            
            return saved_count
        
        # Set up protocol handler for window close button (X)
        def on_closing():
            nonlocal command, waiting_for_input, window_destroyed, current_face_crop_path, force_exit
            
            # First check for selected similar faces without person name
            if not validate_navigation():
                return  # Cancel close
            
            # Check if there are pending identifications (faces with complete data but not yet saved)
            pending_identifications = {}
            for k, v in face_person_names.items():
                if k not in face_status or face_status[k] != 'identified':
                    # Handle person data dict format
                    if isinstance(v, dict):
                        first_name = v.get('first_name', '').strip()
                        last_name = v.get('last_name', '').strip()
                        date_of_birth = v.get('date_of_birth', '').strip()
                        
                        # Check if we have complete data (both first and last name, plus date of birth)
                        if first_name and last_name and date_of_birth:
                            pending_identifications[k] = v
                    else:
                        # Handle legacy string format - not considered complete without date of birth
                        pass
            
            if pending_identifications:
                # Ask user if they want to save pending identifications
                result = messagebox.askyesnocancel(
                    "Save Pending Identifications?",
                    f"You have {len(pending_identifications)} pending identifications.\n\n"
                    "Do you want to save them before closing?\n\n"
                    "• Yes: Save all pending identifications and close\n"
                    "• No: Close without saving\n"
                    "• Cancel: Return to identification"
                )
                
                if result is True:  # Yes - Save and close
                    save_all_pending_identifications()
                    command = 'q'
                    waiting_for_input = False
                elif result is False:  # No - Close without saving
                    command = 'q'
                    waiting_for_input = False
                else:  # Cancel - Don't close
                    return
            
            # Clean up face crops and caches
            self._cleanup_face_crops(current_face_crop_path)
            self.close_db_connection()
            
            if not window_destroyed:
                window_destroyed = True
                try:
                    root.destroy()
                except tk.TclError:
                    pass  # Window already destroyed
            
            # Force process termination
            force_exit = True
            root.quit()
        
        root.protocol("WM_DELETE_WINDOW", on_closing)
        
        # Set up window size saving
        saved_size = self._setup_window_size_saving(root)
        
        # Create main frame
        main_frame = ttk.Frame(root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # Configure grid weights
        root.columnconfigure(0, weight=1)
        root.rowconfigure(0, weight=1)
        main_frame.columnconfigure(0, weight=1)  # Left panel
        main_frame.columnconfigure(1, weight=1)  # Right panel for similar faces
        # Configure row weights to minimize spacing around Unique checkbox
        main_frame.rowconfigure(2, weight=0)  # Unique checkbox row - no expansion
        main_frame.rowconfigure(3, weight=1)  # Main panels row - expandable
        
        # Photo info
        info_label = ttk.Label(main_frame, text="", font=("Arial", 10, "bold"))
        info_label.grid(row=0, column=0, columnspan=2, pady=(0, 10), sticky=tk.W)
        
        # Calendar dialog function for date filter
        def open_date_calendar(date_var, title):
            """Open a visual calendar dialog to select date"""
            from datetime import datetime, date, timedelta
            import calendar
            
            # Create calendar window
            calendar_window = tk.Toplevel(root)
            calendar_window.title(title)
            calendar_window.resizable(False, False)
            calendar_window.transient(root)
            calendar_window.grab_set()
            
            # Calculate center position before showing the window
            window_width = 400
            window_height = 400
            screen_width = calendar_window.winfo_screenwidth()
            screen_height = calendar_window.winfo_screenheight()
            x = (screen_width // 2) - (window_width // 2)
            y = (screen_height // 2) - (window_height // 2)
            
            # Set geometry with center position before showing
            calendar_window.geometry(f"{window_width}x{window_height}+{x}+{y}")
            
            # Calendar variables
            current_date = datetime.now()
            
            # Check if there's already a date selected
            existing_date_str = date_var.get().strip()
            if existing_date_str:
                try:
                    existing_date = datetime.strptime(existing_date_str, '%Y-%m-%d').date()
                    display_year = existing_date.year
                    display_month = existing_date.month
                    selected_date = existing_date
                except ValueError:
                    # If existing date is invalid, use current date
                    display_year = current_date.year
                    display_month = current_date.month
                    selected_date = None
            else:
                # Default to current date
                display_year = current_date.year
                display_month = current_date.month
                selected_date = None
            
            # Month names
            month_names = ["January", "February", "March", "April", "May", "June",
                          "July", "August", "September", "October", "November", "December"]
            
            # Create custom style for calendar buttons
            style = ttk.Style()
            style.configure("Calendar.TButton", padding=(2, 2))
            style.map("Calendar.TButton",
                     background=[("active", "#e1e1e1")],
                     relief=[("pressed", "sunken")])
            
            # Main frame
            main_cal_frame = ttk.Frame(calendar_window, padding="10")
            main_cal_frame.pack(fill=tk.BOTH, expand=True)
            
            # Header frame with navigation
            header_frame = ttk.Frame(main_cal_frame)
            header_frame.pack(fill=tk.X, pady=(0, 10))
            
            # Month/Year display and navigation
            nav_frame = ttk.Frame(header_frame)
            nav_frame.pack()
            
            # Month/Year label (created once, updated later)
            month_year_label = ttk.Label(nav_frame, text="", font=("Arial", 12, "bold"))
            month_year_label.pack(side=tk.LEFT, padx=10)
            
            def update_calendar():
                """Update the calendar display"""
                # Update month/year label
                month_year_label.configure(text=f"{month_names[display_month-1]} {display_year}")
                
                # Clear existing calendar
                for widget in calendar_frame.winfo_children():
                    widget.destroy()
                
                # Get calendar data
                cal = calendar.monthcalendar(display_year, display_month)
                
                # Day headers
                day_headers = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
                for i, day in enumerate(day_headers):
                    header_label = ttk.Label(calendar_frame, text=day, font=("Arial", 10, "bold"))
                    header_label.grid(row=0, column=i, padx=2, pady=2, sticky="nsew")
                
                # Calendar days
                for week_num, week in enumerate(cal):
                    for day_num, day in enumerate(week):
                        if day == 0:
                            # Empty cell
                            empty_label = ttk.Label(calendar_frame, text="")
                            empty_label.grid(row=week_num+1, column=day_num, padx=2, pady=2, sticky="nsew")
                        else:
                            # Day button
                            day_date = date(display_year, display_month, day)
                            is_selected = selected_date == day_date
                            is_today = day_date == current_date.date()
                            
                            # Button text and style
                            button_text = str(day)
                            if is_today:
                                button_text = f"•{day}•"  # Mark today
                            
                            day_btn = ttk.Button(calendar_frame, text=button_text, 
                                               style="Calendar.TButton" if not is_selected else "Calendar.TButton",
                                               command=lambda d=day_date: select_date(d))
                            day_btn.grid(row=week_num+1, column=day_num, padx=2, pady=2, sticky="nsew")
                            
                            # Highlight selected date
                            if is_selected:
                                day_btn.configure(style="Calendar.TButton")
                                # Add visual indication of selection
                                day_btn.configure(text=f"[{day}]")
            
            def select_date(selected_day):
                """Select a date and close calendar"""
                nonlocal selected_date
                selected_date = selected_day
                date_var.set(selected_day.strftime('%Y-%m-%d'))
                calendar_window.destroy()
            
            def prev_month():
                nonlocal display_month, display_year
                display_month -= 1
                if display_month < 1:
                    display_month = 12
                    display_year -= 1
                update_calendar()
            
            def next_month():
                nonlocal display_month, display_year
                display_month += 1
                if display_month > 12:
                    display_month = 1
                    display_year += 1
                update_calendar()
            
            def prev_year():
                nonlocal display_year
                display_year -= 1
                update_calendar()
            
            def next_year():
                nonlocal display_year
                display_year += 1
                update_calendar()
            
            # Navigation buttons
            prev_year_btn = ttk.Button(nav_frame, text="<<", width=3, command=prev_year)
            prev_year_btn.pack(side=tk.LEFT)
            
            prev_month_btn = ttk.Button(nav_frame, text="<", width=3, command=prev_month)
            prev_month_btn.pack(side=tk.LEFT, padx=(5, 0))
            
            next_month_btn = ttk.Button(nav_frame, text=">", width=3, command=next_month)
            next_month_btn.pack(side=tk.LEFT, padx=(5, 0))
            
            next_year_btn = ttk.Button(nav_frame, text=">>", width=3, command=next_year)
            next_year_btn.pack(side=tk.LEFT)
            
            # Calendar grid frame
            calendar_frame = ttk.Frame(main_cal_frame)
            calendar_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
            
            # Configure grid weights
            for i in range(7):
                calendar_frame.columnconfigure(i, weight=1)
            for i in range(7):
                calendar_frame.rowconfigure(i, weight=1)
            
            # Buttons frame
            buttons_frame = ttk.Frame(main_cal_frame)
            buttons_frame.pack(fill=tk.X)
            
            def clear_date():
                """Clear the selected date"""
                date_var.set("")
                calendar_window.destroy()
            
            # Clear button
            clear_btn = ttk.Button(buttons_frame, text="Clear", command=clear_date)
            clear_btn.pack(side=tk.LEFT)
            
            # Cancel button
            cancel_btn = ttk.Button(buttons_frame, text="Cancel", command=calendar_window.destroy)
            cancel_btn.pack(side=tk.RIGHT)
            
            # Initial calendar display
            update_calendar()
        
        # Unique faces only checkbox variable (must be defined before widgets that use it)
        unique_faces_var = tk.BooleanVar()
        
        # Define update_similar_faces function first - reusing auto-match display logic
        def update_similar_faces():
            """Update the similar faces panel when compare is enabled - reuses auto-match display logic"""
            nonlocal similar_faces_data, similar_face_vars, similar_face_images, similar_face_crops, face_selection_states
            
            # Note: Selection states are now saved automatically via callbacks (auto-match style)
            
            # Clear existing similar faces
            for widget in similar_scrollable_frame.winfo_children():
                widget.destroy()
            similar_face_vars.clear()
            similar_face_images.clear()
            
            # Clean up existing face crops
            for crop_path in similar_face_crops:
                try:
                    if os.path.exists(crop_path):
                        os.remove(crop_path)
                except:
                    pass
            similar_face_crops.clear()
            
            if compare_var.get():
                # Use the same filtering and sorting logic as auto-match (no unique faces filter for similar faces)
                unidentified_similar_faces = self._get_filtered_similar_faces(face_id, tolerance, include_same_photo=False, face_status=face_status)
                
                if unidentified_similar_faces:
                    # Get current face_id for selection state management
                    current_face_id = original_faces[i][0]  # Get current face_id
                    
                    # Reuse auto-match display logic for similar faces
                    self._display_similar_faces_in_panel(similar_scrollable_frame, unidentified_similar_faces, 
                                                       similar_face_vars, similar_face_images, similar_face_crops,
                                                       current_face_id, face_selection_states, identify_data_cache)
                    
                    # Note: Selection states are now restored automatically during checkbox creation (auto-match style)
                else:
                    # No similar unidentified faces found
                    no_faces_label = ttk.Label(similar_scrollable_frame, text="No similar unidentified faces found", 
                                             foreground="gray", font=("Arial", 10))
                    no_faces_label.pack(pady=20)
            else:
                # Compare disabled - clear the panel
                clear_label = ttk.Label(similar_scrollable_frame, text="Enable 'Compare with similar faces' to see matches", 
                                      foreground="gray", font=("Arial", 10))
                clear_label.pack(pady=20)
            
            # Update button states based on compare checkbox and list contents
            update_select_clear_buttons_state()
        
        # Unique faces change handler (must be defined before checkbox that uses it)
        def on_unique_faces_change():
            """Handle unique faces checkbox change"""
            nonlocal original_faces, i
            
            if unique_faces_var.get():
                # Show progress message
                print("🔄 Applying unique faces filter...")
                root.update()  # Update UI to show the message
                
                # Apply unique faces filtering to the main face list
                try:
                    original_faces = self._filter_unique_faces_from_list(original_faces)
                    print(f"✅ Filter applied: {len(original_faces)} unique faces remaining")
                except Exception as e:
                    print(f"⚠️  Error applying filter: {e}")
                    # Revert checkbox state
                    unique_faces_var.set(False)
                    return
            else:
                # Reload the original unfiltered face list
                print("🔄 Reloading all faces...")
                root.update()  # Update UI to show the message
                
                with self.get_db_connection() as conn:
                    cursor = conn.cursor()
                    query = '''
                        SELECT f.id, f.photo_id, p.path, p.filename, f.location 
                        FROM faces f 
                        JOIN photos p ON f.photo_id = p.id 
                        WHERE f.person_id IS NULL 
                    '''
                    params = []
                    
                    # Add date taken filtering if specified
                    if date_from:
                        query += ' AND p.date_taken >= ?'
                        params.append(date_from)
                    
                    if date_to:
                        query += ' AND p.date_taken <= ?'
                        params.append(date_to)
                    
                    # Add date processed filtering if specified
                    if date_processed_from:
                        query += ' AND DATE(p.date_added) >= ?'
                        params.append(date_processed_from)
                    
                    if date_processed_to:
                        query += ' AND DATE(p.date_added) <= ?'
                        params.append(date_processed_to)
                    
                    query += ' ORDER BY f.id'
                    cursor.execute(query, params)
                    original_faces = list(cursor.fetchall())
                
                print(f"✅ Reloaded: {len(original_faces)} faces")
            
            # Reset to first face and update display
            i = 0
            update_similar_faces()

        # Compare checkbox variable and handler (must be defined before widgets that use it)
        compare_var = tk.BooleanVar()
        
        def on_compare_change():
            """Handle compare checkbox change"""
            update_similar_faces()
            update_select_clear_buttons_state()

        # Date filter controls
        date_filter_frame = ttk.LabelFrame(main_frame, text="Filter", padding="5")
        date_filter_frame.grid(row=1, column=0, pady=(0, 0), sticky=tk.W)
        date_filter_frame.columnconfigure(1, weight=0)
        date_filter_frame.columnconfigure(4, weight=0)
        
        # Date from
        ttk.Label(date_filter_frame, text="Taken date: from").grid(row=0, column=0, sticky=tk.W, padx=(0, 5))
        date_from_var = tk.StringVar(value=date_from or "")
        date_from_entry = ttk.Entry(date_filter_frame, textvariable=date_from_var, width=10, state='readonly')
        date_from_entry.grid(row=0, column=1, sticky=tk.W, padx=(0, 5))
        
        # Calendar button for date from
        def open_calendar_from():
            open_date_calendar(date_from_var, "Select Start Date")
        
        calendar_from_btn = ttk.Button(date_filter_frame, text="📅", width=3, command=open_calendar_from)
        calendar_from_btn.grid(row=0, column=2, padx=(0, 10))
        
        # Date to
        ttk.Label(date_filter_frame, text="to").grid(row=0, column=3, sticky=tk.W, padx=(0, 5))
        date_to_var = tk.StringVar(value=date_to or "")
        date_to_entry = ttk.Entry(date_filter_frame, textvariable=date_to_var, width=10, state='readonly')
        date_to_entry.grid(row=0, column=4, sticky=tk.W, padx=(0, 5))
        
        # Calendar button for date to
        def open_calendar_to():
            open_date_calendar(date_to_var, "Select End Date")
        
        calendar_to_btn = ttk.Button(date_filter_frame, text="📅", width=3, command=open_calendar_to)
        calendar_to_btn.grid(row=0, column=5, padx=(0, 10))
        
        # Apply filter button
        def apply_date_filter():
            nonlocal date_from, date_to
            date_from = date_from_var.get().strip() or None
            date_to = date_to_var.get().strip() or None
            date_processed_from = date_processed_from_var.get().strip() or None
            date_processed_to = date_processed_to_var.get().strip() or None
            
            # Reload faces with new date filter
            with self.get_db_connection() as conn:
                cursor = conn.cursor()
                
                # Build the SQL query with optional date filtering
                query = '''
                    SELECT f.id, f.photo_id, p.path, p.filename, f.location 
                    FROM faces f 
                    JOIN photos p ON f.photo_id = p.id 
                    WHERE f.person_id IS NULL 
                '''
                params = []
                
                # Add date taken filtering if specified
                if date_from:
                    query += ' AND p.date_taken >= ?'
                    params.append(date_from)
                
                if date_to:
                    query += ' AND p.date_taken <= ?'
                    params.append(date_to)
                
                # Add date processed filtering if specified
                if date_processed_from:
                    query += ' AND DATE(p.date_added) >= ?'
                    params.append(date_processed_from)
                
                if date_processed_to:
                    query += ' AND DATE(p.date_added) <= ?'
                    params.append(date_processed_to)
                
                query += ' LIMIT ?'
                params.append(batch_size)
                
                cursor.execute(query, params)
                unidentified = cursor.fetchall()
            
            if not unidentified:
                messagebox.showinfo("No Faces Found", "No unidentified faces found with the current date filters.")
                return
            
            # Update the global unidentified list and reset position
            nonlocal current_pos, total_unidentified
            current_pos = 0
            total_unidentified = len(unidentified)
            
            # Reset to first face - display will update when user navigates
            if len(unidentified) > 0:
                # Reset to first face
                current_pos = 0
                # The display will be updated when the user navigates or when the window is shown
            
            # Build filter description
            filters_applied = []
            if date_from or date_to:
                taken_filter = f"taken: {date_from or 'any'} to {date_to or 'any'}"
                filters_applied.append(taken_filter)
            if date_processed_from or date_processed_to:
                processed_filter = f"processed: {date_processed_from or 'any'} to {date_processed_to or 'any'}"
                filters_applied.append(processed_filter)
            
            filter_desc = " | ".join(filters_applied) if filters_applied else "no filters"
            
            print(f"📅 Applied filters: {filter_desc}")
            print(f"👤 Found {len(unidentified)} unidentified faces with date filters")
            print("💡 Navigate to refresh the display with filtered faces")
        
        # Apply filter button (inside filter frame)
        apply_filter_btn = ttk.Button(date_filter_frame, text="Apply Filter", command=apply_date_filter)
        apply_filter_btn.grid(row=0, column=6, padx=(10, 0))
        
        # Date processed filter (second row)
        ttk.Label(date_filter_frame, text="Processed date: from").grid(row=1, column=0, sticky=tk.W, padx=(0, 5), pady=(10, 0))
        date_processed_from_var = tk.StringVar()
        date_processed_from_entry = ttk.Entry(date_filter_frame, textvariable=date_processed_from_var, width=10, state='readonly')
        date_processed_from_entry.grid(row=1, column=1, sticky=tk.W, padx=(0, 5), pady=(10, 0))
        
        # Calendar button for date processed from
        def open_calendar_processed_from():
            open_date_calendar(date_processed_from_var, "Select Processing Start Date")
        
        calendar_processed_from_btn = ttk.Button(date_filter_frame, text="📅", width=3, command=open_calendar_processed_from)
        calendar_processed_from_btn.grid(row=1, column=2, padx=(0, 10), pady=(10, 0))
        
        # Date processed to
        ttk.Label(date_filter_frame, text="to").grid(row=1, column=3, sticky=tk.W, padx=(0, 5), pady=(10, 0))
        date_processed_to_var = tk.StringVar()
        date_processed_to_entry = ttk.Entry(date_filter_frame, textvariable=date_processed_to_var, width=10, state='readonly')
        date_processed_to_entry.grid(row=1, column=4, sticky=tk.W, padx=(0, 5), pady=(10, 0))
        
        # Calendar button for date processed to
        def open_calendar_processed_to():
            open_date_calendar(date_processed_to_var, "Select Processing End Date")
        
        calendar_processed_to_btn = ttk.Button(date_filter_frame, text="📅", width=3, command=open_calendar_processed_to)
        calendar_processed_to_btn.grid(row=1, column=5, padx=(0, 10), pady=(10, 0))
        
        # Unique checkbox under the filter frame
        unique_faces_checkbox = ttk.Checkbutton(main_frame, text="Unique faces only", 
                                              variable=unique_faces_var, command=on_unique_faces_change)
        unique_faces_checkbox.grid(row=2, column=0, sticky=tk.W, padx=(0, 5), pady=0)
        
        # Compare checkbox on the same row as Unique
        compare_checkbox = ttk.Checkbutton(main_frame, text="Compare similar faces", variable=compare_var, 
                                         command=on_compare_change)
        compare_checkbox.grid(row=2, column=1, sticky=tk.W, padx=(5, 10), pady=0)
        
        # Left panel for main face
        left_panel = ttk.Frame(main_frame)
        left_panel.grid(row=3, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(0, 5), pady=(0, 0))
        left_panel.columnconfigure(0, weight=1)
        
        # Right panel for similar faces
        right_panel = ttk.LabelFrame(main_frame, text="Similar Faces", padding="5")
        right_panel.grid(row=3, column=1, columnspan=2, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(5, 0))
        right_panel.columnconfigure(0, weight=1)
        right_panel.rowconfigure(0, weight=1)  # Make right panel expandable vertically
        
        # Image display (left panel)
        image_frame = ttk.Frame(left_panel)
        image_frame.grid(row=0, column=0, pady=(0, 10), sticky=(tk.W, tk.E, tk.N, tk.S))
        image_frame.columnconfigure(0, weight=1)
        image_frame.rowconfigure(0, weight=1)
        
        # Create canvas for image display
        style = ttk.Style()
        canvas_bg_color = style.lookup('TFrame', 'background') or '#d9d9d9'
        canvas = tk.Canvas(image_frame, width=400, height=400, bg=canvas_bg_color, highlightthickness=0)
        canvas.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # Input section (left panel)
        input_frame = ttk.LabelFrame(left_panel, text="Person Identification", padding="10")
        input_frame.grid(row=1, column=0, pady=(10, 0), sticky=(tk.W, tk.E))
        input_frame.columnconfigure(1, weight=1)
        input_frame.columnconfigure(3, weight=1)
        input_frame.columnconfigure(5, weight=1)
        input_frame.columnconfigure(7, weight=1)
        
        # First name input
        ttk.Label(input_frame, text="First name:").grid(row=0, column=0, sticky=tk.W, padx=(0, 10))
        first_name_var = tk.StringVar()
        first_name_entry = ttk.Entry(input_frame, textvariable=first_name_var, width=12)
        first_name_entry.grid(row=0, column=1, sticky=(tk.W, tk.E), padx=(0, 5))
        
        # Red asterisk for required first name field (overlayed, no layout impact)
        first_name_asterisk = ttk.Label(root, text="*", foreground="red")
        first_name_asterisk.place_forget()
        
        # Last name input (with live listbox autocomplete)
        ttk.Label(input_frame, text="Last name:").grid(row=0, column=2, sticky=tk.W, padx=(10, 10))
        last_name_var = tk.StringVar()
        last_name_entry = ttk.Entry(input_frame, textvariable=last_name_var, width=12)
        last_name_entry.grid(row=0, column=3, sticky=(tk.W, tk.E), padx=(0, 5))
        
        # Red asterisk for required last name field (overlayed, no layout impact)
        last_name_asterisk = ttk.Label(root, text="*", foreground="red")
        last_name_asterisk.place_forget()

        def _position_required_asterisks(event=None):
            """Position required asterisks at top-right corner of their entries."""
            try:
                root.update_idletasks()
                input_frame.update_idletasks()
                first_name_entry.update_idletasks()
                last_name_entry.update_idletasks()
                date_of_birth_entry.update_idletasks()
                
                # Get absolute coordinates relative to root window
                first_root_x = first_name_entry.winfo_rootx()
                first_root_y = first_name_entry.winfo_rooty()
                first_w = first_name_entry.winfo_width()
                root_x = root.winfo_rootx()
                root_y = root.winfo_rooty()
                
                # First name asterisk at the true top-right corner of entry
                first_name_asterisk.place(x=first_root_x - root_x + first_w + 2, y=first_root_y - root_y - 2, anchor='nw')
                first_name_asterisk.lift()
                
                # Last name asterisk at the true top-right corner of entry
                last_root_x = last_name_entry.winfo_rootx()
                last_root_y = last_name_entry.winfo_rooty()
                last_w = last_name_entry.winfo_width()
                last_name_asterisk.place(x=last_root_x - root_x + last_w + 2, y=last_root_y - root_y - 2, anchor='nw')
                last_name_asterisk.lift()

                # Date of birth asterisk at the true top-right corner of date entry
                dob_root_x = date_of_birth_entry.winfo_rootx()
                dob_root_y = date_of_birth_entry.winfo_rooty()
                dob_w = date_of_birth_entry.winfo_width()
                date_asterisk.place(x=dob_root_x - root_x + dob_w + 2, y=dob_root_y - root_y - 2, anchor='nw')
                date_asterisk.lift()
            except Exception:
                pass

        # Bind repositioning after all entries are created
        def _bind_asterisk_positioning():
            try:
                input_frame.bind('<Configure>', _position_required_asterisks)
                first_name_entry.bind('<Configure>', _position_required_asterisks)
                last_name_entry.bind('<Configure>', _position_required_asterisks)
                date_of_birth_entry.bind('<Configure>', _position_required_asterisks)
                _position_required_asterisks()
            except Exception:
                pass
        root.after(100, _bind_asterisk_positioning)
        
        # Create listbox for suggestions (as overlay attached to root, not clipped by frames)
        last_name_listbox = tk.Listbox(root, height=8)
        last_name_listbox.place_forget()  # Hide initially
        
        def _show_suggestions():
            """Show filtered suggestions in listbox"""
            all_last_names = identify_data_cache.get('last_names', [])
            typed = last_name_var.get().strip()
            
            if not typed:
                filtered = []  # Show nothing if no typing
            else:
                low = typed.lower()
                # Only show names that start with the typed text
                filtered = [n for n in all_last_names if n.lower().startswith(low)][:10]
            
            # Update listbox
            last_name_listbox.delete(0, tk.END)
            for name in filtered:
                last_name_listbox.insert(tk.END, name)
            
            # Show listbox if we have suggestions (as overlay)
            if filtered:
                # Ensure geometry is up to date before positioning
                root.update_idletasks()
                # Absolute coordinates of entry relative to screen
                entry_root_x = last_name_entry.winfo_rootx()
                entry_root_y = last_name_entry.winfo_rooty()
                entry_height = last_name_entry.winfo_height()
                # Convert to coordinates relative to root
                root_origin_x = root.winfo_rootx()
                root_origin_y = root.winfo_rooty()
                place_x = entry_root_x - root_origin_x
                place_y = entry_root_y - root_origin_y + entry_height
                place_width = last_name_entry.winfo_width()
                # Calculate how many rows fit to bottom of window
                available_px = max(60, root.winfo_height() - place_y - 8)
                # Approximate row height in pixels; 18 is a reasonable default for Tk listbox rows
                approx_row_px = 18
                rows_fit = max(3, min(len(filtered), available_px // approx_row_px))
                last_name_listbox.configure(height=rows_fit)
                last_name_listbox.place(x=place_x, y=place_y, width=place_width)
                last_name_listbox.selection_clear(0, tk.END)
                last_name_listbox.selection_set(0)  # Select first item
                last_name_listbox.activate(0)  # Activate first item
            else:
                last_name_listbox.place_forget()
        
        def _hide_suggestions():
            """Hide the suggestions listbox"""
            last_name_listbox.place_forget()
        
        def _on_listbox_select(event=None):
            """Handle listbox selection and hide list"""
            selection = last_name_listbox.curselection()
            if selection:
                selected_name = last_name_listbox.get(selection[0])
                last_name_var.set(selected_name)
            _hide_suggestions()
            last_name_entry.focus_set()

        def _on_listbox_click(event):
            """Handle mouse click selection"""
            try:
                index = last_name_listbox.nearest(event.y)
                if index is not None and index >= 0:
                    selected_name = last_name_listbox.get(index)
                    last_name_var.set(selected_name)
            except:
                pass
            _hide_suggestions()
            last_name_entry.focus_set()
            return 'break'
        
        def _on_key_press(event):
            """Handle key navigation in entry"""
            nonlocal navigating_to_listbox, escape_pressed, enter_pressed
            if event.keysym == 'Down':
                if last_name_listbox.winfo_ismapped():
                    navigating_to_listbox = True
                    last_name_listbox.focus_set()
                    last_name_listbox.selection_clear(0, tk.END)
                    last_name_listbox.selection_set(0)
                    last_name_listbox.activate(0)
                return 'break'
            elif event.keysym == 'Escape':
                escape_pressed = True
                _hide_suggestions()
                return 'break'
            elif event.keysym == 'Return':
                enter_pressed = True
                return 'break'
        
        def _on_listbox_key(event):
            """Handle key navigation in listbox"""
            nonlocal enter_pressed, escape_pressed
            if event.keysym == 'Return':
                enter_pressed = True
                _on_listbox_select(event)
                return 'break'
            elif event.keysym == 'Escape':
                escape_pressed = True
                _hide_suggestions()
                last_name_entry.focus_set()
                return 'break'
            elif event.keysym == 'Up':
                selection = last_name_listbox.curselection()
                if selection and selection[0] > 0:
                    # Move up in listbox
                    last_name_listbox.selection_clear(0, tk.END)
                    last_name_listbox.selection_set(selection[0] - 1)
                    last_name_listbox.see(selection[0] - 1)
                else:
                    # At top, go back to entry field
                    _hide_suggestions()
                    last_name_entry.focus_set()
                return 'break'
            elif event.keysym == 'Down':
                selection = last_name_listbox.curselection()
                max_index = last_name_listbox.size() - 1
                if selection and selection[0] < max_index:
                    # Move down in listbox
                    last_name_listbox.selection_clear(0, tk.END)
                    last_name_listbox.selection_set(selection[0] + 1)
                    last_name_listbox.see(selection[0] + 1)
                return 'break'
        
        # Track if we're navigating to listbox to prevent auto-hide
        navigating_to_listbox = False
        escape_pressed = False
        enter_pressed = False
        
        def _safe_hide_suggestions():
            """Hide suggestions only if not navigating to listbox"""
            nonlocal navigating_to_listbox
            if not navigating_to_listbox:
                _hide_suggestions()
            navigating_to_listbox = False
        
        def _safe_show_suggestions():
            """Show suggestions only if escape or enter wasn't just pressed"""
            nonlocal escape_pressed, enter_pressed
            if not escape_pressed and not enter_pressed:
                _show_suggestions()
            escape_pressed = False
            enter_pressed = False
        
        # Bind events
        last_name_entry.bind('<KeyRelease>', lambda e: _safe_show_suggestions())
        last_name_entry.bind('<KeyPress>', _on_key_press)
        last_name_entry.bind('<FocusOut>', lambda e: root.after(150, _safe_hide_suggestions))  # Delay to allow listbox clicks
        last_name_listbox.bind('<Button-1>', _on_listbox_click)
        last_name_listbox.bind('<KeyPress>', _on_listbox_key)
        last_name_listbox.bind('<Double-Button-1>', _on_listbox_click)
        
        # Middle name input
        ttk.Label(input_frame, text="Middle name:").grid(row=0, column=4, sticky=tk.W, padx=(10, 10))
        middle_name_var = tk.StringVar()
        middle_name_entry = ttk.Entry(input_frame, textvariable=middle_name_var, width=12)
        middle_name_entry.grid(row=0, column=5, sticky=(tk.W, tk.E), padx=(0, 5))
        
        # Date of birth input with calendar chooser
        ttk.Label(input_frame, text="Date of birth:").grid(row=1, column=0, sticky=tk.W, padx=(0, 10))
        date_of_birth_var = tk.StringVar()
        
        # Create a frame for the date picker
        date_frame = ttk.Frame(input_frame)
        date_frame.grid(row=1, column=1, sticky=(tk.W, tk.E), padx=(0, 10))
        
        # Maiden name input
        ttk.Label(input_frame, text="Maiden name:").grid(row=1, column=2, sticky=tk.W, padx=(10, 10))
        maiden_name_var = tk.StringVar()
        maiden_name_entry = ttk.Entry(input_frame, textvariable=maiden_name_var, width=12)
        maiden_name_entry.grid(row=1, column=3, sticky=(tk.W, tk.E), padx=(0, 5))
        
        # Date display entry (read-only)
        date_of_birth_entry = ttk.Entry(date_frame, textvariable=date_of_birth_var, width=12, state='readonly')
        date_of_birth_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
        
        # Red asterisk for required date of birth field (overlayed, no layout impact)
        date_asterisk = ttk.Label(root, text="*", foreground="red")
        date_asterisk.place_forget()
        
        # Calendar button
        calendar_btn = ttk.Button(date_frame, text="📅", width=3, command=lambda: open_calendar())
        calendar_btn.pack(side=tk.RIGHT, padx=(15, 0))
        
        def open_calendar():
            """Open a visual calendar dialog to select date of birth"""
            from datetime import datetime, date, timedelta
            import calendar
            
            # Create calendar window
            calendar_window = tk.Toplevel(root)
            calendar_window.title("Select Date of Birth")
            calendar_window.resizable(False, False)
            calendar_window.transient(root)
            calendar_window.grab_set()
            
            # Calculate center position before showing the window
            window_width = 400
            window_height = 400
            screen_width = calendar_window.winfo_screenwidth()
            screen_height = calendar_window.winfo_screenheight()
            x = (screen_width // 2) - (window_width // 2)
            y = (screen_height // 2) - (window_height // 2)
            
            # Set geometry with center position before showing
            calendar_window.geometry(f"{window_width}x{window_height}+{x}+{y}")
            
            # Calendar variables
            current_date = datetime.now()
            
            # Check if there's already a date selected
            existing_date_str = date_of_birth_var.get().strip()
            if existing_date_str:
                try:
                    existing_date = datetime.strptime(existing_date_str, '%Y-%m-%d').date()
                    display_year = existing_date.year
                    display_month = existing_date.month
                    selected_date = existing_date
                except ValueError:
                    # If existing date is invalid, use default
                    display_year = current_date.year - 25
                    display_month = 1
                    selected_date = None
            else:
                # Default to 25 years ago
                display_year = current_date.year - 25
                display_month = 1
                selected_date = None
            
            # Month names
            month_names = ["January", "February", "March", "April", "May", "June",
                          "July", "August", "September", "October", "November", "December"]
            
            # Configure custom styles for better visual highlighting
            style = ttk.Style()
            
            # Selected date style - bright blue background with white text
            style.configure("Selected.TButton", 
                          background="#0078d4", 
                          foreground="white",
                          font=("Arial", 9, "bold"),
                          relief="raised",
                          borderwidth=2)
            style.map("Selected.TButton",
                     background=[("active", "#106ebe")],
                     relief=[("pressed", "sunken")])
            
            # Today's date style - orange background
            style.configure("Today.TButton",
                          background="#ff8c00",
                          foreground="white", 
                          font=("Arial", 9, "bold"),
                          relief="raised",
                          borderwidth=1)
            style.map("Today.TButton",
                     background=[("active", "#e67e00")],
                     relief=[("pressed", "sunken")])
            
            # Calendar-specific normal button style (don't affect global TButton)
            style.configure("Calendar.TButton",
                          font=("Arial", 9),
                          relief="flat")
            style.map("Calendar.TButton",
                     background=[("active", "#e1e1e1")],
                     relief=[("pressed", "sunken")])
            
            # Main frame
            main_cal_frame = ttk.Frame(calendar_window, padding="10")
            main_cal_frame.pack(fill=tk.BOTH, expand=True)
            
            # Header frame with navigation
            header_frame = ttk.Frame(main_cal_frame)
            header_frame.pack(fill=tk.X, pady=(0, 10))
            
            # Month/Year display and navigation
            nav_frame = ttk.Frame(header_frame)
            nav_frame.pack()
            
            def update_calendar():
                """Update the calendar display"""
                # Clear existing calendar
                for widget in calendar_frame.winfo_children():
                    widget.destroy()
                
                # Update header
                month_year_label.config(text=f"{month_names[display_month-1]} {display_year}")
                
                # Get calendar data
                cal = calendar.monthcalendar(display_year, display_month)
                
                # Day headers
                day_headers = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
                for i, day in enumerate(day_headers):
                    label = ttk.Label(calendar_frame, text=day, font=("Arial", 9, "bold"))
                    label.grid(row=0, column=i, padx=1, pady=1, sticky="nsew")
                
                # Calendar days
                for week_num, week in enumerate(cal):
                    for day_num, day in enumerate(week):
                        if day == 0:
                            # Empty cell
                            label = ttk.Label(calendar_frame, text="")
                            label.grid(row=week_num+1, column=day_num, padx=1, pady=1, sticky="nsew")
                        else:
                            # Day button
                            def make_day_handler(day_value):
                                def select_day():
                                    nonlocal selected_date
                                    selected_date = date(display_year, display_month, day_value)
                                    # Reset all buttons to normal calendar style
                                    for widget in calendar_frame.winfo_children():
                                        if isinstance(widget, ttk.Button):
                                            widget.config(style="Calendar.TButton")
                                    # Highlight selected day with prominent style
                                    for widget in calendar_frame.winfo_children():
                                        if isinstance(widget, ttk.Button) and widget.cget("text") == str(day_value):
                                            widget.config(style="Selected.TButton")
                                return select_day
                            
                            day_btn = ttk.Button(calendar_frame, text=str(day), 
                                               command=make_day_handler(day),
                                               width=3, style="Calendar.TButton")
                            day_btn.grid(row=week_num+1, column=day_num, padx=1, pady=1, sticky="nsew")
                            
                            # Check if this day should be highlighted
                            is_today = (display_year == current_date.year and 
                                       display_month == current_date.month and 
                                       day == current_date.day)
                            is_selected = (selected_date and 
                                         selected_date.year == display_year and 
                                         selected_date.month == display_month and 
                                         selected_date.day == day)
                            
                            if is_selected:
                                day_btn.config(style="Selected.TButton")
                            elif is_today:
                                day_btn.config(style="Today.TButton")
            
            # Navigation functions
            def prev_year():
                nonlocal display_year
                display_year = max(1900, display_year - 1)
                update_calendar()
            
            def next_year():
                nonlocal display_year
                display_year = min(current_date.year, display_year + 1)
                update_calendar()
            
            def prev_month():
                nonlocal display_month, display_year
                if display_month > 1:
                    display_month -= 1
                else:
                    display_month = 12
                    display_year = max(1900, display_year - 1)
                update_calendar()
            
            def next_month():
                nonlocal display_month, display_year
                if display_month < 12:
                    display_month += 1
                else:
                    display_month = 1
                    display_year = min(current_date.year, display_year + 1)
                update_calendar()
            
            # Navigation buttons
            prev_year_btn = ttk.Button(nav_frame, text="<<", width=3, command=prev_year)
            prev_year_btn.pack(side=tk.LEFT, padx=(0, 2))
            
            prev_month_btn = ttk.Button(nav_frame, text="<", width=3, command=prev_month)
            prev_month_btn.pack(side=tk.LEFT, padx=(0, 5))
            
            month_year_label = ttk.Label(nav_frame, text="", font=("Arial", 12, "bold"))
            month_year_label.pack(side=tk.LEFT, padx=5)
            
            next_month_btn = ttk.Button(nav_frame, text=">", width=3, command=next_month)
            next_month_btn.pack(side=tk.LEFT, padx=(5, 2))
            
            next_year_btn = ttk.Button(nav_frame, text=">>", width=3, command=next_year)
            next_year_btn.pack(side=tk.LEFT)
            
            # Calendar grid frame
            calendar_frame = ttk.Frame(main_cal_frame)
            calendar_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
            
            # Configure grid weights
            for i in range(7):
                calendar_frame.columnconfigure(i, weight=1)
            for i in range(7):
                calendar_frame.rowconfigure(i, weight=1)
            
            # Buttons frame
            buttons_frame = ttk.Frame(main_cal_frame)
            buttons_frame.pack(fill=tk.X)
            
            def select_date():
                """Select the date and close calendar"""
                if selected_date:
                    date_str = selected_date.strftime('%Y-%m-%d')
                    date_of_birth_var.set(date_str)
                    calendar_window.destroy()
                else:
                    messagebox.showwarning("No Date Selected", "Please select a date from the calendar.")
            
            def cancel_selection():
                """Cancel date selection"""
                calendar_window.destroy()
            
            # Buttons
            ttk.Button(buttons_frame, text="Select", command=select_date).pack(side=tk.LEFT, padx=(0, 5))
            ttk.Button(buttons_frame, text="Cancel", command=cancel_selection).pack(side=tk.LEFT)
            
            # Initialize calendar
            update_calendar()
        
        # (moved) unique_faces_var is defined earlier before date filter widgets
        
        # (moved) update_similar_faces function is defined earlier before on_unique_faces_change
        
        # (moved) Compare checkbox is now inside date_filter_frame to the right of dates
        
        # (moved) on_unique_faces_change function is defined earlier before date filter widgets
        
        
        # Add callback to save person name when it changes
        def on_name_change(*args):
            if i < len(original_faces):
                current_face_id = original_faces[i][0]
                first_name = first_name_var.get().strip()
                last_name = last_name_var.get().strip()
                middle_name = middle_name_var.get().strip()
                maiden_name = maiden_name_var.get().strip()
                date_of_birth = date_of_birth_var.get().strip()
                
                if first_name or last_name or date_of_birth:
                    # Store as dictionary to maintain consistency
                    face_person_names[current_face_id] = {
                        'first_name': first_name,
                        'last_name': last_name,
                        'middle_name': middle_name,
                        'maiden_name': maiden_name,
                        'date_of_birth': date_of_birth
                    }
                elif current_face_id in face_person_names:
                    # Remove empty names from storage
                    del face_person_names[current_face_id]
        
        first_name_var.trace('w', on_name_change)
        last_name_var.trace('w', on_name_change)
        date_of_birth_var.trace('w', on_name_change)
        
        # Buttons moved to bottom of window
        
        
        # Right panel for similar faces
        similar_faces_frame = ttk.Frame(right_panel)
        similar_faces_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        similar_faces_frame.columnconfigure(0, weight=1)
        similar_faces_frame.rowconfigure(0, weight=0)  # Controls row takes minimal space
        similar_faces_frame.rowconfigure(1, weight=1)  # Canvas row expandable
        
        # Control buttons for similar faces (Select All / Clear All)
        similar_controls_frame = ttk.Frame(similar_faces_frame)
        similar_controls_frame.grid(row=0, column=0, sticky=(tk.W, tk.E), padx=5, pady=(5, 0))
        
        def select_all_similar_faces():
            """Select all similar faces checkboxes"""
            for face_id, var in similar_face_vars:
                var.set(True)
        
        def clear_all_similar_faces():
            """Clear all similar faces checkboxes"""
            for face_id, var in similar_face_vars:
                var.set(False)
        
        select_all_btn = ttk.Button(similar_controls_frame, text="☑️ Select All", command=select_all_similar_faces, state='disabled')
        select_all_btn.pack(side=tk.LEFT, padx=(0, 5))
        
        clear_all_btn = ttk.Button(similar_controls_frame, text="☐ Clear All", command=clear_all_similar_faces, state='disabled')
        clear_all_btn.pack(side=tk.LEFT)
        
        def update_select_clear_buttons_state():
            """Enable/disable Select All and Clear All based on compare state and presence of items"""
            if compare_var.get() and similar_face_vars:
                select_all_btn.config(state='normal')
                clear_all_btn.config(state='normal')
            else:
                select_all_btn.config(state='disabled')
                clear_all_btn.config(state='disabled')
        
        # Create canvas for similar faces with scrollbar
        style = ttk.Style()
        canvas_bg_color = style.lookup('TFrame', 'background') or '#d9d9d9'
        similar_canvas = tk.Canvas(similar_faces_frame, bg=canvas_bg_color, highlightthickness=0)
        similar_scrollbar = ttk.Scrollbar(similar_faces_frame, orient="vertical", command=similar_canvas.yview)
        similar_scrollable_frame = ttk.Frame(similar_canvas)
        
        similar_scrollable_frame.bind(
            "<Configure>",
            lambda e: similar_canvas.configure(scrollregion=similar_canvas.bbox("all"))
        )
        
        similar_canvas.create_window((0, 0), window=similar_scrollable_frame, anchor="nw")
        similar_canvas.configure(yscrollcommand=similar_scrollbar.set)
        
        # Pack canvas and scrollbar
        similar_canvas.grid(row=1, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        similar_scrollbar.grid(row=0, column=1, rowspan=2, sticky=(tk.N, tk.S))
        
        # Variables for similar faces
        similar_faces_data = []
        similar_face_vars = []
        similar_face_images = []
        similar_face_crops = []
        
        # Store face selection states per face ID to preserve selections during navigation (auto-match style)
        face_selection_states = {}  # {face_id: {unique_key: bool}}
        
        # Store person names per face ID to preserve names during navigation
        face_person_names = {}  # {face_id: person_name}
        
        def save_current_face_selection_states():
            """Save current checkbox states and person name for the current face (auto-match style backup)"""
            if i < len(original_faces):
                current_face_id = original_faces[i][0]
                
                # Save checkbox states
                if similar_face_vars:
                    if current_face_id not in face_selection_states:
                        face_selection_states[current_face_id] = {}
                    
                    # Save current checkbox states using unique keys
                    for similar_face_id, var in similar_face_vars:
                        unique_key = f"{current_face_id}_{similar_face_id}"
                        face_selection_states[current_face_id][unique_key] = var.get()
                
                # Save person name and date of birth
                first_name = first_name_var.get().strip()
                last_name = last_name_var.get().strip()
                middle_name = middle_name_var.get().strip()
                maiden_name = maiden_name_var.get().strip()
                date_of_birth = date_of_birth_var.get().strip()
                
                if first_name or last_name:
                    # Store all fields
                    face_person_names[current_face_id] = {
                        'first_name': first_name,
                        'last_name': last_name,
                        'middle_name': middle_name,
                        'maiden_name': maiden_name,
                        'date_of_birth': date_of_birth
                    }
        
        # Button commands
        command = None
        waiting_for_input = False
        
        def on_identify():
            nonlocal command, waiting_for_input
            first_name = first_name_var.get().strip()
            last_name = last_name_var.get().strip()
            middle_name = middle_name_var.get().strip()
            maiden_name = maiden_name_var.get().strip()
            date_of_birth = date_of_birth_var.get().strip()
            compare_enabled = compare_var.get()
            
            if not first_name:
                print("⚠️  Please enter a first name before identifying")
                return
            
            if not last_name:
                print("⚠️  Please enter a last name before identifying")
                return
            
            if not date_of_birth:
                print("⚠️  Please select a date of birth before identifying")
                return
            
            # Validate date format (YYYY-MM-DD) - should always be valid from calendar
            try:
                from datetime import datetime
                datetime.strptime(date_of_birth, '%Y-%m-%d')
            except ValueError:
                print("⚠️  Invalid date format. Please use the calendar to select a date.")
                return
            
            # Combine first and last name properly
            if last_name and first_name:
                command = f"{last_name}, {first_name}"
            elif last_name:
                command = last_name
            elif first_name:
                command = first_name
            else:
                command = ""
            
            # Store the additional fields for database insertion
            # We'll pass them through the command structure
            if middle_name or maiden_name:
                command += f"|{middle_name}|{maiden_name}|{date_of_birth}"
            else:
                command += f"|||{date_of_birth}"
            
            if not command:
                print("⚠️  Please enter at least a first name or last name before identifying")
                return
            
            if compare_enabled:
                # Get selected similar faces
                selected_face_ids = [face_id for face_id, var in similar_face_vars if var.get()]
                if selected_face_ids:
                    # Create compare command with selected face IDs
                    command = f"compare:{command}:{','.join(map(str, selected_face_ids))}"
                # If no similar faces selected, just identify the current face
            else:
                # Regular identification
                pass
            
            waiting_for_input = False
        
        
        def validate_navigation():
            """Check if navigation is allowed (no selected similar faces without person name)"""
            # Check if compare is enabled and similar faces are selected
            if compare_var.get() and similar_face_vars:
                selected_faces = [face_id for face_id, var in similar_face_vars if var.get()]
                first_name = first_name_var.get().strip()
                last_name = last_name_var.get().strip()
                if selected_faces and not (first_name or last_name):
                    # Show warning dialog
                    result = messagebox.askyesno(
                        "Selected Faces Not Identified",
                        f"You have {len(selected_faces)} similar face(s) selected but no person name entered.\n\n"
                        "These faces will not be identified if you continue.\n\n"
                        "Do you want to continue anyway?",
                        icon='warning'
                    )
                    return result  # True = continue, False = cancel
            return True  # No validation issues, allow navigation
        
        def on_back():
            nonlocal command, waiting_for_input
            if not validate_navigation():
                return  # Cancel navigation
            command = 'back'
            waiting_for_input = False
        
        def on_skip():
            nonlocal command, waiting_for_input
            if not validate_navigation():
                return  # Cancel navigation
            command = 's'
            waiting_for_input = False
        
        def on_quit():
            nonlocal command, waiting_for_input, window_destroyed, force_exit
            
            # First check for selected similar faces without person name
            if not validate_navigation():
                return  # Cancel quit
            
            # Check if there are pending identifications (faces with complete data but not yet saved)
            pending_identifications = {}
            for k, v in face_person_names.items():
                if k not in face_status or face_status[k] != 'identified':
                    # Handle person data dict format
                    if isinstance(v, dict):
                        first_name = v.get('first_name', '').strip()
                        last_name = v.get('last_name', '').strip()
                        date_of_birth = v.get('date_of_birth', '').strip()
                        
                        # Check if we have complete data (both first and last name, plus date of birth)
                        if first_name and last_name and date_of_birth:
                            pending_identifications[k] = v
                    else:
                        # Handle legacy string format
                        person_name = v.strip()
                        date_of_birth = ''  # Legacy format doesn't have date_of_birth
                        # Legacy format is not considered complete without date of birth
                        pass
            
            if pending_identifications:
                # Ask user if they want to save pending identifications
                result = messagebox.askyesnocancel(
                    "Save Pending Identifications?",
                    f"You have {len(pending_identifications)} pending identifications.\n\n"
                    "Do you want to save them before quitting?\n\n"
                    "• Yes: Save all pending identifications and quit\n"
                    "• No: Quit without saving\n"
                    "• Cancel: Return to identification"
                )
                
                if result is True:  # Yes - Save and quit
                    save_all_pending_identifications()
                    command = 'q'
                    waiting_for_input = False
                elif result is False:  # No - Quit without saving
                    command = 'q'
                    waiting_for_input = False
                else:  # Cancel - Don't quit
                    return
            else:
                # No pending identifications, quit normally
                command = 'q'
                waiting_for_input = False
            
            if not window_destroyed:
                window_destroyed = True
                try:
                    root.destroy()
                except tk.TclError:
                    pass  # Window already destroyed
            
            # Force process termination
            force_exit = True
            root.quit()
        
        
        
        def update_button_states():
            """Update button states based on current position and unidentified faces"""
            # Check if there are previous unidentified faces
            has_prev_unidentified = False
            for j in range(i - 1, -1, -1):
                if original_faces[j][0] not in face_status or face_status[original_faces[j][0]] != 'identified':
                    has_prev_unidentified = True
                    break
            
            # Check if there are next unidentified faces
            has_next_unidentified = False
            for j in range(i + 1, len(original_faces)):
                if original_faces[j][0] not in face_status or face_status[original_faces[j][0]] != 'identified':
                    has_next_unidentified = True
                    break
            
            # Enable/disable Back button
            if has_prev_unidentified:
                back_btn.config(state='normal')
            else:
                back_btn.config(state='disabled')
            
            # Enable/disable Next button
            if has_next_unidentified:
                next_btn.config(state='normal')
            else:
                next_btn.config(state='disabled')
        
        # Button references moved to bottom control panel
        
        def update_identify_button_state():
            """Enable/disable identify button based on first name, last name, and date of birth"""
            first_name = first_name_var.get().strip()
            last_name = last_name_var.get().strip()
            date_of_birth = date_of_birth_var.get().strip()
            if first_name and last_name and date_of_birth:
                identify_btn.config(state='normal')
            else:
                identify_btn.config(state='disabled')
        
        # Bind name input changes to update button state
        first_name_var.trace('w', lambda *args: update_identify_button_state())
        last_name_var.trace('w', lambda *args: update_identify_button_state())
        date_of_birth_var.trace('w', lambda *args: update_identify_button_state())
        
        # Handle Enter key
        def on_enter(event):
            on_identify()
        
        first_name_entry.bind('<Return>', on_enter)
        last_name_entry.bind('<Return>', on_enter)
        
        # Bottom control panel (move to bottom below panels)
        control_frame = ttk.Frame(main_frame)
        control_frame.grid(row=4, column=0, columnspan=3, pady=(10, 0), sticky=(tk.E, tk.S))
        
        # Create button references for state management
        back_btn = ttk.Button(control_frame, text="⬅️ Back", command=on_back)
        next_btn = ttk.Button(control_frame, text="➡️ Next", command=on_skip)
        quit_btn = ttk.Button(control_frame, text="❌ Quit", command=on_quit)
        
        back_btn.pack(side=tk.LEFT, padx=(0, 5))
        next_btn.pack(side=tk.LEFT, padx=(0, 5))
        quit_btn.pack(side=tk.LEFT, padx=(5, 0))

        # Identify button (placed after on_identify is defined)
        identify_btn = ttk.Button(input_frame, text="✅ Identify", command=on_identify, state='disabled')
        identify_btn.grid(row=4, column=0, pady=(10, 0), sticky=tk.W)
        
        # Show the window
        try:
            root.deiconify()
            root.lift()
            root.focus_force()
        except tk.TclError:
            # Window was destroyed before we could show it
            conn.close()
            return 0
        
        
        
        # Process each face with back navigation support
        # Keep track of original face list and current position
        original_faces = list(unidentified)  # Make a copy of the original list
        i = 0
        face_status = {}  # Track which faces have been identified
        
        def get_unidentified_faces():
            """Get list of faces that haven't been identified yet"""
            return [face for face in original_faces if face[0] not in face_status or face_status[face[0]] != 'identified']
        
        def get_current_face_position():
            """Get current face position among unidentified faces"""
            unidentified_faces = get_unidentified_faces()
            current_face_id = original_faces[i][0] if i < len(original_faces) else None
            
            # Find position of current face in unidentified list
            for pos, face in enumerate(unidentified_faces):
                if face[0] == current_face_id:
                    return pos + 1, len(unidentified_faces)
            
            return 1, len(unidentified_faces)  # Fallback
        
        def update_current_face_index():
            """Update the current face index to point to a valid unidentified face"""
            nonlocal i
            unidentified_faces = get_unidentified_faces()
            if not unidentified_faces:
                # All faces identified, we're done
                return False
            
            # Find the current face in the unidentified list
            current_face_id = original_faces[i][0] if i < len(original_faces) else None
            if current_face_id and current_face_id in face_status and face_status[current_face_id] == 'identified':
                # Current face was just identified, find the next unidentified face
                if i < len(original_faces) - 1:
                    # Try to find the next unidentified face
                    for j in range(i + 1, len(original_faces)):
                        if original_faces[j][0] not in face_status or face_status[original_faces[j][0]] != 'identified':
                            i = j
                            break
                    else:
                        # No more faces after current, go to previous
                        for j in range(i - 1, -1, -1):
                            if original_faces[j][0] not in face_status or face_status[original_faces[j][0]] != 'identified':
                                i = j
                                break
                else:
                    # At the end, go to previous unidentified face
                    for j in range(i - 1, -1, -1):
                        if original_faces[j][0] not in face_status or face_status[original_faces[j][0]] != 'identified':
                            i = j
                            break
            
            # Ensure index is within bounds
            if i >= len(original_faces):
                i = len(original_faces) - 1
            if i < 0:
                i = 0
                
            return True
        
        while not window_destroyed:
            # Check if current face is identified and update index if needed
            if not update_current_face_index():
                # All faces have been identified
                print("\n🎉 All faces have been identified!")
                break
            
            # Ensure we don't go beyond the bounds
            if i >= len(original_faces):
                # Stay on the last face instead of breaking
                i = len(original_faces) - 1
                
            face_id, photo_id, photo_path, filename, location = original_faces[i]
            
            # Check if this face was already identified in this session
            is_already_identified = face_id in face_status and face_status[face_id] == 'identified'
            
            # Reset command and waiting state for each face
            command = None
            waiting_for_input = True
            
            # Update the display
            current_pos, total_unidentified = get_current_face_position()
            print(f"\n--- Face {current_pos}/{total_unidentified} (unidentified) ---")
            print(f"📁 Photo: {filename}")
            print(f"📍 Face location: {location}")
            
            # Update title
            root.title(f"Face Identification - {current_pos}/{total_unidentified} (unidentified)")
            
            # Update button states
            update_button_states()
            
            # Update similar faces panel if compare is enabled
            if compare_var.get():
                update_similar_faces()
            
            # Update photo info
            if is_already_identified:
                # Get the person name for this face
                with self.get_db_connection() as conn:
                    cursor = conn.cursor()
                    cursor.execute('''
                        SELECT p.first_name, p.last_name FROM people p 
                        JOIN faces f ON p.id = f.person_id 
                        WHERE f.id = ?
                    ''', (face_id,))
                    result = cursor.fetchone()
                    if result:
                        first_name, last_name = result
                        if last_name and first_name:
                            person_name = f"{last_name}, {first_name}"
                        elif last_name:
                            person_name = last_name
                        elif first_name:
                            person_name = first_name
                        else:
                            person_name = "Unknown"
                    else:
                        person_name = "Unknown"
                
                info_label.config(text=f"📁 Photo: {filename} (Face {current_pos}/{total_unidentified}) - ✅ Already identified as: {person_name}")
                print(f"✅ Already identified as: {person_name}")
            else:
                info_label.config(text=f"📁 Photo: {filename} (Face {current_pos}/{total_unidentified})")
            
            # Extract face crop if enabled
            face_crop_path = None
            if show_faces:
                face_crop_path = self._extract_face_crop(photo_path, location, face_id)
                if face_crop_path:
                    print(f"🖼️  Face crop saved: {face_crop_path}")
                    current_face_crop_path = face_crop_path  # Track for cleanup
            else:
                print("💡 Use --show-faces flag to display individual face crops")
                current_face_crop_path = None
            
            print(f"\n🖼️  Viewing face {current_pos}/{total_unidentified} from {filename}")
            
            # Clear and update image
            canvas.delete("all")
            if show_faces and face_crop_path and os.path.exists(face_crop_path):
                try:
                    # Load and display the face crop image
                    pil_image = Image.open(face_crop_path)
                    
                    # Get canvas dimensions
                    canvas_width = canvas.winfo_width()
                    canvas_height = canvas.winfo_height()
                    
                    # If canvas hasn't been rendered yet, force update and use actual size
                    if canvas_width <= 1 or canvas_height <= 1:
                        # Force the canvas to update its geometry
                        canvas.update_idletasks()
                        canvas_width = canvas.winfo_width()
                        canvas_height = canvas.winfo_height()
                        
                        # If still not rendered, use default size
                        if canvas_width <= 1:
                            canvas_width = 400
                        if canvas_height <= 1:
                            canvas_height = 400
                    
                    # Calculate scaling to fit within the canvas while maintaining aspect ratio
                    img_width, img_height = pil_image.size
                    scale_x = canvas_width / img_width
                    scale_y = canvas_height / img_height
                    # Allow slight upscaling (up to 1.2x) for better visibility, but cap to avoid excessive blurriness
                    max_scale = min(1.2, max(scale_x, scale_y))
                    scale = min(scale_x, scale_y, max_scale)
                    
                    # Resize image to fill canvas
                    new_width = int(img_width * scale)
                    new_height = int(img_height * scale)
                    pil_image = pil_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
                    
                    photo = ImageTk.PhotoImage(pil_image)
                    
                    # Center the image in the canvas
                    x = canvas_width // 2
                    y = canvas_height // 2
                    canvas.create_image(x, y, image=photo)
                    
                    # Keep a reference to prevent garbage collection
                    canvas.image = photo
                    
                except Exception as e:
                    canvas.create_text(200, 200, text=f"❌ Could not load image: {e}", fill="red")
            else:
                canvas.create_text(200, 200, text="🖼️ No face crop available", fill="gray")
            
            # Set person name input - restore saved name or use database/empty value
            if face_id in face_person_names:
                # Restore previously entered name for this face
                person_data = face_person_names[face_id]
                if isinstance(person_data, dict):
                    # Handle dictionary format - use individual field values for proper restoration
                    first_name = person_data.get('first_name', '').strip()
                    last_name = person_data.get('last_name', '').strip()
                    middle_name = person_data.get('middle_name', '').strip()
                    maiden_name = person_data.get('maiden_name', '').strip()
                    date_of_birth = person_data.get('date_of_birth', '').strip()
                    
                    # Restore all fields directly
                    first_name_var.set(first_name)
                    last_name_var.set(last_name)
                    middle_name_var.set(middle_name)
                    maiden_name_var.set(maiden_name)
                    date_of_birth_var.set(date_of_birth)
                else:
                    # Handle legacy string format (for backward compatibility)
                    full_name = person_data
                    # Parse "Last, First" format back to separate fields
                    if ', ' in full_name:
                        parts = full_name.split(', ', 1)
                        last_name_var.set(parts[0].strip())
                        first_name_var.set(parts[1].strip())
                    else:
                        # Single name format
                        first_name_var.set(full_name)
                        last_name_var.set("")
            elif is_already_identified:
                # Pre-populate with the current person name from database
                with self.get_db_connection() as conn:
                    cursor = conn.cursor()
                    cursor.execute('''
                        SELECT p.first_name, p.last_name, p.middle_name, p.maiden_name, p.date_of_birth FROM people p 
                        JOIN faces f ON p.id = f.person_id 
                        WHERE f.id = ?
                    ''', (face_id,))
                    result = cursor.fetchone()
                    if result:
                        first_name_var.set(result[0] or "")
                        last_name_var.set(result[1] or "")
                        middle_name_var.set(result[2] or "")
                        maiden_name_var.set(result[3] or "")
                        date_of_birth_var.set(result[4] or "")
                    else:
                        first_name_var.set("")
                        last_name_var.set("")
                        middle_name_var.set("")
                        maiden_name_var.set("")
                        date_of_birth_var.set("")
            else:
                first_name_var.set("")
                last_name_var.set("")
                middle_name_var.set("")
                maiden_name_var.set("")
                date_of_birth_var.set("")
            
            # Keep compare checkbox state persistent across navigation
            first_name_entry.focus_set()
            first_name_entry.icursor(0)
            
            # Force GUI update before waiting for input
            root.update_idletasks()
            
            # Wait for user input
            while waiting_for_input:
                try:
                    root.update()
                    # Small delay to prevent excessive CPU usage
                    time.sleep(0.01)
                except tk.TclError:
                    # Window was destroyed, break out of loop
                    break
                
                # Check if force exit was requested
                if force_exit:
                    break
            
            # Check if force exit was requested (exit immediately)
            if force_exit:
                print("Force exit requested...")
                # Clean up face crops and caches
                self._cleanup_face_crops(face_crop_path)
                self.close_db_connection()
                return identified_count
            
            # Process the command
            if command is None:  # User clicked Cancel
                command = 'q'
            else:
                command = command.strip()
            
            if command.lower() == 'q':
                print("Quitting...")
                # Clean up face crops and caches
                self._cleanup_face_crops(face_crop_path)
                self.close_db_connection()
                
                if not window_destroyed:
                    window_destroyed = True
                    try:
                        root.destroy()
                    except tk.TclError:
                        pass  # Window already destroyed
                return identified_count
            
            
            elif command.lower() == 's':
                print("➡️  Next")
                
                # Save current checkbox states before navigating away (auto-match style backup)
                save_current_face_selection_states()
                
                # Clean up current face crop when moving forward
                if face_crop_path and os.path.exists(face_crop_path):
                    try:
                        os.remove(face_crop_path)
                    except:
                        pass  # Ignore cleanup errors
                current_face_crop_path = None  # Clear tracked path
                
                # Find next unidentified face
                next_found = False
                for j in range(i + 1, len(original_faces)):
                    if original_faces[j][0] not in face_status or face_status[original_faces[j][0]] != 'identified':
                        i = j
                        next_found = True
                        break
                
                if not next_found:
                    print("⚠️  No more unidentified faces - Next button disabled")
                    continue
                
                # Clear date of birth field when moving to next face
                date_of_birth_var.set("")
                # Clear middle name and maiden name fields when moving to next face
                middle_name_var.set("")
                maiden_name_var.set("")
                
                update_button_states()
                # Only update similar faces if compare is enabled
                if compare_var.get():
                    update_similar_faces()
                continue
            
            elif command.lower() == 'back':
                print("⬅️  Going back to previous face")
                
                # Save current checkbox states before navigating away (auto-match style backup)
                save_current_face_selection_states()
                
                # Find previous unidentified face
                prev_found = False
                for j in range(i - 1, -1, -1):
                    if original_faces[j][0] not in face_status or face_status[original_faces[j][0]] != 'identified':
                        i = j
                        prev_found = True
                        break
                
                if not prev_found:
                    print("⚠️  No more unidentified faces - Back button disabled")
                    continue
                
                # Repopulate fields with saved data when going back
                current_face_id = original_faces[i][0]
                if current_face_id in face_person_names:
                    person_data = face_person_names[current_face_id]
                    if isinstance(person_data, dict):
                        # Use individual field values for proper restoration
                        first_name = person_data.get('first_name', '').strip()
                        last_name = person_data.get('last_name', '').strip()
                        middle_name = person_data.get('middle_name', '').strip()
                        maiden_name = person_data.get('maiden_name', '').strip()
                        date_of_birth = person_data.get('date_of_birth', '').strip()
                        
                        # Restore all fields directly
                        first_name_var.set(first_name)
                        last_name_var.set(last_name)
                        middle_name_var.set(middle_name)
                        maiden_name_var.set(maiden_name)
                        date_of_birth_var.set(date_of_birth)
                    else:
                        # Clear fields
                        first_name_var.set("")
                        last_name_var.set("")
                        middle_name_var.set("")
                        maiden_name_var.set("")
                        date_of_birth_var.set("")
                else:
                    # No saved data - clear fields
                    first_name_var.set("")
                    last_name_var.set("")
                    middle_name_var.set("")
                    maiden_name_var.set("")
                    date_of_birth_var.set("")
                
                update_button_states()
                # Only update similar faces if compare is enabled
                if compare_var.get():
                    update_similar_faces()
                continue
            
            elif command.lower() == 'list':
                self._show_people_list()
                continue
            
            elif command:
                try:
                    # Check if this is a compare command
                    if command.startswith('compare:'):
                        # Parse compare command: compare:person_name:face_id1,face_id2,face_id3
                        parts = command.split(':', 2)
                        if len(parts) == 3:
                            person_name = parts[1]
                            selected_face_ids = [int(fid.strip()) for fid in parts[2].split(',') if fid.strip()]
                            
                            with self.get_db_connection() as conn:
                                cursor = conn.cursor()
                                # Add person if doesn't exist
                                # Parse person_name in "Last, First" or single-token format
                                # Parse person_name with additional fields (middle_name|maiden_name|date_of_birth)
                                name_part, middle_name, maiden_name, date_of_birth = person_name.split('|', 3)
                                parts = [p.strip() for p in name_part.split(',', 1)]
                                
                                if len(parts) == 2:
                                    last_name, first_name = parts[0], parts[1]
                                else:
                                    first_name = parts[0] if parts else ''
                                    last_name = ''
                                
                                cursor.execute('INSERT OR IGNORE INTO people (first_name, last_name, middle_name, maiden_name, date_of_birth) VALUES (?, ?, ?, ?, ?)', (first_name, last_name, middle_name, maiden_name, date_of_birth))
                                cursor.execute('SELECT id FROM people WHERE first_name = ? AND last_name = ? AND middle_name = ? AND maiden_name = ? AND date_of_birth = ?', (first_name, last_name, middle_name, maiden_name, date_of_birth))
                                result = cursor.fetchone()
                                person_id = result[0] if result else None
                                
                                # Update people cache if new person was added
                                if person_name not in identify_data_cache['people_names']:
                                    identify_data_cache['people_names'].append(person_name)
                                    identify_data_cache['people_names'].sort()  # Keep sorted
                                # Update last names cache from person_name ("Last, First" or single)
                                inferred_last = person_name.split(',')[0].strip() if ',' in person_name else person_name.strip()
                                if inferred_last:
                                    if 'last_names' not in identify_data_cache:
                                        identify_data_cache['last_names'] = []
                                    if inferred_last not in identify_data_cache['last_names']:
                                        identify_data_cache['last_names'].append(inferred_last)
                                        identify_data_cache['last_names'].sort()
                                
                                # Identify all selected faces (including current face)
                                all_face_ids = [face_id] + selected_face_ids
                                for fid in all_face_ids:
                                    cursor.execute(
                                        'UPDATE faces SET person_id = ? WHERE id = ?',
                                        (person_id, fid)
                                    )
                                
                                # Mark all faces as identified in our tracking
                                for fid in all_face_ids:
                                    face_status[fid] = 'identified'
                            
                            if is_already_identified:
                                print(f"✅ Re-identified current face and {len(selected_face_ids)} similar faces as: {person_name}")
                            else:
                                print(f"✅ Identified current face and {len(selected_face_ids)} similar faces as: {person_name}")
                                identified_count += 1 + len(selected_face_ids)
                            
                            
                            # Update person encodings after database transaction is complete
                            self._update_person_encodings(person_id)
                        else:
                            print("❌ Invalid compare command format")
                    else:
                        # Regular identification
                        with self.get_db_connection() as conn:
                            cursor = conn.cursor()
                            # Add person if doesn't exist
                            # Parse command in "Last, First" or single-token format
                            # Parse command with additional fields (middle_name|maiden_name|date_of_birth)
                            name_part, middle_name, maiden_name, date_of_birth = command.split('|', 3)
                            parts = [p.strip() for p in name_part.split(',', 1)]
                            
                            if len(parts) == 2:
                                last_name, first_name = parts[0], parts[1]
                            else:
                                first_name = parts[0] if parts else ''
                                last_name = ''
                            
                            cursor.execute('INSERT OR IGNORE INTO people (first_name, last_name, middle_name, maiden_name, date_of_birth) VALUES (?, ?, ?, ?, ?)', (first_name, last_name, middle_name, maiden_name, date_of_birth))
                            cursor.execute('SELECT id FROM people WHERE first_name = ? AND last_name = ? AND middle_name = ? AND maiden_name = ? AND date_of_birth = ?', (first_name, last_name, middle_name, maiden_name, date_of_birth))
                            result = cursor.fetchone()
                            person_id = result[0] if result else None
                            
                            # Update people cache if new person was added
                            if command not in identify_data_cache['people_names']:
                                identify_data_cache['people_names'].append(command)
                                identify_data_cache['people_names'].sort()  # Keep sorted
                            # Update last names cache from command ("Last, First" or single)
                            inferred_last = command.split(',')[0].strip() if ',' in command else command.strip()
                            if inferred_last:
                                if 'last_names' not in identify_data_cache:
                                    identify_data_cache['last_names'] = []
                                if inferred_last not in identify_data_cache['last_names']:
                                    identify_data_cache['last_names'].append(inferred_last)
                                    identify_data_cache['last_names'].sort()
                            
                            # Assign face to person
                            cursor.execute(
                                'UPDATE faces SET person_id = ? WHERE id = ?',
                                (person_id, face_id)
                            )
                        
                        if is_already_identified:
                            print(f"✅ Re-identified as: {command}")
                        else:
                            print(f"✅ Identified as: {command}")
                            identified_count += 1
                        
                        # Mark this face as identified in our tracking
                        face_status[face_id] = 'identified'
                        
                        
                        # Update person encodings after database transaction is complete
                        self._update_person_encodings(person_id)
                    
                except Exception as e:
                    print(f"❌ Error: {e}")
                
                # Increment index for normal flow (identification or error) - but not if we're at the last item
                if i < len(original_faces) - 1:
                    i += 1
                update_button_states()
                # Only update similar faces if compare is enabled
                if compare_var.get():
                    update_similar_faces()
                
                # Clean up current face crop when moving forward after identification
                if face_crop_path and os.path.exists(face_crop_path):
                    try:
                        os.remove(face_crop_path)
                    except:
                        pass  # Ignore cleanup errors
                current_face_crop_path = None  # Clear tracked path
                
                # Continue to next face after processing command
                continue
            else:
                print("Please enter a name, 's' to skip, 'q' to quit, or use buttons")
        
        # Only close the window if user explicitly quit (not when reaching end of faces)
        if not window_destroyed:
            # Keep the window open - user can still navigate and quit manually
            print(f"\n✅ Identified {identified_count} faces")
            print("💡 Application remains open - use Quit button to close")
            # Don't destroy the window - let user quit manually
            return identified_count
        
        print(f"\n✅ Identified {identified_count} faces")
        return identified_count
    
    def _display_similar_faces_in_panel(self, parent_frame, similar_faces_data, face_vars, face_images, face_crops, current_face_id=None, face_selection_states=None, data_cache=None):
        """Display similar faces in a panel - reuses auto-match display logic"""
        import tkinter as tk
        from tkinter import ttk
        from PIL import Image, ImageTk
        import os
        
        # Create all similar faces using auto-match style display
        for i, face_data in enumerate(similar_faces_data[:10]):  # Limit to 10 faces
            similar_face_id = face_data['face_id']
            filename = face_data['filename']
            distance = face_data['distance']
            quality = face_data.get('quality_score', 0.5)
            
            # Calculate confidence like in auto-match
            confidence_pct = (1 - distance) * 100
            confidence_desc = self._get_confidence_description(confidence_pct)
            
            # Create match frame using auto-match style
            match_frame = ttk.Frame(parent_frame)
            match_frame.pack(fill=tk.X, padx=5, pady=5)
            
            # Checkbox for this match (reusing auto-match checkbox style)
            match_var = tk.BooleanVar()
            face_vars.append((similar_face_id, match_var))
            
            # Restore previous checkbox state if available (auto-match style)
            if current_face_id is not None and face_selection_states is not None:
                unique_key = f"{current_face_id}_{similar_face_id}"
                if current_face_id in face_selection_states and unique_key in face_selection_states[current_face_id]:
                    saved_state = face_selection_states[current_face_id][unique_key]
                    match_var.set(saved_state)
                
                # Add immediate callback to save state when checkbox changes (auto-match style)
                def make_callback(var, face_id, similar_face_id):
                    def on_checkbox_change(*args):
                        unique_key = f"{face_id}_{similar_face_id}"
                        if face_id not in face_selection_states:
                            face_selection_states[face_id] = {}
                        face_selection_states[face_id][unique_key] = var.get()
                    return on_checkbox_change
                
                # Bind the callback to the variable
                match_var.trace('w', make_callback(match_var, current_face_id, similar_face_id))
            
            # Configure match frame for grid layout
            match_frame.columnconfigure(0, weight=0)  # Checkbox column - fixed width
            match_frame.columnconfigure(1, weight=1)  # Text column - expandable
            match_frame.columnconfigure(2, weight=0)  # Image column - fixed width
            
            # Checkbox without text
            checkbox = ttk.Checkbutton(match_frame, variable=match_var)
            checkbox.grid(row=0, column=0, rowspan=2, sticky=(tk.W, tk.N), padx=(0, 5))
            
            # Create labels for confidence and filename
            confidence_label = ttk.Label(match_frame, text=f"{confidence_pct:.1f}% {confidence_desc}", font=("Arial", 9, "bold"))
            confidence_label.grid(row=0, column=1, sticky=tk.W, padx=(0, 10))
            
            filename_label = ttk.Label(match_frame, text=f"📁 {filename}", font=("Arial", 8), foreground="gray")
            filename_label.grid(row=1, column=1, sticky=tk.W, padx=(0, 10))
            
            # Face image (reusing auto-match image display)
            try:
                # Get photo path from cache or database
                photo_path = None
                if data_cache and 'photo_paths' in data_cache:
                    # Find photo path by filename in cache
                    for photo_data in data_cache['photo_paths'].values():
                        if photo_data['filename'] == filename:
                            photo_path = photo_data['path']
                            break
                
                # Fallback to database if not in cache
                if photo_path is None:
                    with self.get_db_connection() as conn:
                        cursor = conn.cursor()
                        cursor.execute('SELECT path FROM photos WHERE filename = ?', (filename,))
                        result = cursor.fetchone()
                        photo_path = result[0] if result else None
                
                # Extract face crop using existing method
                face_crop_path = self._extract_face_crop(photo_path, face_data['location'], similar_face_id)
                if face_crop_path and os.path.exists(face_crop_path):
                    face_crops.append(face_crop_path)
                    
                    # Create canvas for face image (like in auto-match)
                    style = ttk.Style()
                    canvas_bg_color = style.lookup('TFrame', 'background') or '#d9d9d9'
                    match_canvas = tk.Canvas(match_frame, width=80, height=80, bg=canvas_bg_color, highlightthickness=0)
                    match_canvas.grid(row=0, column=2, rowspan=2, sticky=(tk.W, tk.N), padx=(10, 0))
                    
                    # Load and display image (reusing auto-match image loading)
                    pil_image = Image.open(face_crop_path)
                    pil_image.thumbnail((80, 80), Image.Resampling.LANCZOS)
                    photo = ImageTk.PhotoImage(pil_image)
                    match_canvas.create_image(40, 40, image=photo)
                    match_canvas.image = photo  # Keep reference
                    face_images.append(photo)
                else:
                    # No image available
                    match_canvas = tk.Canvas(match_frame, width=80, height=80, bg='white')
                    match_canvas.pack(side=tk.LEFT, padx=(10, 0))
                    match_canvas.create_text(40, 40, text="🖼️", fill="gray")
            except Exception as e:
                # Error loading image
                match_canvas = tk.Canvas(match_frame, width=80, height=80, bg='white')
                match_canvas.pack(side=tk.LEFT, padx=(10, 0))
                match_canvas.create_text(40, 40, text="❌", fill="red")
    
    def _extract_face_crop(self, photo_path: str, location: tuple, face_id: int) -> str:
        """Extract and save individual face crop for identification with caching"""
        try:
            # Check cache first
            cache_key = f"{photo_path}_{location}_{face_id}"
            if cache_key in self._image_cache:
                cached_path = self._image_cache[cache_key]
                # Verify the cached file still exists
                if os.path.exists(cached_path):
                    return cached_path
                else:
                    # Remove from cache if file doesn't exist
                    del self._image_cache[cache_key]
            
            # Parse location tuple from string format
            if isinstance(location, str):
                location = eval(location)
            
            top, right, bottom, left = location
            
            # Load the image
            image = Image.open(photo_path)
            
            # Add padding around the face (20% of face size)
            face_width = right - left
            face_height = bottom - top
            padding_x = int(face_width * 0.2)
            padding_y = int(face_height * 0.2)
            
            # Calculate crop bounds with padding
            crop_left = max(0, left - padding_x)
            crop_top = max(0, top - padding_y)
            crop_right = min(image.width, right + padding_x)
            crop_bottom = min(image.height, bottom + padding_y)
            
            # Crop the face
            face_crop = image.crop((crop_left, crop_top, crop_right, crop_bottom))
            
            # Create temporary file for the face crop
            temp_dir = tempfile.gettempdir()
            face_filename = f"face_{face_id}_crop.jpg"
            face_path = os.path.join(temp_dir, face_filename)
            
            # Resize for better viewing (minimum 200px width)
            if face_crop.width < 200:
                ratio = 200 / face_crop.width
                new_width = 200
                new_height = int(face_crop.height * ratio)
                face_crop = face_crop.resize((new_width, new_height), Image.Resampling.LANCZOS)
            
            face_crop.save(face_path, "JPEG", quality=95)
            
            # Cache the result
            self._image_cache[cache_key] = face_path
            return face_path
            
        except Exception as e:
            if self.verbose >= 1:
                print(f"⚠️  Could not extract face crop: {e}")
            return None

    def _create_comparison_image(self, unid_crop_path: str, match_crop_path: str, person_name: str, confidence: float) -> str:
        """Create a side-by-side comparison image"""
        try:
            # Load both face crops
            unid_img = Image.open(unid_crop_path)
            match_img = Image.open(match_crop_path)
            
            # Resize both to same height for better comparison
            target_height = 300
            unid_ratio = target_height / unid_img.height
            match_ratio = target_height / match_img.height
            
            unid_resized = unid_img.resize((int(unid_img.width * unid_ratio), target_height), Image.Resampling.LANCZOS)
            match_resized = match_img.resize((int(match_img.width * match_ratio), target_height), Image.Resampling.LANCZOS)
            
            # Create comparison image
            total_width = unid_resized.width + match_resized.width + 20  # 20px gap
            comparison = Image.new('RGB', (total_width, target_height + 60), 'white')
            
            # Paste images
            comparison.paste(unid_resized, (0, 30))
            comparison.paste(match_resized, (unid_resized.width + 20, 30))
            
            # Add labels
            draw = ImageDraw.Draw(comparison)
            try:
                # Try to use a font
                font = ImageFont.truetype("/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf", 16)
            except:
                font = ImageFont.load_default()
            
            draw.text((10, 5), "UNKNOWN", fill='red', font=font)
            draw.text((unid_resized.width + 30, 5), f"{person_name.upper()}", fill='green', font=font)
            draw.text((10, target_height + 35), f"Confidence: {confidence:.1%}", fill='blue', font=font)
            
            # Save comparison image
            temp_dir = tempfile.gettempdir()
            comparison_path = os.path.join(temp_dir, f"face_comparison_{person_name}.jpg")
            comparison.save(comparison_path, "JPEG", quality=95)
            
            return comparison_path
            
        except Exception as e:
            if self.verbose >= 1:
                print(f"⚠️  Could not create comparison image: {e}")
            return None

    def _get_confidence_description(self, confidence_pct: float) -> str:
        """Get human-readable confidence description"""
        if confidence_pct >= 80:
            return "🟢 (Very High - Almost Certain)"
        elif confidence_pct >= 70:
            return "🟡 (High - Likely Match)"
        elif confidence_pct >= 60:
            return "🟠 (Medium - Possible Match)"
        elif confidence_pct >= 50:
            return "🔴 (Low - Questionable)"
        else:
            return "⚫ (Very Low - Unlikely)"

    def _calculate_face_quality_score(self, image: np.ndarray, face_location: tuple) -> float:
        """Calculate face quality score based on multiple factors"""
        try:
            top, right, bottom, left = face_location
            face_height = bottom - top
            face_width = right - left
            
            # Basic size check - faces too small get lower scores
            min_face_size = 50
            size_score = min(1.0, (face_height * face_width) / (min_face_size * min_face_size))
            
            # Extract face region
            face_region = image[top:bottom, left:right]
            if face_region.size == 0:
                return 0.0
            
            # Convert to grayscale for analysis
            if len(face_region.shape) == 3:
                gray_face = np.mean(face_region, axis=2)
            else:
                gray_face = face_region
            
            # Calculate sharpness (Laplacian variance)
            laplacian_var = np.var(np.array([[0, -1, 0], [-1, 4, -1], [0, -1, 0]]).astype(np.float32))
            if laplacian_var > 0:
                sharpness = np.var(np.array([[0, -1, 0], [-1, 4, -1], [0, -1, 0]]).astype(np.float32))
            else:
                sharpness = 0.0
            sharpness_score = min(1.0, sharpness / 1000.0)  # Normalize sharpness
            
            # Calculate brightness and contrast
            mean_brightness = np.mean(gray_face)
            brightness_score = 1.0 - abs(mean_brightness - 128) / 128.0  # Prefer middle brightness
            
            contrast = np.std(gray_face)
            contrast_score = min(1.0, contrast / 64.0)  # Prefer good contrast
            
            # Calculate aspect ratio (faces should be roughly square)
            aspect_ratio = face_width / face_height if face_height > 0 else 1.0
            aspect_score = 1.0 - abs(aspect_ratio - 1.0)  # Prefer square faces
            
            # Calculate position in image (centered faces are better)
            image_height, image_width = image.shape[:2]
            center_x = (left + right) / 2
            center_y = (top + bottom) / 2
            position_x_score = 1.0 - abs(center_x - image_width / 2) / (image_width / 2)
            position_y_score = 1.0 - abs(center_y - image_height / 2) / (image_height / 2)
            position_score = (position_x_score + position_y_score) / 2.0
            
            # Weighted combination of all factors
            quality_score = (
                size_score * 0.25 +
                sharpness_score * 0.25 +
                brightness_score * 0.15 +
                contrast_score * 0.15 +
                aspect_score * 0.10 +
                position_score * 0.10
            )
            
            return max(0.0, min(1.0, quality_score))
            
        except Exception as e:
            if self.verbose >= 2:
                print(f"⚠️  Error calculating face quality: {e}")
            return 0.5  # Default medium quality on error

    def _add_person_encoding(self, person_id: int, face_id: int, encoding: np.ndarray, quality_score: float):
        """Add a face encoding to a person's encoding collection"""
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            cursor.execute(
                'INSERT INTO person_encodings (person_id, face_id, encoding, quality_score) VALUES (?, ?, ?, ?)',
                (person_id, face_id, encoding.tobytes(), quality_score)
            )

    def _get_person_encodings(self, person_id: int, min_quality: float = 0.3) -> List[Tuple[np.ndarray, float]]:
        """Get all high-quality encodings for a person"""
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            cursor.execute(
                'SELECT encoding, quality_score FROM person_encodings WHERE person_id = ? AND quality_score >= ? ORDER BY quality_score DESC',
                (person_id, min_quality)
            )
            results = cursor.fetchall()
            return [(np.frombuffer(encoding, dtype=np.float64), quality_score) for encoding, quality_score in results]

    def _update_person_encodings(self, person_id: int):
        """Update person encodings when a face is identified"""
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            
            # Get all faces for this person
            cursor.execute(
                'SELECT id, encoding, quality_score FROM faces WHERE person_id = ? ORDER BY quality_score DESC',
                (person_id,)
            )
            faces = cursor.fetchall()
            
            # Clear existing person encodings
            cursor.execute('DELETE FROM person_encodings WHERE person_id = ?', (person_id,))
            
            # Add all faces as person encodings
            for face_id, encoding, quality_score in faces:
                cursor.execute(
                    'INSERT INTO person_encodings (person_id, face_id, encoding, quality_score) VALUES (?, ?, ?, ?)',
                    (person_id, face_id, encoding, quality_score)
                )

    def _calculate_adaptive_tolerance(self, base_tolerance: float, face_quality: float, match_confidence: float = None) -> float:
        """Calculate adaptive tolerance based on face quality and match confidence"""
        # Start with base tolerance
        tolerance = base_tolerance
        
        # Adjust based on face quality (higher quality = stricter tolerance)
        # More conservative: range 0.9 to 1.1 instead of 0.8 to 1.2
        quality_factor = 0.9 + (face_quality * 0.2)  # Range: 0.9 to 1.1
        tolerance *= quality_factor
        
        # If we have match confidence, adjust further
        if match_confidence is not None:
            # Higher confidence matches can use stricter tolerance
            # More conservative: range 0.95 to 1.05 instead of 0.9 to 1.1
            confidence_factor = 0.95 + (match_confidence * 0.1)  # Range: 0.95 to 1.05
            tolerance *= confidence_factor
        
        # Ensure tolerance stays within reasonable bounds
        return max(0.3, min(0.8, tolerance))  # Reduced max from 0.9 to 0.8

    def _get_filtered_similar_faces(self, face_id: int, tolerance: float, include_same_photo: bool = False, face_status: dict = None) -> List[Dict]:
        """Get similar faces with consistent filtering and sorting logic used by both auto-match and identify"""
        # Find similar faces using the core function
        similar_faces_data = self.find_similar_faces(face_id, tolerance=tolerance, include_same_photo=include_same_photo)
        
        # Filter to only show unidentified faces with confidence filtering
        filtered_faces = []
        for face in similar_faces_data:
            # For auto-match: only filter by database state (keep existing behavior)
            # For identify: also filter by current session state
            is_identified_in_db = face.get('person_id') is not None
            is_identified_in_session = face_status and face.get('face_id') in face_status and face_status[face.get('face_id')] == 'identified'
            
            # If face_status is provided (identify mode), use both filters
            # If face_status is None (auto-match mode), only use database filter
            if face_status is not None:
                # Identify mode: filter out both database and session identified faces
                if not is_identified_in_db and not is_identified_in_session:
                    # Calculate confidence percentage
                    confidence_pct = (1 - face['distance']) * 100
                    
                    # Only include matches with reasonable confidence (at least 40%)
                    if confidence_pct >= 40:
                        filtered_faces.append(face)
            else:
                # Auto-match mode: only filter by database state (keep existing behavior)
                if not is_identified_in_db:
                    # Calculate confidence percentage
                    confidence_pct = (1 - face['distance']) * 100
                    
                    # Only include matches with reasonable confidence (at least 40%)
                    if confidence_pct >= 40:
                        filtered_faces.append(face)
        
        # Sort by confidence (distance) - highest confidence first
        filtered_faces.sort(key=lambda x: x['distance'])
        
        return filtered_faces

    def _filter_unique_faces(self, faces: List[Dict]) -> List[Dict]:
        """Filter faces to show only unique ones, hiding duplicates with high/medium confidence matches"""
        if not faces:
            return faces
        
        unique_faces = []
        seen_face_groups = set()  # Track face groups that have been seen
        
        for face in faces:
            face_id = face['face_id']
            confidence_pct = (1 - face['distance']) * 100
            
            # Only consider high (>=70%) or medium (>=60%) confidence matches for grouping
            if confidence_pct >= 60:
                # Find all faces that match this one with high/medium confidence
                matching_face_ids = set()
                for other_face in faces:
                    other_face_id = other_face['face_id']
                    other_confidence_pct = (1 - other_face['distance']) * 100
                    
                    # If this face matches the current face with high/medium confidence
                    if other_confidence_pct >= 60:
                        matching_face_ids.add(other_face_id)
                
                # Create a sorted tuple to represent this group of matching faces
                face_group = tuple(sorted(matching_face_ids))
                
                # Only show this face if we haven't seen this group before
                if face_group not in seen_face_groups:
                    seen_face_groups.add(face_group)
                    unique_faces.append(face)
            else:
                # For low confidence matches, always show them (they're likely different people)
                unique_faces.append(face)
        
        return unique_faces

    def _filter_unique_faces_from_list(self, faces_list: List[tuple]) -> List[tuple]:
        """Filter face list to show only unique ones, hiding duplicates with high/medium confidence matches"""
        if not faces_list:
            return faces_list
        
        # Extract face IDs from the list
        face_ids = [face_tuple[0] for face_tuple in faces_list]
        
        # Get face encodings from database for all faces
        face_encodings = {}
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            placeholders = ','.join('?' * len(face_ids))
            cursor.execute(f'''
                SELECT id, encoding 
                FROM faces 
                WHERE id IN ({placeholders}) AND encoding IS NOT NULL
            ''', face_ids)
            
            for face_id, encoding_blob in cursor.fetchall():
                try:
                    import numpy as np
                    # Load encoding as numpy array (not pickle)
                    encoding = np.frombuffer(encoding_blob, dtype=np.float64)
                    face_encodings[face_id] = encoding
                except Exception:
                    continue
        
        # If we don't have enough encodings, return original list
        if len(face_encodings) < 2:
            return faces_list
        
        # Calculate distances between all faces using existing encodings
        face_distances = {}
        face_id_list = list(face_encodings.keys())
        
        for i, face_id1 in enumerate(face_id_list):
            for j, face_id2 in enumerate(face_id_list):
                if i != j:
                    try:
                        import face_recognition
                        encoding1 = face_encodings[face_id1]
                        encoding2 = face_encodings[face_id2]
                        
                        # Calculate distance
                        distance = face_recognition.face_distance([encoding1], encoding2)[0]
                        face_distances[(face_id1, face_id2)] = distance
                    except Exception:
                        # If calculation fails, assume no match
                        face_distances[(face_id1, face_id2)] = 1.0
        
        # Apply unique faces filtering
        unique_faces = []
        seen_face_groups = set()
        
        for face_tuple in faces_list:
            face_id = face_tuple[0]
            
            # Skip if we don't have encoding for this face
            if face_id not in face_encodings:
                unique_faces.append(face_tuple)
                continue
            
            # Find all faces that match this one with high/medium confidence
            matching_face_ids = set([face_id])  # Include self
            for other_face_id in face_encodings.keys():
                if other_face_id != face_id:
                    distance = face_distances.get((face_id, other_face_id), 1.0)
                    confidence_pct = (1 - distance) * 100
                    
                    # If this face matches with high/medium confidence
                    if confidence_pct >= 60:
                        matching_face_ids.add(other_face_id)
            
            # Create a sorted tuple to represent this group of matching faces
            face_group = tuple(sorted(matching_face_ids))
            
            # Only show this face if we haven't seen this group before
            if face_group not in seen_face_groups:
                seen_face_groups.add(face_group)
                unique_faces.append(face_tuple)
        
        return unique_faces

    def _show_people_list(self, cursor=None):
        """Show list of known people"""
        if cursor is None:
            with self.get_db_connection() as conn:
                cursor = conn.cursor()
                cursor.execute('SELECT first_name, last_name FROM people ORDER BY first_name, last_name')
                people = cursor.fetchall()
        else:
            cursor.execute('SELECT first_name, last_name FROM people ORDER BY first_name, last_name')
            people = cursor.fetchall()
            
        if people:
            formatted_names = [f"{last}, {first}".strip(", ").strip() for first, last in people if first or last]
            print("👥 Known people:", ", ".join(formatted_names))
        else:
            print("👥 No people identified yet")
    
    def add_tags(self, photo_pattern: str = None, batch_size: int = 10) -> int:
        """Add custom tags to photos"""
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            
            if photo_pattern:
                cursor.execute(
                    'SELECT id, filename FROM photos WHERE filename LIKE ? LIMIT ?',
                    (f'%{photo_pattern}%', batch_size)
                )
            else:
                cursor.execute('SELECT id, filename FROM photos LIMIT ?', (batch_size,))
            
            photos = cursor.fetchall()
            
            if not photos:
                print("No photos found")
                return 0
            
            print(f"🏷️  Tagging {len(photos)} photos (enter comma-separated tags)")
            tagged_count = 0
            
            for photo_id, filename in photos:
                print(f"\n📸 {filename}")
                tags_input = input("🏷️  Tags: ").strip()
                
                if tags_input.lower() == 'q':
                    break
                
                if tags_input:
                    tags = [tag.strip() for tag in tags_input.split(',') if tag.strip()]
                    for tag in tags:
                        cursor.execute(
                            'INSERT INTO tags (photo_id, tag_name) VALUES (?, ?)',
                            (photo_id, tag)
                        )
                    print(f"   ✅ Added {len(tags)} tags")
                    tagged_count += 1
        
        print(f"✅ Tagged {tagged_count} photos")
        return tagged_count
    
    def stats(self) -> Dict:
        """Show database statistics"""
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            
            stats = {}
            
            # Basic counts
            cursor.execute('SELECT COUNT(*) FROM photos')
            result = cursor.fetchone()
            stats['total_photos'] = result[0] if result else 0
            
            cursor.execute('SELECT COUNT(*) FROM photos WHERE processed = 1')
            result = cursor.fetchone()
            stats['processed_photos'] = result[0] if result else 0
            
            cursor.execute('SELECT COUNT(*) FROM faces')
            result = cursor.fetchone()
            stats['total_faces'] = result[0] if result else 0
            
            cursor.execute('SELECT COUNT(*) FROM faces WHERE person_id IS NOT NULL')
            result = cursor.fetchone()
            stats['identified_faces'] = result[0] if result else 0
            
            cursor.execute('SELECT COUNT(*) FROM people')
            result = cursor.fetchone()
            stats['total_people'] = result[0] if result else 0
            
            cursor.execute('SELECT COUNT(DISTINCT tag_name) FROM tags')
            result = cursor.fetchone()
            stats['unique_tags'] = result[0] if result else 0
            
            # Top people
            cursor.execute('''
                SELECT 
                    CASE 
                        WHEN p.last_name AND p.first_name THEN p.last_name || ', ' || p.first_name
                        WHEN p.first_name THEN p.first_name
                        WHEN p.last_name THEN p.last_name
                        ELSE 'Unknown'
                    END as full_name,
                    COUNT(f.id) as face_count 
                FROM people p 
                LEFT JOIN faces f ON p.id = f.person_id 
                GROUP BY p.id 
                ORDER BY face_count DESC 
                LIMIT 15
            ''')
            stats['top_people'] = cursor.fetchall()
        
        # Display stats
        print(f"\n📊 Database Statistics")
        print("=" * 40)
        print(f"Photos: {stats['processed_photos']}/{stats['total_photos']} processed")
        print(f"Faces: {stats['identified_faces']}/{stats['total_faces']} identified")
        print(f"People: {stats['total_people']} unique")
        print(f"Tags: {stats['unique_tags']} unique")
        
        if stats['top_people']:
            print(f"\n👥 Top People:")
            for name, count in stats['top_people']:
                print(f"   {name}: {count} faces")
        
        unidentified = stats['total_faces'] - stats['identified_faces']
        if unidentified > 0:
            print(f"\n⚠️  {unidentified} faces still need identification")
        
        return stats
    
    def search_faces(self, person_name: str) -> List[str]:
        """Search for photos containing a specific person"""
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            
            cursor.execute('''
                SELECT DISTINCT p.filename, p.path
                FROM photos p
                JOIN faces f ON p.id = f.photo_id
                JOIN people pe ON f.person_id = pe.id
                WHERE pe.name LIKE ?
            ''', (f'%{person_name}%',))
            
            results = cursor.fetchall()
        
        if results:
            print(f"\n🔍 Found {len(results)} photos with '{person_name}':")
            for filename, path in results:
                print(f"   📸 {filename}")
        else:
            print(f"🔍 No photos found with '{person_name}'")
        
        return [path for filename, path in results]

    def find_similar_faces(self, face_id: int = None, tolerance: float = 0.6, include_same_photo: bool = False) -> List[Dict]:
        """Find similar faces across all photos with improved multi-encoding and quality scoring"""
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            
            if face_id:
                # Find faces similar to a specific face
                cursor.execute('''
                    SELECT id, photo_id, encoding, location, quality_score
                    FROM faces 
                    WHERE id = ?
                ''', (face_id,))
                target_face = cursor.fetchone()
                
                if not target_face:
                    print(f"❌ Face ID {face_id} not found")
                    return []
                
                target_encoding = self._get_cached_face_encoding(face_id, target_face[2])
                target_quality = target_face[4] if len(target_face) > 4 else 0.5
                
                # Get all other faces with quality scores
                cursor.execute('''
                    SELECT f.id, f.photo_id, f.encoding, f.location, p.filename, f.person_id, f.quality_score
                    FROM faces f
                    JOIN photos p ON f.photo_id = p.id
                    WHERE f.id != ? AND f.quality_score >= 0.2
                ''', (face_id,))
                
            else:
                # Find all unidentified faces and try to match them with identified ones
                cursor.execute('''
                    SELECT f.id, f.photo_id, f.encoding, f.location, p.filename, f.person_id, f.quality_score
                    FROM faces f
                    JOIN photos p ON f.photo_id = p.id
                    WHERE f.quality_score >= 0.2
                    ORDER BY f.quality_score DESC, f.id
                ''')
            
            all_faces = cursor.fetchall()
            matches = []
            
            if face_id:
                # Compare target face with all other faces using adaptive tolerance
                for face_data in all_faces:
                    other_id, other_photo_id, other_encoding, other_location, other_filename, other_person_id, other_quality = face_data
                    other_enc = self._get_cached_face_encoding(other_id, other_encoding)
                    
                    # Calculate adaptive tolerance based on both face qualities
                    avg_quality = (target_quality + other_quality) / 2
                    adaptive_tolerance = self._calculate_adaptive_tolerance(tolerance, avg_quality)
                    
                    distance = face_recognition.face_distance([target_encoding], other_enc)[0]
                    if distance <= adaptive_tolerance:
                        matches.append({
                            'face_id': other_id,
                            'photo_id': other_photo_id,
                            'filename': other_filename,
                            'location': other_location,
                            'distance': distance,
                            'person_id': other_person_id,
                            'quality_score': other_quality,
                            'adaptive_tolerance': adaptive_tolerance
                        })
                
                # Get target photo info
                cursor.execute('SELECT filename FROM photos WHERE id = ?', (target_face[1],))
                result = cursor.fetchone()
                target_filename = result[0] if result else "Unknown"
                
                print(f"\n🔍 Finding faces similar to face in: {target_filename}")
                print(f"📍 Target face location: {target_face[3]}")
                
            else:
                # Auto-match unidentified faces with identified ones using multi-encoding
                identified_faces = [f for f in all_faces if f[5] is not None]  # person_id is not None
                unidentified_faces = [f for f in all_faces if f[5] is None]    # person_id is None
                
                print(f"\n🔍 Auto-matching {len(unidentified_faces)} unidentified faces with {len(identified_faces)} known faces...")
                
                # Group identified faces by person (simplified for now)
                person_encodings = {}
                for id_face in identified_faces:
                    person_id = id_face[5]
                    if person_id not in person_encodings:
                        # Use single encoding per person for now (simplified)
                        id_enc = self._get_cached_face_encoding(id_face[0], id_face[2])
                        person_encodings[person_id] = [(id_enc, id_face[6])]
                
                for unid_face in unidentified_faces:
                    unid_id, unid_photo_id, unid_encoding, unid_location, unid_filename, _, unid_quality = unid_face
                    unid_enc = self._get_cached_face_encoding(unid_id, unid_encoding)
                    
                    best_match = None
                    best_distance = float('inf')
                    best_person_id = None
                    
                    # Compare with all person encodings
                    for person_id, encodings in person_encodings.items():
                        for person_enc, person_quality in encodings:
                            # Calculate adaptive tolerance based on both face qualities
                            avg_quality = (unid_quality + person_quality) / 2
                            adaptive_tolerance = self._calculate_adaptive_tolerance(tolerance, avg_quality)
                            
                            distance = face_recognition.face_distance([unid_enc], person_enc)[0]
                            
                            # Skip if same photo (unless specifically requested for twins detection)
                            # Note: Same photo check is simplified for performance
                            if not include_same_photo:
                                # For now, we'll skip this check to avoid performance issues
                                # TODO: Implement efficient same-photo checking
                                pass
                            
                            if distance <= adaptive_tolerance and distance < best_distance:
                                best_distance = distance
                                best_person_id = person_id
                                
                                # Get the best matching face info for this person
                                cursor.execute('''
                                    SELECT f.id, f.photo_id, f.location, p.filename
                                    FROM faces f
                                    JOIN photos p ON f.photo_id = p.id
                                    WHERE f.person_id = ? AND f.quality_score >= ?
                                    ORDER BY f.quality_score DESC
                                    LIMIT 1
                                ''', (person_id, 0.3))
                                
                                best_face_info = cursor.fetchone()
                                if best_face_info:
                                    best_match = {
                                        'unidentified_id': unid_id,
                                        'unidentified_photo_id': unid_photo_id,
                                        'unidentified_filename': unid_filename,
                                        'unidentified_location': unid_location,
                                        'matched_id': best_face_info[0],
                                        'matched_photo_id': best_face_info[1],
                                        'matched_filename': best_face_info[3],
                                        'matched_location': best_face_info[2],
                                        'person_id': person_id,
                                        'distance': distance,
                                        'quality_score': unid_quality,
                                        'adaptive_tolerance': adaptive_tolerance
                                    }
                    
                    if best_match:
                        matches.append(best_match)
            
            return matches

    def auto_identify_matches(self, tolerance: float = 0.6, confirm: bool = True, show_faces: bool = False, include_same_photo: bool = False) -> int:
        """Automatically identify faces that match already identified faces using GUI"""
        # Get all identified faces (one per person) to use as reference faces
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            cursor.execute('''
                SELECT f.id, f.person_id, f.photo_id, f.location, p.filename, f.quality_score
                FROM faces f
                JOIN photos p ON f.photo_id = p.id
                WHERE f.person_id IS NOT NULL AND f.quality_score >= 0.3
                ORDER BY f.person_id, f.quality_score DESC
            ''')
            identified_faces = cursor.fetchall()
        
        if not identified_faces:
            print("🔍 No identified faces found for auto-matching")
            return 0
        
        # Group by person and get the best quality face per person
        person_faces = {}
        for face in identified_faces:
            person_id = face[1]
            if person_id not in person_faces:
                person_faces[person_id] = face
        
        # Convert to ordered list to ensure consistent ordering
        # Order by person name for user-friendly consistent results across runs
        person_faces_list = []
        for person_id, face in person_faces.items():
            # Get person name for ordering
            with self.get_db_connection() as conn:
                cursor = conn.cursor()
                cursor.execute('SELECT first_name, last_name FROM people WHERE id = ?', (person_id,))
                result = cursor.fetchone()
                if result:
                    first_name, last_name = result
                    if last_name and first_name:
                        person_name = f"{last_name}, {first_name}"
                    elif last_name:
                        person_name = last_name
                    elif first_name:
                        person_name = first_name
                    else:
                        person_name = "Unknown"
                else:
                    person_name = "Unknown"
            person_faces_list.append((person_id, face, person_name))
        
        # Sort by person name for consistent, user-friendly ordering
        person_faces_list.sort(key=lambda x: x[2])  # Sort by person name (index 2)
        
        print(f"\n🎯 Found {len(person_faces)} identified people to match against")
        print("📊 Confidence Guide: 🟢80%+ = Very High, 🟡70%+ = High, 🟠60%+ = Medium, 🔴50%+ = Low, ⚫<50% = Very Low")
        
        # Find similar faces for each identified person using face-to-face comparison
        matches_by_matched = {}
        for person_id, reference_face, person_name in person_faces_list:
            reference_face_id = reference_face[0]
            
            # Use the same filtering and sorting logic as identify
            similar_faces = self._get_filtered_similar_faces(reference_face_id, tolerance, include_same_photo, face_status=None)
            
            # Convert to auto-match format
            person_matches = []
            for similar_face in similar_faces:
                # Convert to auto-match format
                match = {
                    'unidentified_id': similar_face['face_id'],
                    'unidentified_photo_id': similar_face['photo_id'],
                    'unidentified_filename': similar_face['filename'],
                    'unidentified_location': similar_face['location'],
                    'matched_id': reference_face_id,
                    'matched_photo_id': reference_face[2],
                    'matched_filename': reference_face[4],
                    'matched_location': reference_face[3],
                    'person_id': person_id,
                    'distance': similar_face['distance'],
                    'quality_score': similar_face['quality_score'],
                    'adaptive_tolerance': similar_face.get('adaptive_tolerance', tolerance)
                }
                person_matches.append(match)
            
            matches_by_matched[person_id] = person_matches
        
        # Flatten all matches for counting
        all_matches = []
        for person_matches in matches_by_matched.values():
            all_matches.extend(person_matches)
        
        if not all_matches:
            print("🔍 No similar faces found for auto-identification")
            return 0
        
        print(f"\n🎯 Found {len(all_matches)} potential matches")
        
        # Pre-fetch all needed data to avoid repeated database queries in update_display
        print("📊 Pre-fetching data for optimal performance...")
        data_cache = {}
        
        with self.get_db_connection() as conn:
            cursor = conn.cursor()
            
            # Pre-fetch all person names and details
            person_ids = list(matches_by_matched.keys())
            if person_ids:
                placeholders = ','.join('?' * len(person_ids))
                cursor.execute(f'SELECT id, first_name, last_name, middle_name, maiden_name, date_of_birth FROM people WHERE id IN ({placeholders})', person_ids)
                data_cache['person_details'] = {}
                for row in cursor.fetchall():
                    person_id = row[0]
                    first_name = row[1] or ''
                    last_name = row[2] or ''
                    middle_name = row[3] or ''
                    maiden_name = row[4] or ''
                    date_of_birth = row[5] or ''
                    
                    # Create full name display
                    name_parts = []
                    if first_name:
                        name_parts.append(first_name)
                    if middle_name:
                        name_parts.append(middle_name)
                    if last_name:
                        name_parts.append(last_name)
                    if maiden_name:
                        name_parts.append(f"({maiden_name})")
                    
                    full_name = ' '.join(name_parts)
                    data_cache['person_details'][person_id] = {
                        'full_name': full_name,
                        'first_name': first_name,
                        'last_name': last_name,
                        'middle_name': middle_name,
                        'maiden_name': maiden_name,
                        'date_of_birth': date_of_birth
                    }
            
            # Pre-fetch all photo paths (both matched and unidentified)
            all_photo_ids = set()
            for person_matches in matches_by_matched.values():
                for match in person_matches:
                    all_photo_ids.add(match['matched_photo_id'])
                    all_photo_ids.add(match['unidentified_photo_id'])
            
            if all_photo_ids:
                photo_ids_list = list(all_photo_ids)
                placeholders = ','.join('?' * len(photo_ids_list))
                cursor.execute(f'SELECT id, path FROM photos WHERE id IN ({placeholders})', photo_ids_list)
                data_cache['photo_paths'] = {row[0]: row[1] for row in cursor.fetchall()}
        
        print(f"✅ Pre-fetched {len(data_cache.get('person_details', {}))} person details and {len(data_cache.get('photo_paths', {}))} photo paths")
        
        identified_count = 0
        
        # Use integrated GUI for auto-matching
        import tkinter as tk
        from tkinter import ttk, messagebox
        from PIL import Image, ImageTk
        import json
        import os
        
        # Create the main window
        root = tk.Tk()
        root.title("Auto-Match Face Identification")
        root.resizable(True, True)
        
        # Track window state to prevent multiple destroy calls
        window_destroyed = False
        
        # Hide window initially to prevent flash at corner
        root.withdraw()
        
        # Set up protocol handler for window close button (X)
        def on_closing():
            nonlocal window_destroyed
            # Clean up face crops and caches
            self._cleanup_face_crops()
            self.close_db_connection()
            
            if not window_destroyed:
                window_destroyed = True
                try:
                    root.destroy()
                except tk.TclError:
                    pass  # Window already destroyed
        
        root.protocol("WM_DELETE_WINDOW", on_closing)
        
        # Set up window size saving with larger default size
        saved_size = self._setup_window_size_saving(root, "gui_config.json")
        # Override with larger size for auto-match window
        root.geometry("1000x700")
        
        # Create main frame
        main_frame = ttk.Frame(root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # Configure grid weights
        root.columnconfigure(0, weight=1)
        root.rowconfigure(0, weight=1)
        main_frame.columnconfigure(0, weight=1)
        main_frame.columnconfigure(1, weight=1)
        
        # Left side - identified person
        left_frame = ttk.LabelFrame(main_frame, text="Identified person", padding="10")
        left_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(0, 5))
        
        # Right side - unidentified faces that match this person
        right_frame = ttk.LabelFrame(main_frame, text="Unidentified Faces to Match", padding="10")
        right_frame.grid(row=0, column=1, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(5, 0))
        
        # Configure row weights
        main_frame.rowconfigure(0, weight=1)
        
        # Search controls for filtering people by last name
        last_name_search_var = tk.StringVar()
        # Search field with label underneath (like modifyidentified edit section)
        search_frame = ttk.Frame(left_frame)
        search_frame.grid(row=0, column=0, sticky=(tk.W, tk.E), pady=(0, 10))
        
        # Search input on the left
        search_entry = ttk.Entry(search_frame, textvariable=last_name_search_var, width=20)
        search_entry.grid(row=0, column=0, sticky=tk.W)
        
        # Buttons on the right of the search input
        buttons_row = ttk.Frame(search_frame)
        buttons_row.grid(row=0, column=1, sticky=tk.W, padx=(6, 0))
        
        search_btn = ttk.Button(buttons_row, text="Search", width=8)
        search_btn.pack(side=tk.LEFT, padx=(0, 5))
        clear_btn = ttk.Button(buttons_row, text="Clear", width=6)
        clear_btn.pack(side=tk.LEFT)
        
        # Helper label directly under the search input
        last_name_label = ttk.Label(search_frame, text="Type Last Name", font=("Arial", 8), foreground="gray")
        last_name_label.grid(row=1, column=0, sticky=tk.W, pady=(2, 0))
        
        # Matched person info
        matched_info_label = ttk.Label(left_frame, text="", font=("Arial", 10, "bold"))
        matched_info_label.grid(row=2, column=0, pady=(0, 10), sticky=tk.W)
        
        # Matched person image
        style = ttk.Style()
        canvas_bg_color = style.lookup('TFrame', 'background') or '#d9d9d9'
        matched_canvas = tk.Canvas(left_frame, width=300, height=300, bg=canvas_bg_color, highlightthickness=0)
        matched_canvas.grid(row=3, column=0, pady=(0, 10))
        
        # Save button for this person (will be created after function definitions)
        save_btn = None
        
        # Matches scrollable frame
        matches_frame = ttk.Frame(right_frame)
        matches_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # Control buttons for matches (Select All / Clear All)
        matches_controls_frame = ttk.Frame(matches_frame)
        matches_controls_frame.grid(row=0, column=0, sticky=(tk.W, tk.E), padx=5, pady=(5, 0))
        
        def select_all_matches():
            """Select all match checkboxes"""
            for var in match_vars:
                var.set(True)
        
        def clear_all_matches():
            """Clear all match checkboxes"""
            for var in match_vars:
                var.set(False)
        
        select_all_matches_btn = ttk.Button(matches_controls_frame, text="☑️ Select All", command=select_all_matches)
        select_all_matches_btn.pack(side=tk.LEFT, padx=(0, 5))
        
        clear_all_matches_btn = ttk.Button(matches_controls_frame, text="☐ Clear All", command=clear_all_matches)
        clear_all_matches_btn.pack(side=tk.LEFT)
        
        def update_match_control_buttons_state():
            """Enable/disable Select All / Clear All based on matches presence"""
            if match_vars:
                select_all_matches_btn.config(state='normal')
                clear_all_matches_btn.config(state='normal')
            else:
                select_all_matches_btn.config(state='disabled')
                clear_all_matches_btn.config(state='disabled')
        
        # Create scrollbar for matches
        scrollbar = ttk.Scrollbar(right_frame, orient="vertical", command=None)
        scrollbar.grid(row=0, column=1, rowspan=1, sticky=(tk.N, tk.S))
        
        # Create canvas for matches with scrollbar
        style = ttk.Style()
        canvas_bg_color = style.lookup('TFrame', 'background') or '#d9d9d9'
        matches_canvas = tk.Canvas(matches_frame, yscrollcommand=scrollbar.set, bg=canvas_bg_color, highlightthickness=0)
        matches_canvas.grid(row=1, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        scrollbar.config(command=matches_canvas.yview)
        
        # Configure grid weights
        right_frame.columnconfigure(0, weight=1)
        right_frame.rowconfigure(0, weight=1)
        matches_frame.columnconfigure(0, weight=1)
        matches_frame.rowconfigure(0, weight=0)  # Controls row takes minimal space
        matches_frame.rowconfigure(1, weight=1)  # Canvas row expandable
        
        # Control buttons (navigation only)
        control_frame = ttk.Frame(main_frame)
        control_frame.grid(row=1, column=0, columnspan=2, pady=(10, 0))
        
        # Button commands
        current_matched_index = 0
        matched_ids = [person_id for person_id, _, _ in person_faces_list if person_id in matches_by_matched and matches_by_matched[person_id]]
        filtered_matched_ids = None  # filtered subset based on last name search
        
        match_checkboxes = []
        match_vars = []
        identified_faces_per_person = {}  # Track which faces were identified for each person
        checkbox_states_per_person = {}  # Track checkbox states for each person (unsaved selections)
        original_checkbox_states_per_person = {}  # Track original/default checkbox states for comparison
        
        def on_confirm_matches():
            nonlocal identified_count, current_matched_index, identified_faces_per_person
            if current_matched_index < len(matched_ids):
                matched_id = matched_ids[current_matched_index]
                matches_for_this_person = matches_by_matched[matched_id]
                
                # Initialize identified faces for this person if not exists
                if matched_id not in identified_faces_per_person:
                    identified_faces_per_person[matched_id] = set()
                
                with self.get_db_connection() as conn:
                    cursor = conn.cursor()
                    
                    # Process all matches (both checked and unchecked)
                    for i, (match, var) in enumerate(zip(matches_for_this_person, match_vars)):
                        if var.get():
                            # Face is checked - assign to person
                            cursor.execute(
                                'UPDATE faces SET person_id = ? WHERE id = ?',
                                (match['person_id'], match['unidentified_id'])
                            )
                            
                            # Use cached person name instead of database query
                            person_details = data_cache['person_details'].get(match['person_id'], {})
                            person_name = person_details.get('full_name', "Unknown")
                            
                            # Track this face as identified for this person
                            identified_faces_per_person[matched_id].add(match['unidentified_id'])
                            
                            print(f"✅ Identified as: {person_name}")
                            identified_count += 1
                        else:
                            # Face is unchecked - check if it was previously identified for this person
                            if match['unidentified_id'] in identified_faces_per_person[matched_id]:
                                # This face was previously identified for this person, now unchecking it
                                cursor.execute(
                                    'UPDATE faces SET person_id = NULL WHERE id = ?',
                                    (match['unidentified_id'],)
                                )
                                
                                # Remove from identified faces for this person
                                identified_faces_per_person[matched_id].discard(match['unidentified_id'])
                                
                                print(f"❌ Unidentified: {match['unidentified_filename']}")
                
                # Update person encodings for all affected persons after database transaction is complete
                for person_id in set(match['person_id'] for match in matches_for_this_person if match['person_id']):
                    self._update_person_encodings(person_id)
                
                # After saving, set original states to the current UI states so there are no unsaved changes
                current_snapshot = {}
                for match, var in zip(matches_for_this_person, match_vars):
                    unique_key = f"{matched_id}_{match['unidentified_id']}"
                    current_snapshot[unique_key] = var.get()
                checkbox_states_per_person[matched_id] = dict(current_snapshot)
                original_checkbox_states_per_person[matched_id] = dict(current_snapshot)
        
        def on_skip_current():
            nonlocal current_matched_index
            # Save current checkbox states before navigating away
            save_current_checkbox_states()
            current_matched_index += 1
            active_ids = filtered_matched_ids if filtered_matched_ids is not None else matched_ids
            if current_matched_index < len(active_ids):
                update_display()
            else:
                finish_auto_match()
        
        def on_go_back():
            nonlocal current_matched_index
            if current_matched_index > 0:
                # Save current checkbox states before navigating away
                save_current_checkbox_states()
                current_matched_index -= 1
                update_display()
        
        def has_unsaved_changes():
            """Check if there are any unsaved changes by comparing current states with original states"""
            for person_id, current_states in checkbox_states_per_person.items():
                if person_id in original_checkbox_states_per_person:
                    original_states = original_checkbox_states_per_person[person_id]
                    # Check if any checkbox state differs from its original state
                    for key, current_value in current_states.items():
                        if key not in original_states or original_states[key] != current_value:
                            return True
                else:
                    # If person has current states but no original states, there are changes
                    if any(current_states.values()):
                        return True
            return False
        
        def apply_last_name_filter():
            """Filter people by last name and update navigation"""
            nonlocal filtered_matched_ids, current_matched_index
            query = last_name_search_var.get().strip().lower()
            if query:
                # Filter person_faces_list by last name
                filtered_people = []
                for person_id, face, person_name in person_faces_list:
                    # Extract last name from person_name (format: "Last, First")
                    if ',' in person_name:
                        last_name = person_name.split(',')[0].strip().lower()
                    else:
                        last_name = person_name.strip().lower()
                    
                    if query in last_name:
                        filtered_people.append((person_id, face, person_name))
                
                # Get filtered matched_ids
                filtered_matched_ids = [person_id for person_id, _, _ in filtered_people if person_id in matches_by_matched and matches_by_matched[person_id]]
            else:
                filtered_matched_ids = None
            
            # Reset to first person in filtered list
            current_matched_index = 0
            if filtered_matched_ids:
                update_display()
            else:
                # No matches - clear display
                matched_info_label.config(text="No people match filter")
                matched_canvas.delete("all")
                matched_canvas.create_text(150, 150, text="No matches found", fill="gray")
                matches_canvas.delete("all")
                update_button_states()
        
        def clear_last_name_filter():
            """Clear filter and show all people"""
            nonlocal filtered_matched_ids, current_matched_index
            last_name_search_var.set("")
            filtered_matched_ids = None
            current_matched_index = 0
            update_display()
        
        def on_quit_auto_match():
            nonlocal window_destroyed
            
            # Check for unsaved changes before quitting
            if has_unsaved_changes():
                # Show warning dialog with custom width
                from tkinter import messagebox
                
                # Create a custom dialog for better width control
                dialog = tk.Toplevel(root)
                dialog.title("Unsaved Changes")
                dialog.geometry("500x250")
                dialog.resizable(True, True)
                dialog.transient(root)
                dialog.grab_set()
                
                # Center the dialog
                dialog.geometry("+%d+%d" % (root.winfo_rootx() + 50, root.winfo_rooty() + 50))
                
                # Main message
                message_frame = ttk.Frame(dialog, padding="20")
                message_frame.pack(fill=tk.BOTH, expand=True)
                
                # Warning icon and text
                icon_label = ttk.Label(message_frame, text="⚠️", font=("Arial", 16))
                icon_label.pack(anchor=tk.W)
                
                main_text = ttk.Label(message_frame, 
                                    text="You have unsaved changes that will be lost if you quit.",
                                    font=("Arial", 10))
                main_text.pack(anchor=tk.W, pady=(5, 10))
                
                # Options
                options_text = ttk.Label(message_frame,
                                       text="• Yes: Save current changes and quit\n"
                                            "• No: Quit without saving\n"
                                            "• Cancel: Return to auto-match",
                                       font=("Arial", 9))
                options_text.pack(anchor=tk.W, pady=(0, 10))
                
                
                # Buttons
                button_frame = ttk.Frame(dialog)
                button_frame.pack(fill=tk.X, padx=20, pady=(0, 20))
                
                result = None
                
                def on_yes():
                    nonlocal result
                    result = True
                    dialog.destroy()
                
                def on_no():
                    nonlocal result
                    result = False
                    dialog.destroy()
                
                def on_cancel():
                    nonlocal result
                    result = None
                    dialog.destroy()
                
                yes_btn = ttk.Button(button_frame, text="Yes", command=on_yes)
                no_btn = ttk.Button(button_frame, text="No", command=on_no)
                cancel_btn = ttk.Button(button_frame, text="Cancel", command=on_cancel)
                
                yes_btn.pack(side=tk.LEFT, padx=(0, 5))
                no_btn.pack(side=tk.LEFT, padx=5)
                cancel_btn.pack(side=tk.RIGHT, padx=(5, 0))
                
                # Wait for dialog to close
                dialog.wait_window()
                
                if result is None:  # Cancel - don't quit
                    return
                elif result:  # Yes - save changes first
                    # Save current checkbox states before quitting
                    save_current_checkbox_states()
                    # Note: We don't actually save to database here, just preserve the states
                    # The user would need to click Save button for each person to persist changes
                    print("⚠️  Warning: Changes are preserved but not saved to database.")
                    print("   Click 'Save Changes' button for each person to persist changes.")
            
            if not window_destroyed:
                window_destroyed = True
                try:
                    root.destroy()
                except tk.TclError:
                    pass  # Window already destroyed
        
        def finish_auto_match():
            nonlocal window_destroyed
            print(f"\n✅ Auto-identified {identified_count} faces")
            if not window_destroyed:
                window_destroyed = True
                try:
                    root.destroy()
                except tk.TclError:
                    pass  # Window already destroyed
        
        # Create button references for state management
        back_btn = ttk.Button(control_frame, text="⏮️ Back", command=on_go_back)
        next_btn = ttk.Button(control_frame, text="⏭️ Next", command=on_skip_current)
        quit_btn = ttk.Button(control_frame, text="❌ Quit", command=on_quit_auto_match)
        
        back_btn.grid(row=0, column=0, padx=(0, 5))
        next_btn.grid(row=0, column=1, padx=5)
        quit_btn.grid(row=0, column=2, padx=(5, 0))
        
        # Create save button now that functions are defined
        save_btn = ttk.Button(left_frame, text="💾 Save Changes", command=on_confirm_matches)
        save_btn.grid(row=4, column=0, pady=(0, 10), sticky=(tk.W, tk.E))
        
        def update_button_states():
            """Update button states based on current position"""
            active_ids = filtered_matched_ids if filtered_matched_ids is not None else matched_ids
            # Enable/disable Back button based on position
            if current_matched_index > 0:
                back_btn.config(state='normal')
            else:
                back_btn.config(state='disabled')
            
            # Enable/disable Next button based on position
            if current_matched_index < len(active_ids) - 1:
                next_btn.config(state='normal')
            else:
                next_btn.config(state='disabled')
        
        def update_save_button_text():
            """Update save button text with current person name"""
            active_ids = filtered_matched_ids if filtered_matched_ids is not None else matched_ids
            if current_matched_index < len(active_ids):
                matched_id = active_ids[current_matched_index]
                # Get person name from the first match for this person
                matches_for_current_person = matches_by_matched[matched_id]
                if matches_for_current_person:
                    person_id = matches_for_current_person[0]['person_id']
                    # Use cached person name instead of database query
                    person_details = data_cache['person_details'].get(person_id, {})
                    person_name = person_details.get('full_name', "Unknown")
                    save_btn.config(text=f"💾 Save changes for {person_name}")
                else:
                    save_btn.config(text="💾 Save Changes")
            else:
                save_btn.config(text="💾 Save Changes")
        
        def save_current_checkbox_states():
            """Save current checkbox states for the current person.
            Note: Do NOT modify original states here to avoid false positives
            when a user toggles and reverts a checkbox.
            """
            if current_matched_index < len(matched_ids) and match_vars:
                current_matched_id = matched_ids[current_matched_index]
                matches_for_current_person = matches_by_matched[current_matched_id]
                
                if len(match_vars) == len(matches_for_current_person):
                    if current_matched_id not in checkbox_states_per_person:
                        checkbox_states_per_person[current_matched_id] = {}
                    
                    # Save current checkbox states for this person
                    for i, (match, var) in enumerate(zip(matches_for_current_person, match_vars)):
                        unique_key = f"{current_matched_id}_{match['unidentified_id']}"
                        current_value = var.get()
                        checkbox_states_per_person[current_matched_id][unique_key] = current_value
                        
                        if self.verbose >= 2:
                            print(f"DEBUG: Saved state for person {current_matched_id}, face {match['unidentified_id']}: {current_value}")
        
        def update_display():
            nonlocal current_matched_index
            active_ids = filtered_matched_ids if filtered_matched_ids is not None else matched_ids
            if current_matched_index >= len(active_ids):
                finish_auto_match()
                return
            
            matched_id = active_ids[current_matched_index]
            matches_for_this_person = matches_by_matched[matched_id]
            
            # Update button states
            update_button_states()
            
            # Update save button text with person name
            update_save_button_text()
            
            # Update title
            active_ids = filtered_matched_ids if filtered_matched_ids is not None else matched_ids
            root.title(f"Auto-Match Face Identification - {current_matched_index + 1}/{len(active_ids)}")
            
            # Get the first match to get matched person info
            if not matches_for_this_person:
                print(f"❌ Error: No matches found for current person {matched_id}")
                # No items on the right panel – disable Select All / Clear All
                match_checkboxes.clear()
                match_vars.clear()
                update_match_control_buttons_state()
                # Skip to next person if available
                if current_matched_index < len(matched_ids) - 1:
                    current_matched_index += 1
                    update_display()
                else:
                    finish_auto_match()
                return
            
            first_match = matches_for_this_person[0]
            
            # Use cached data instead of database queries
            person_details = data_cache['person_details'].get(first_match['person_id'], {})
            person_name = person_details.get('full_name', "Unknown")
            date_of_birth = person_details.get('date_of_birth', '')
            matched_photo_path = data_cache['photo_paths'].get(first_match['matched_photo_id'], None)
            
            # Create detailed person info display
            person_info_lines = [f"👤 Person: {person_name}"]
            if date_of_birth:
                person_info_lines.append(f"📅 Born: {date_of_birth}")
            person_info_lines.extend([
                f"📁 Photo: {first_match['matched_filename']}",
                f"📍 Face location: {first_match['matched_location']}"
            ])
            
            # Update matched person info
            matched_info_label.config(text="\n".join(person_info_lines))
            
            # Display matched person face
            matched_canvas.delete("all")
            if show_faces:
                matched_crop_path = self._extract_face_crop(
                    matched_photo_path, 
                    first_match['matched_location'], 
                    f"matched_{first_match['person_id']}"
                )
                
                if matched_crop_path and os.path.exists(matched_crop_path):
                    try:
                        pil_image = Image.open(matched_crop_path)
                        pil_image.thumbnail((300, 300), Image.Resampling.LANCZOS)
                        photo = ImageTk.PhotoImage(pil_image)
                        matched_canvas.create_image(150, 150, image=photo)
                        matched_canvas.image = photo
                    except Exception as e:
                        matched_canvas.create_text(150, 150, text=f"❌ Could not load image: {e}", fill="red")
                else:
                    matched_canvas.create_text(150, 150, text="🖼️ No face crop available", fill="gray")
            
            # Clear and populate unidentified faces
            matches_canvas.delete("all")
            match_checkboxes.clear()
            match_vars.clear()
            update_match_control_buttons_state()
            
            # Create frame for unidentified faces inside canvas
            matches_inner_frame = ttk.Frame(matches_canvas)
            matches_canvas.create_window((0, 0), window=matches_inner_frame, anchor="nw")
            
            # Use cached photo paths instead of database queries
            photo_paths = data_cache['photo_paths']
            
            # Create all checkboxes
            for i, match in enumerate(matches_for_this_person):
                # Get unidentified face info from cached data
                unidentified_photo_path = photo_paths.get(match['unidentified_photo_id'], '')
                
                # Calculate confidence
                confidence_pct = (1 - match['distance']) * 100
                confidence_desc = self._get_confidence_description(confidence_pct)
                
                # Create match frame
                match_frame = ttk.Frame(matches_inner_frame)
                match_frame.grid(row=i, column=0, sticky=(tk.W, tk.E), pady=5)
                
                # Checkbox for this match
                match_var = tk.BooleanVar()
                
                # Restore previous checkbox state if available
                unique_key = f"{matched_id}_{match['unidentified_id']}"
                if matched_id in checkbox_states_per_person and unique_key in checkbox_states_per_person[matched_id]:
                    saved_state = checkbox_states_per_person[matched_id][unique_key]
                    match_var.set(saved_state)
                    if self.verbose >= 2:
                        print(f"DEBUG: Restored state for person {matched_id}, face {match['unidentified_id']}: {saved_state}")
                # Otherwise, pre-select if this face was previously identified for this person
                elif matched_id in identified_faces_per_person and match['unidentified_id'] in identified_faces_per_person[matched_id]:
                    match_var.set(True)
                    if self.verbose >= 2:
                        print(f"DEBUG: Pre-selected identified face for person {matched_id}, face {match['unidentified_id']}")
                
                match_vars.append(match_var)
                
                # Capture original state at render time (once per person per face)
                if matched_id not in original_checkbox_states_per_person:
                    original_checkbox_states_per_person[matched_id] = {}
                if unique_key not in original_checkbox_states_per_person[matched_id]:
                    original_checkbox_states_per_person[matched_id][unique_key] = match_var.get()

                # Add callback to save state immediately when checkbox changes
                def on_checkbox_change(var, person_id, face_id):
                    unique_key = f"{person_id}_{face_id}"
                    if person_id not in checkbox_states_per_person:
                        checkbox_states_per_person[person_id] = {}
                    
                    current_value = var.get()
                    checkbox_states_per_person[person_id][unique_key] = current_value
                    
                    if self.verbose >= 2:
                        print(f"DEBUG: Checkbox changed for person {person_id}, face {face_id}: {current_value}")
                
                # Bind the callback to the variable
                match_var.trace('w', lambda *args: on_checkbox_change(match_var, matched_id, match['unidentified_id']))
                
                # Configure match frame for grid layout
                match_frame.columnconfigure(0, weight=0)  # Checkbox column - fixed width
                match_frame.columnconfigure(1, weight=1)  # Text column - expandable
                match_frame.columnconfigure(2, weight=0)  # Image column - fixed width
                
                # Checkbox without text
                checkbox = ttk.Checkbutton(match_frame, variable=match_var)
                checkbox.grid(row=0, column=0, rowspan=2, sticky=(tk.W, tk.N), padx=(0, 5))
                match_checkboxes.append(checkbox)
                
                # Create labels for confidence and filename
                confidence_label = ttk.Label(match_frame, text=f"{confidence_pct:.1f}% {confidence_desc}", font=("Arial", 9, "bold"))
                confidence_label.grid(row=0, column=1, sticky=tk.W, padx=(0, 10))
                
                filename_label = ttk.Label(match_frame, text=f"📁 {match['unidentified_filename']}", font=("Arial", 8), foreground="gray")
                filename_label.grid(row=1, column=1, sticky=tk.W, padx=(0, 10))
                
                # Unidentified face image
                if show_faces:
                    style = ttk.Style()
                    canvas_bg_color = style.lookup('TFrame', 'background') or '#d9d9d9'
                    match_canvas = tk.Canvas(match_frame, width=100, height=100, bg=canvas_bg_color, highlightthickness=0)
                    match_canvas.grid(row=0, column=2, rowspan=2, sticky=(tk.W, tk.N), padx=(10, 0))
                    
                    unidentified_crop_path = self._extract_face_crop(
                        unidentified_photo_path,
                        match['unidentified_location'],
                        f"unid_{match['unidentified_id']}"
                    )
                    
                    if unidentified_crop_path and os.path.exists(unidentified_crop_path):
                        try:
                            pil_image = Image.open(unidentified_crop_path)
                            pil_image.thumbnail((100, 100), Image.Resampling.LANCZOS)
                            photo = ImageTk.PhotoImage(pil_image)
                            match_canvas.create_image(50, 50, image=photo)
                            match_canvas.image = photo
                        except Exception as e:
                            match_canvas.create_text(50, 50, text="❌", fill="red")
                    else:
                        match_canvas.create_text(50, 50, text="🖼️", fill="gray")
            
            # Update Select All / Clear All button states after populating
            update_match_control_buttons_state()
            
            # Update scroll region
            matches_canvas.update_idletasks()
            matches_canvas.configure(scrollregion=matches_canvas.bbox("all"))
        
        # Show the window
        try:
            root.deiconify()
            root.lift()
            root.focus_force()
        except tk.TclError:
            # Window was destroyed before we could show it
            return 0
        
        # Wire up search controls now that helper functions exist
        try:
            search_btn.config(command=lambda: apply_last_name_filter())
            clear_btn.config(command=lambda: clear_last_name_filter())
            search_entry.bind('<Return>', lambda e: apply_last_name_filter())
        except Exception:
            pass
        
        # Start with first matched person
        update_display()
        
        # Main event loop
        try:
            root.mainloop()
        except tk.TclError:
            pass  # Window was destroyed
        
        return identified_count

    def modifyidentified(self) -> int:
        """Modify identified faces interface - empty window with Quit button for now"""
        import tkinter as tk
        from tkinter import ttk, messagebox
        from PIL import Image, ImageTk
        import os
        
        # Simple tooltip implementation
        class ToolTip:
            def __init__(self, widget, text):
                self.widget = widget
                self.text = text
                self.tooltip_window = None
                self.widget.bind("<Enter>", self.on_enter)
                self.widget.bind("<Leave>", self.on_leave)
            
            def on_enter(self, event=None):
                if self.tooltip_window or not self.text:
                    return
                x, y, _, _ = self.widget.bbox("insert") if hasattr(self.widget, 'bbox') else (0, 0, 0, 0)
                x += self.widget.winfo_rootx() + 25
                y += self.widget.winfo_rooty() + 25
                
                self.tooltip_window = tw = tk.Toplevel(self.widget)
                tw.wm_overrideredirect(True)
                tw.wm_geometry(f"+{x}+{y}")
                
                label = tk.Label(tw, text=self.text, justify=tk.LEFT,
                               background="#ffffe0", relief=tk.SOLID, borderwidth=1,
                               font=("tahoma", "8", "normal"))
                label.pack(ipadx=1)
            
            def on_leave(self, event=None):
                if self.tooltip_window:
                    self.tooltip_window.destroy()
                    self.tooltip_window = None
        
        # Create the main window
        root = tk.Tk()
        root.title("View and Modify Identified Faces")
        root.resizable(True, True)
        
        # Track window state to prevent multiple destroy calls
        window_destroyed = False
        temp_crops = []
        right_panel_images = []  # Keep PhotoImage refs alive
        selected_person_id = None
        
        # Hide window initially to prevent flash at corner
        root.withdraw()
        
        # Set up protocol handler for window close button (X)
        def on_closing():
            nonlocal window_destroyed
            # Cleanup temp crops
            for crop in list(temp_crops):
                try:
                    if os.path.exists(crop):
                        os.remove(crop)
                except:
                    pass
            temp_crops.clear()
            if not window_destroyed:
                window_destroyed = True
                try:
                    root.destroy()
                except tk.TclError:
                    pass  # Window already destroyed
        
        root.protocol("WM_DELETE_WINDOW", on_closing)
        
        # Set up window size saving
        saved_size = self._setup_window_size_saving(root)
        
        # Create main frame
        main_frame = ttk.Frame(root, padding="10")
        main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        
        # Configure grid weights
        root.columnconfigure(0, weight=1)
        root.rowconfigure(0, weight=1)
        main_frame.columnconfigure(0, weight=1)
        main_frame.columnconfigure(1, weight=2)
        main_frame.rowconfigure(1, weight=1)
        
        # Title label
        title_label = ttk.Label(main_frame, text="View and Modify Identified Faces", font=("Arial", 16, "bold"))
        title_label.grid(row=0, column=0, columnspan=2, pady=(0, 10), sticky=tk.W)
        
        # Left panel: People list
        people_frame = ttk.LabelFrame(main_frame, text="People", padding="10")
        people_frame.grid(row=1, column=0, sticky=(tk.W, tk.E, tk.N, tk.S), padx=(0, 8))
        people_frame.columnconfigure(0, weight=1)

        # Search controls (Last Name) with label under the input (match auto-match style)
        last_name_search_var = tk.StringVar()
        search_frame = ttk.Frame(people_frame)
        search_frame.grid(row=0, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=(0, 6))
        
        # Entry on the left
        search_entry = ttk.Entry(search_frame, textvariable=last_name_search_var, width=20)
        search_entry.grid(row=0, column=0, sticky=tk.W)
        
        # Buttons to the right of the entry
        buttons_row = ttk.Frame(search_frame)
        buttons_row.grid(row=0, column=1, sticky=tk.W, padx=(6, 0))
        search_btn = ttk.Button(buttons_row, text="Search", width=8)
        search_btn.pack(side=tk.LEFT, padx=(0, 5))
        clear_btn = ttk.Button(buttons_row, text="Clear", width=6)
        clear_btn.pack(side=tk.LEFT)
        
        # Helper label directly under the entry
        last_name_label = ttk.Label(search_frame, text="Type Last Name", font=("Arial", 8), foreground="gray")
        last_name_label.grid(row=1, column=0, sticky=tk.W, pady=(2, 0))

        people_canvas = tk.Canvas(people_frame, bg='white')
        people_scrollbar = ttk.Scrollbar(people_frame, orient="vertical", command=people_canvas.yview)
        people_list_inner = ttk.Frame(people_canvas)
        people_canvas.create_window((0, 0), window=people_list_inner, anchor="nw")
        people_canvas.configure(yscrollcommand=people_scrollbar.set)
        
        people_list_inner.bind(
            "<Configure>",
            lambda e: people_canvas.configure(scrollregion=people_canvas.bbox("all"))
        )
        
        people_canvas.grid(row=1, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        people_scrollbar.grid(row=1, column=1, sticky=(tk.N, tk.S))
        people_frame.rowconfigure(1, weight=1)
        
        # Right panel: Faces for selected person
        faces_frame = ttk.LabelFrame(main_frame, text="Faces", padding="10")
        faces_frame.grid(row=1, column=1, sticky=(tk.W, tk.E, tk.N, tk.S))
        faces_frame.columnconfigure(0, weight=1)
        faces_frame.rowconfigure(0, weight=1)
        
        style = ttk.Style()
        canvas_bg_color = style.lookup('TFrame', 'background') or '#d9d9d9'
        # Match auto-match UI: set gray background for left canvas and remove highlight border
        try:
            people_canvas.configure(bg=canvas_bg_color, highlightthickness=0)
        except Exception:
            pass
        faces_canvas = tk.Canvas(faces_frame, bg=canvas_bg_color, highlightthickness=0)
        faces_scrollbar = ttk.Scrollbar(faces_frame, orient="vertical", command=faces_canvas.yview)
        faces_inner = ttk.Frame(faces_canvas)
        faces_canvas.create_window((0, 0), window=faces_inner, anchor="nw")
        faces_canvas.configure(yscrollcommand=faces_scrollbar.set)
        
        faces_inner.bind(
            "<Configure>",
            lambda e: faces_canvas.configure(scrollregion=faces_canvas.bbox("all"))
        )
        
        # Track current person for responsive face grid
        current_person_id = None
        current_person_name = ""
        resize_job = None
        
        # Track unmatched faces (temporary changes)
        unmatched_faces = set()  # All face IDs unmatched across people (for global save)
        unmatched_by_person = {}  # person_id -> set(face_id) for per-person undo
        original_faces_data = []  # store original faces data for potential future use

        def on_faces_canvas_resize(event):
            nonlocal resize_job
            if current_person_id is None:
                return
            # Debounce re-render on resize
            try:
                if resize_job is not None:
                    root.after_cancel(resize_job)
            except Exception:
                pass
            resize_job = root.after(150, lambda: show_person_faces(current_person_id, current_person_name))

        faces_canvas.bind("<Configure>", on_faces_canvas_resize)

        faces_canvas.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
        faces_scrollbar.grid(row=0, column=1, sticky=(tk.N, tk.S))
        
        # Load people from DB with counts
        people_data = []  # list of dicts: {id, name, count, first_name, last_name}
        people_filtered = None  # filtered subset based on last name search
        
        def load_people():
            nonlocal people_data
            with self.get_db_connection() as conn:
                cursor = conn.cursor()
                cursor.execute(
                    """
                    SELECT p.id, p.first_name, p.last_name, p.middle_name, p.maiden_name, p.date_of_birth, COUNT(f.id) as face_count
                    FROM people p
                    JOIN faces f ON f.person_id = p.id
                    GROUP BY p.id, p.last_name, p.first_name, p.middle_name, p.maiden_name, p.date_of_birth
                    HAVING face_count > 0
                    ORDER BY p.last_name, p.first_name COLLATE NOCASE
                    """
                )
                people_data = []
                for (pid, first_name, last_name, middle_name, maiden_name, date_of_birth, count) in cursor.fetchall():
                    # Create full name display with all available information
                    name_parts = []
                    if first_name:
                        name_parts.append(first_name)
                    if middle_name:
                        name_parts.append(middle_name)
                    if last_name:
                        name_parts.append(last_name)
                    if maiden_name:
                        name_parts.append(f"({maiden_name})")
                    
                    full_name = ' '.join(name_parts) if name_parts else "Unknown"
                    
                    # Create detailed display with date of birth if available
                    display_name = full_name
                    if date_of_birth:
                        display_name += f" - Born: {date_of_birth}"
                    
                    people_data.append({
                        'id': pid,
                        'name': display_name,
                        'full_name': full_name,
                        'first_name': first_name or "",
                        'last_name': last_name or "",
                        'middle_name': middle_name or "",
                        'maiden_name': maiden_name or "",
                        'date_of_birth': date_of_birth or "",
                        'count': count
                    })
            # Re-apply filter (if any) after loading
            try:
                apply_last_name_filter()
            except Exception:
                pass

        # Wire up search controls now that helper functions exist
        try:
            search_btn.config(command=lambda: apply_last_name_filter())
            clear_btn.config(command=lambda: clear_last_name_filter())
            search_entry.bind('<Return>', lambda e: apply_last_name_filter())
        except Exception:
            pass

        def apply_last_name_filter():
            nonlocal people_filtered
            query = last_name_search_var.get().strip().lower()
            if query:
                people_filtered = [p for p in people_data if p.get('last_name', '').lower().find(query) != -1]
            else:
                people_filtered = None
            populate_people_list()
            # Update right panel based on filtered results
            source = people_filtered if people_filtered is not None else people_data
            if source:
                # Load faces for the first person in the list
                first = source[0]
                try:
                    # Update selection state
                    for child in people_list_inner.winfo_children():
                        for widget in child.winfo_children():
                            if isinstance(widget, ttk.Label):
                                widget.config(font=("Arial", 10))
                    # Bold the first label if present
                    first_row = people_list_inner.winfo_children()[0]
                    for widget in first_row.winfo_children():
                        if isinstance(widget, ttk.Label):
                            widget.config(font=("Arial", 10, "bold"))
                            break
                except Exception:
                    pass
                # Show faces for the first person
                show_person_faces(first['id'], first.get('full_name') or first.get('name') or "")
            else:
                # No matches: clear faces panel
                clear_faces_panel()

        def clear_last_name_filter():
            nonlocal people_filtered
            last_name_search_var.set("")
            people_filtered = None
            populate_people_list()
            # After clearing, load faces for the first available person if any
            if people_data:
                first = people_data[0]
                try:
                    for child in people_list_inner.winfo_children():
                        for widget in child.winfo_children():
                            if isinstance(widget, ttk.Label):
                                widget.config(font=("Arial", 10))
                    first_row = people_list_inner.winfo_children()[0]
                    for widget in first_row.winfo_children():
                        if isinstance(widget, ttk.Label):
                            widget.config(font=("Arial", 10, "bold"))
                            break
                except Exception:
                    pass
                show_person_faces(first['id'], first.get('full_name') or first.get('name') or "")
            else:
                clear_faces_panel()
        
        def clear_faces_panel():
            for w in faces_inner.winfo_children():
                w.destroy()
            # Cleanup temp crops
            for crop in list(temp_crops):
                try:
                    if os.path.exists(crop):
                        os.remove(crop)
                except:
                    pass
            temp_crops.clear()
            right_panel_images.clear()
        
        def unmatch_face(face_id: int):
            """Temporarily unmatch a face from the current person"""
            nonlocal unmatched_faces, unmatched_by_person
            unmatched_faces.add(face_id)
            # Track per-person for Undo
            person_set = unmatched_by_person.get(current_person_id)
            if person_set is None:
                person_set = set()
                unmatched_by_person[current_person_id] = person_set
            person_set.add(face_id)
            # Refresh the display
            show_person_faces(current_person_id, current_person_name)
        
        def undo_changes():
            """Undo all temporary changes"""
            nonlocal unmatched_faces, unmatched_by_person
            if current_person_id in unmatched_by_person:
                for fid in list(unmatched_by_person[current_person_id]):
                    unmatched_faces.discard(fid)
                unmatched_by_person[current_person_id].clear()
            # Refresh the display
            show_person_faces(current_person_id, current_person_name)
        
        def save_changes():
            """Save unmatched faces to database"""
            if not unmatched_faces:
                return
            
            # Confirm with user
            result = messagebox.askyesno(
                "Confirm Changes",
                f"Are you sure you want to unlink {len(unmatched_faces)} face(s) from '{current_person_name}'?\n\n"
                "This will make these faces unidentified again."
            )
            
            if not result:
                return
            
            # Update database
            with self.get_db_connection() as conn:
                cursor = conn.cursor()
                for face_id in unmatched_faces:
                    cursor.execute('UPDATE faces SET person_id = NULL WHERE id = ?', (face_id,))
                conn.commit()
            
            # Store count for message before clearing
            unlinked_count = len(unmatched_faces)
            
            # Clear unmatched faces and refresh
            unmatched_faces.clear()
            original_faces_data.clear()
            
            # Refresh people list to update counts
            load_people()
            populate_people_list()
            
            # Refresh faces display
            show_person_faces(current_person_id, current_person_name)
            
            messagebox.showinfo("Changes Saved", f"Successfully unlinked {unlinked_count} face(s) from '{current_person_name}'.")
        
        def show_person_faces(person_id: int, person_name: str):
            nonlocal current_person_id, current_person_name, unmatched_faces, original_faces_data
            current_person_id = person_id
            current_person_name = person_name
            clear_faces_panel()
            
            # Determine how many columns fit the available width
            available_width = faces_canvas.winfo_width()
            if available_width <= 1:
                available_width = faces_frame.winfo_width()
            tile_width = 150  # approx tile + padding
            cols = max(1, available_width // tile_width)
            
            # Header row
            header = ttk.Label(faces_inner, text=f"Faces for: {person_name}", font=("Arial", 12, "bold"))
            header.grid(row=0, column=0, columnspan=cols, sticky=tk.W, pady=(0, 5))
            
            # Control buttons row
            button_frame = ttk.Frame(faces_inner)
            button_frame.grid(row=1, column=0, columnspan=cols, sticky=tk.W, pady=(0, 10))
            
            # Enable Undo only if current person has unmatched faces
            current_has_unmatched = bool(unmatched_by_person.get(current_person_id))
            undo_btn = ttk.Button(button_frame, text="↶ Undo changes", 
                                command=lambda: undo_changes(),
                                state="disabled" if not current_has_unmatched else "normal")
            undo_btn.pack(side=tk.LEFT, padx=(0, 10))
            
            # Note: Save button moved to bottom control bar
            
            # Query faces for this person
            with self.get_db_connection() as conn:
                cursor = conn.cursor()
                cursor.execute(
                    """
                    SELECT f.id, f.location, ph.path, ph.filename
                    FROM faces f
                    JOIN photos ph ON ph.id = f.photo_id
                    WHERE f.person_id = ?
                    ORDER BY f.id DESC
                    """,
                    (person_id,)
                )
                rows = cursor.fetchall()
            
            # Filter out unmatched faces
            visible_rows = [row for row in rows if row[0] not in unmatched_faces]
            
            if not visible_rows:
                ttk.Label(faces_inner, text="No faces found." if not rows else "All faces unmatched.", foreground="gray").grid(row=2, column=0, sticky=tk.W)
                return
            
            # Grid thumbnails with responsive column count
            row_index = 2  # Start after header and buttons
            col_index = 0
            for face_id, location, photo_path, filename in visible_rows:
                crop_path = self._extract_face_crop(photo_path, location, face_id)
                thumb = None
                if crop_path and os.path.exists(crop_path):
                    try:
                        img = Image.open(crop_path)
                        img.thumbnail((130, 130), Image.Resampling.LANCZOS)
                        photo_img = ImageTk.PhotoImage(img)
                        temp_crops.append(crop_path)
                        right_panel_images.append(photo_img)
                        thumb = photo_img
                    except Exception:
                        thumb = None
                
                tile = ttk.Frame(faces_inner, padding="5")
                tile.grid(row=row_index, column=col_index, padx=5, pady=5, sticky=tk.N)
                
                # Create a frame for the face image with X button overlay
                face_frame = ttk.Frame(tile)
                face_frame.grid(row=0, column=0)
                
                canvas = tk.Canvas(face_frame, width=130, height=130, bg=canvas_bg_color, highlightthickness=0)
                canvas.grid(row=0, column=0)
                if thumb is not None:
                    canvas.create_image(65, 65, image=thumb)
                else:
                    canvas.create_text(65, 65, text="🖼️", fill="gray")
                
                # X button to unmatch face - pin exactly to the canvas' top-right corner
                x_canvas = tk.Canvas(face_frame, width=12, height=12, bg='red', 
                                    highlightthickness=0, relief="flat")
                x_canvas.create_text(6, 6, text="✖", fill="white", font=("Arial", 8, "bold"))
                # Click handler
                x_canvas.bind("<Button-1>", lambda e, fid=face_id: unmatch_face(fid))
                # Hover highlight: change bg, show white outline, and hand cursor
                x_canvas.bind("<Enter>", lambda e, c=x_canvas: c.configure(bg="#cc0000", highlightthickness=1, highlightbackground="white", cursor="hand2"))
                x_canvas.bind("<Leave>", lambda e, c=x_canvas: c.configure(bg="red", highlightthickness=0, cursor=""))
                # Anchor to the canvas' top-right regardless of layout/size
                try:
                    x_canvas.place(in_=canvas, relx=1.0, x=0, y=0, anchor='ne')
                except Exception:
                    # Fallback to absolute coords if relative placement fails
                    x_canvas.place(x=118, y=0)
                
                ttk.Label(tile, text=f"ID {face_id}", foreground="gray").grid(row=1, column=0)
                
                col_index += 1
                if col_index >= cols:
                    col_index = 0
                    row_index += 1
        
        def populate_people_list():
            for w in people_list_inner.winfo_children():
                w.destroy()
            source = people_filtered if people_filtered is not None else people_data
            if not source:
                empty_label = ttk.Label(people_list_inner, text="No people match filter", foreground="gray")
                empty_label.grid(row=0, column=0, sticky=tk.W, pady=4)
                return
            for idx, person in enumerate(source):
                row = ttk.Frame(people_list_inner)
                row.grid(row=idx, column=0, sticky=(tk.W, tk.E), pady=4)
                # Freeze per-row values to avoid late-binding issues
                row_person = person
                row_idx = idx
                
                # Make person name clickable
                def make_click_handler(p_id, p_name, p_idx):
                    def on_click(event):
                        nonlocal selected_person_id
                        # Reset all labels to normal font
                        for child in people_list_inner.winfo_children():
                            for widget in child.winfo_children():
                                if isinstance(widget, ttk.Label):
                                    widget.config(font=("Arial", 10))
                        # Set clicked label to bold
                        event.widget.config(font=("Arial", 10, "bold"))
                        selected_person_id = p_id
                        # Show faces for this person
                        show_person_faces(p_id, p_name)
                    return on_click
                
                
                # Edit (rename) button
                def start_edit_person(row_frame, person_record, row_index):
                    for w in row_frame.winfo_children():
                        w.destroy()
                    
                    # Use pre-loaded data instead of database query
                    cur_first = person_record.get('first_name', '')
                    cur_last = person_record.get('last_name', '')
                    cur_middle = person_record.get('middle_name', '')
                    cur_maiden = person_record.get('maiden_name', '')
                    cur_dob = person_record.get('date_of_birth', '')

                    # Create a larger container frame for the text boxes and labels
                    edit_container = ttk.Frame(row_frame)
                    edit_container.pack(side=tk.LEFT, fill=tk.X, expand=True)
                    
                    # Create a grid layout for better organization
                    # First name field with label
                    first_frame = ttk.Frame(edit_container)
                    first_frame.grid(row=0, column=0, padx=(0, 10), pady=(0, 5), sticky=tk.W)
                    
                    first_var = tk.StringVar(value=cur_first)
                    first_entry = ttk.Entry(first_frame, textvariable=first_var, width=15)
                    first_entry.pack(side=tk.TOP)
                    first_entry.focus_set()
                    
                    first_label = ttk.Label(first_frame, text="First Name", font=("Arial", 8), foreground="gray")
                    first_label.pack(side=tk.TOP, pady=(2, 0))
                    
                    # Last name field with label
                    last_frame = ttk.Frame(edit_container)
                    last_frame.grid(row=0, column=1, padx=(0, 10), pady=(0, 5), sticky=tk.W)
                    
                    last_var = tk.StringVar(value=cur_last)
                    last_entry = ttk.Entry(last_frame, textvariable=last_var, width=15)
                    last_entry.pack(side=tk.TOP)
                    
                    last_label = ttk.Label(last_frame, text="Last Name", font=("Arial", 8), foreground="gray")
                    last_label.pack(side=tk.TOP, pady=(2, 0))
                    
                    # Middle name field with label
                    middle_frame = ttk.Frame(edit_container)
                    middle_frame.grid(row=0, column=2, padx=(0, 10), pady=(0, 5), sticky=tk.W)
                    
                    middle_var = tk.StringVar(value=cur_middle)
                    middle_entry = ttk.Entry(middle_frame, textvariable=middle_var, width=15)
                    middle_entry.pack(side=tk.TOP)
                    
                    middle_label = ttk.Label(middle_frame, text="Middle Name", font=("Arial", 8), foreground="gray")
                    middle_label.pack(side=tk.TOP, pady=(2, 0))
                    
                    # Maiden name field with label
                    maiden_frame = ttk.Frame(edit_container)
                    maiden_frame.grid(row=1, column=0, padx=(0, 10), pady=(0, 5), sticky=tk.W)
                    
                    maiden_var = tk.StringVar(value=cur_maiden)
                    maiden_entry = ttk.Entry(maiden_frame, textvariable=maiden_var, width=15)
                    maiden_entry.pack(side=tk.TOP)
                    
                    maiden_label = ttk.Label(maiden_frame, text="Maiden Name", font=("Arial", 8), foreground="gray")
                    maiden_label.pack(side=tk.TOP, pady=(2, 0))
                    
                    # Date of birth field with label and calendar button
                    dob_frame = ttk.Frame(edit_container)
                    dob_frame.grid(row=1, column=1, columnspan=2, padx=(0, 10), pady=(0, 5), sticky=tk.W)
                    
                    # Create a frame for the date picker
                    date_picker_frame = ttk.Frame(dob_frame)
                    date_picker_frame.pack(side=tk.TOP)
                    
                    dob_var = tk.StringVar(value=cur_dob)
                    dob_entry = ttk.Entry(date_picker_frame, textvariable=dob_var, width=20, state='readonly')
                    dob_entry.pack(side=tk.LEFT, fill=tk.X, expand=True)
                    
                    # Calendar button
                    calendar_btn = ttk.Button(date_picker_frame, text="📅", width=3, command=lambda: open_calendar())
                    calendar_btn.pack(side=tk.RIGHT, padx=(5, 0))
                    
                    dob_label = ttk.Label(dob_frame, text="Date of Birth", font=("Arial", 8), foreground="gray")
                    dob_label.pack(side=tk.TOP, pady=(2, 0))
                    
                    def open_calendar():
                        """Open a visual calendar dialog to select date of birth"""
                        from datetime import datetime, date, timedelta
                        import calendar
                        
                        # Create calendar window
                        calendar_window = tk.Toplevel(root)
                        calendar_window.title("Select Date of Birth")
                        calendar_window.resizable(False, False)
                        calendar_window.transient(root)
                        calendar_window.grab_set()
                        
                        # Calculate center position before showing the window
                        window_width = 400
                        window_height = 400
                        screen_width = calendar_window.winfo_screenwidth()
                        screen_height = calendar_window.winfo_screenheight()
                        x = (screen_width // 2) - (window_width // 2)
                        y = (screen_height // 2) - (window_height // 2)
                        
                        # Set geometry with center position before showing
                        calendar_window.geometry(f"{window_width}x{window_height}+{x}+{y}")
                        
                        # Calendar variables
                        current_date = datetime.now()
                        
                        # Check if there's already a date selected
                        existing_date_str = dob_var.get().strip()
                        if existing_date_str:
                            try:
                                existing_date = datetime.strptime(existing_date_str, '%Y-%m-%d').date()
                                display_year = existing_date.year
                                display_month = existing_date.month
                                selected_date = existing_date
                            except ValueError:
                                # If existing date is invalid, use default
                                display_year = current_date.year - 25
                                display_month = 1
                                selected_date = None
                        else:
                            # Default to 25 years ago
                            display_year = current_date.year - 25
                            display_month = 1
                            selected_date = None
                        
                        # Month names
                        month_names = ["January", "February", "March", "April", "May", "June",
                                      "July", "August", "September", "October", "November", "December"]
                        
                        # Configure custom styles for better visual highlighting
                        style = ttk.Style()
                        
                        # Selected date style - bright blue background with white text
                        style.configure("Selected.TButton", 
                                      background="#0078d4", 
                                      foreground="white",
                                      font=("Arial", 9, "bold"),
                                      relief="raised",
                                      borderwidth=2)
                        style.map("Selected.TButton",
                                 background=[("active", "#106ebe")],
                                 relief=[("pressed", "sunken")])
                        
                        # Today's date style - orange background
                        style.configure("Today.TButton",
                                      background="#ff8c00",
                                      foreground="white", 
                                      font=("Arial", 9, "bold"),
                                      relief="raised",
                                      borderwidth=1)
                        style.map("Today.TButton",
                                 background=[("active", "#e67e00")],
                                 relief=[("pressed", "sunken")])
                        
                        # Calendar-specific normal button style (don't affect global TButton)
                        style.configure("Calendar.TButton",
                                      font=("Arial", 9),
                                      relief="flat")
                        style.map("Calendar.TButton",
                                 background=[("active", "#e1e1e1")],
                                 relief=[("pressed", "sunken")])
                        
                        # Main frame
                        main_cal_frame = ttk.Frame(calendar_window, padding="10")
                        main_cal_frame.pack(fill=tk.BOTH, expand=True)
                        
                        # Header frame with navigation
                        header_frame = ttk.Frame(main_cal_frame)
                        header_frame.pack(fill=tk.X, pady=(0, 10))
                        
                        # Month/Year display and navigation
                        nav_frame = ttk.Frame(header_frame)
                        nav_frame.pack()
                        
                        def update_calendar():
                            """Update the calendar display"""
                            # Clear existing calendar
                            for widget in calendar_frame.winfo_children():
                                widget.destroy()
                            
                            # Update header
                            month_year_label.config(text=f"{month_names[display_month-1]} {display_year}")
                            
                            # Get calendar data
                            cal = calendar.monthcalendar(display_year, display_month)
                            
                            # Day headers
                            day_headers = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
                            for i, day in enumerate(day_headers):
                                label = ttk.Label(calendar_frame, text=day, font=("Arial", 9, "bold"))
                                label.grid(row=0, column=i, padx=1, pady=1, sticky="nsew")
                            
                            # Calendar days
                            for week_num, week in enumerate(cal):
                                for day_num, day in enumerate(week):
                                    if day == 0:
                                        # Empty cell
                                        label = ttk.Label(calendar_frame, text="")
                                        label.grid(row=week_num+1, column=day_num, padx=1, pady=1, sticky="nsew")
                                    else:
                                        # Day button
                                        def make_day_handler(day_value):
                                            def select_day():
                                                nonlocal selected_date
                                                selected_date = date(display_year, display_month, day_value)
                                                # Reset all buttons to normal calendar style
                                                for widget in calendar_frame.winfo_children():
                                                    if isinstance(widget, ttk.Button):
                                                        widget.config(style="Calendar.TButton")
                                                # Highlight selected day with prominent style
                                                for widget in calendar_frame.winfo_children():
                                                    if isinstance(widget, ttk.Button) and widget.cget("text") == str(day_value):
                                                        widget.config(style="Selected.TButton")
                                            return select_day
                                        
                                        day_btn = ttk.Button(calendar_frame, text=str(day), 
                                                           command=make_day_handler(day),
                                                           width=3, style="Calendar.TButton")
                                        day_btn.grid(row=week_num+1, column=day_num, padx=1, pady=1, sticky="nsew")
                                        
                                        # Check if this day should be highlighted
                                        is_today = (display_year == current_date.year and 
                                                   display_month == current_date.month and 
                                                   day == current_date.day)
                                        is_selected = (selected_date and 
                                                     selected_date.year == display_year and 
                                                     selected_date.month == display_month and 
                                                     selected_date.day == day)
                                        
                                        if is_selected:
                                            day_btn.config(style="Selected.TButton")
                                        elif is_today:
                                            day_btn.config(style="Today.TButton")
                        
                        # Navigation functions
                        def prev_year():
                            nonlocal display_year
                            display_year = max(1900, display_year - 1)
                            update_calendar()
                        
                        def next_year():
                            nonlocal display_year
                            display_year = min(current_date.year, display_year + 1)
                            update_calendar()
                        
                        def prev_month():
                            nonlocal display_month, display_year
                            if display_month > 1:
                                display_month -= 1
                            else:
                                display_month = 12
                                display_year = max(1900, display_year - 1)
                            update_calendar()
                        
                        def next_month():
                            nonlocal display_month, display_year
                            if display_month < 12:
                                display_month += 1
                            else:
                                display_month = 1
                                display_year = min(current_date.year, display_year + 1)
                            update_calendar()
                        
                        # Navigation buttons
                        prev_year_btn = ttk.Button(nav_frame, text="<<", width=3, command=prev_year)
                        prev_year_btn.pack(side=tk.LEFT, padx=(0, 2))
                        
                        prev_month_btn = ttk.Button(nav_frame, text="<", width=3, command=prev_month)
                        prev_month_btn.pack(side=tk.LEFT, padx=(0, 5))
                        
                        month_year_label = ttk.Label(nav_frame, text="", font=("Arial", 12, "bold"))
                        month_year_label.pack(side=tk.LEFT, padx=5)
                        
                        next_month_btn = ttk.Button(nav_frame, text=">", width=3, command=next_month)
                        next_month_btn.pack(side=tk.LEFT, padx=(5, 2))
                        
                        next_year_btn = ttk.Button(nav_frame, text=">>", width=3, command=next_year)
                        next_year_btn.pack(side=tk.LEFT)
                        
                        # Calendar grid frame
                        calendar_frame = ttk.Frame(main_cal_frame)
                        calendar_frame.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
                        
                        # Configure grid weights
                        for i in range(7):
                            calendar_frame.columnconfigure(i, weight=1)
                        for i in range(7):
                            calendar_frame.rowconfigure(i, weight=1)
                        
                        # Buttons frame
                        buttons_frame = ttk.Frame(main_cal_frame)
                        buttons_frame.pack(fill=tk.X)
                        
                        def select_date():
                            """Select the date and close calendar"""
                            if selected_date:
                                date_str = selected_date.strftime('%Y-%m-%d')
                                dob_var.set(date_str)
                                calendar_window.destroy()
                            else:
                                messagebox.showwarning("No Date Selected", "Please select a date from the calendar.")
                        
                        def cancel_selection():
                            """Cancel date selection"""
                            calendar_window.destroy()
                        
                        # Buttons
                        ttk.Button(buttons_frame, text="Select", command=select_date).pack(side=tk.LEFT, padx=(0, 5))
                        ttk.Button(buttons_frame, text="Cancel", command=cancel_selection).pack(side=tk.LEFT)
                        
                        # Initialize calendar
                        update_calendar()
                    
                    def save_rename():
                        new_first = first_var.get().strip()
                        new_last = last_var.get().strip()
                        new_middle = middle_var.get().strip()
                        new_maiden = maiden_var.get().strip()
                        new_dob = dob_var.get().strip()
                        
                        if not new_first and not new_last:
                            messagebox.showwarning("Invalid name", "At least one of First or Last name must be provided.")
                            return
                        
                        # Check for duplicates in local data first (based on first and last name only)
                        for person in people_data:
                            if person['id'] != person_record['id'] and person['first_name'] == new_first and person['last_name'] == new_last:
                                display_name = f"{new_last}, {new_first}".strip(", ").strip()
                                messagebox.showwarning("Duplicate name", f"A person named '{display_name}' already exists.")
                                return
                        
                        # Single database access - save to database
                        with self.get_db_connection() as conn:
                            cursor = conn.cursor()
                            cursor.execute('UPDATE people SET first_name = ?, last_name = ?, middle_name = ?, maiden_name = ?, date_of_birth = ? WHERE id = ?', 
                                         (new_first, new_last, new_middle, new_maiden, new_dob, person_record['id']))
                            conn.commit()
                        
                        # Update local data structure
                        person_record['first_name'] = new_first
                        person_record['last_name'] = new_last
                        person_record['middle_name'] = new_middle
                        person_record['maiden_name'] = new_maiden
                        person_record['date_of_birth'] = new_dob
                        
                        # Recreate the full display name with all available information
                        name_parts = []
                        if new_first:
                            name_parts.append(new_first)
                        if new_middle:
                            name_parts.append(new_middle)
                        if new_last:
                            name_parts.append(new_last)
                        if new_maiden:
                            name_parts.append(f"({new_maiden})")
                        
                        full_name = ' '.join(name_parts) if name_parts else "Unknown"
                        
                        # Create detailed display with date of birth if available
                        display_name = full_name
                        if new_dob:
                            display_name += f" - Born: {new_dob}"
                        
                        person_record['name'] = display_name
                        person_record['full_name'] = full_name
                        
                        # Refresh list
                        current_selected_id = person_record['id']
                        populate_people_list()
                        # Reselect and refresh right panel header if needed
                        if selected_person_id == current_selected_id or selected_person_id is None:
                            # Find updated name
                            updated = next((p for p in people_data if p['id'] == current_selected_id), None)
                            if updated:
                                # Bold corresponding label
                                for child in people_list_inner.winfo_children():
                                    # child is row frame: contains label and button
                                    widgets = child.winfo_children()
                                    if not widgets:
                                        continue
                                    lbl = widgets[0]
                                    if isinstance(lbl, ttk.Label) and lbl.cget('text').startswith(updated['name'] + " ("):
                                        lbl.config(font=("Arial", 10, "bold"))
                                        break
                                # Update right panel header by re-showing faces
                                show_person_faces(updated['id'], updated['name'])
                        
                    def cancel_edit():
                        # Rebuild the row back to label + edit
                        for w in row_frame.winfo_children():
                            w.destroy()
                        rebuild_row(row_frame, person_record, row_index)
                    
                    save_btn = ttk.Button(row_frame, text="💾", width=3, command=save_rename)
                    save_btn.pack(side=tk.LEFT, padx=(5, 0))
                    cancel_btn = ttk.Button(row_frame, text="✖", width=3, command=cancel_edit)
                    cancel_btn.pack(side=tk.LEFT, padx=(5, 0))
                    
                    # Configure custom disabled button style for better visibility
                    style = ttk.Style()
                    style.configure("Disabled.TButton",
                                  background="#d3d3d3",  # Light gray background
                                  foreground="#808080",  # Dark gray text
                                  relief="flat",
                                  borderwidth=1)
                    
                    def validate_save_button():
                        """Enable/disable save button based on required fields"""
                        first_val = first_var.get().strip()
                        last_val = last_var.get().strip()
                        dob_val = dob_var.get().strip()
                        
                        # Enable save button only if both name fields and date of birth are provided
                        has_first = bool(first_val)
                        has_last = bool(last_val)
                        has_dob = bool(dob_val)
                        
                        if has_first and has_last and has_dob:
                            save_btn.config(state="normal")
                            # Reset to normal styling when enabled
                            save_btn.config(style="TButton")
                        else:
                            save_btn.config(state="disabled")
                            # Apply custom disabled styling for better visibility
                            save_btn.config(style="Disabled.TButton")
                    
                    # Set up validation callbacks for all input fields
                    first_var.trace('w', lambda *args: validate_save_button())
                    last_var.trace('w', lambda *args: validate_save_button())
                    middle_var.trace('w', lambda *args: validate_save_button())
                    maiden_var.trace('w', lambda *args: validate_save_button())
                    dob_var.trace('w', lambda *args: validate_save_button())
                    
                    # Initial validation
                    validate_save_button()
                    
                    # Keyboard shortcuts (only work when save button is enabled)
                    def try_save():
                        if save_btn.cget('state') == 'normal':
                            save_rename()
                    
                    first_entry.bind('<Return>', lambda e: try_save())
                    last_entry.bind('<Return>', lambda e: try_save())
                    middle_entry.bind('<Return>', lambda e: try_save())
                    maiden_entry.bind('<Return>', lambda e: try_save())
                    dob_entry.bind('<Return>', lambda e: try_save())
                    first_entry.bind('<Escape>', lambda e: cancel_edit())
                    last_entry.bind('<Escape>', lambda e: cancel_edit())
                    middle_entry.bind('<Escape>', lambda e: cancel_edit())
                    maiden_entry.bind('<Escape>', lambda e: cancel_edit())
                    dob_entry.bind('<Escape>', lambda e: cancel_edit())
                
                def rebuild_row(row_frame, p, i):
                    # Edit button (on the left)
                    edit_btn = ttk.Button(row_frame, text="✏️", width=3, command=lambda r=row_frame, pr=p, ii=i: start_edit_person(r, pr, ii))
                    edit_btn.pack(side=tk.LEFT, padx=(0, 5))
                    # Add tooltip to edit button
                    ToolTip(edit_btn, "Update name")
                    # Label (clickable) - takes remaining space
                    name_lbl = ttk.Label(row_frame, text=f"{p['name']} ({p['count']})", font=("Arial", 10))
                    name_lbl.pack(side=tk.LEFT, fill=tk.X, expand=True)
                    name_lbl.bind("<Button-1>", make_click_handler(p['id'], p['name'], i))
                    name_lbl.config(cursor="hand2")
                    # Bold if selected
                    if (selected_person_id is None and i == 0) or (selected_person_id == p['id']):
                        name_lbl.config(font=("Arial", 10, "bold"))
                
                # Build row contents with edit button
                rebuild_row(row, row_person, row_idx)
        
        # Initial load
        load_people()
        populate_people_list()
        
        # Show first person's faces by default and mark selected
        if people_data:
            selected_person_id = people_data[0]['id']
            show_person_faces(people_data[0]['id'], people_data[0]['name'])
        
        # Control buttons
        control_frame = ttk.Frame(main_frame)
        control_frame.grid(row=3, column=0, columnspan=2, pady=(10, 0), sticky=tk.E)
        
        def on_quit():
            nonlocal window_destroyed
            on_closing()
            if not window_destroyed:
                window_destroyed = True
                try:
                    root.destroy()
                except tk.TclError:
                    pass  # Window already destroyed
        
        def on_save_all_changes():
            # Use global unmatched_faces set; commit all across people
            nonlocal unmatched_faces
            if not unmatched_faces:
                messagebox.showinfo("Nothing to Save", "There are no pending changes to save.")
                return
            result = messagebox.askyesno(
                "Confirm Save",
                f"Unlink {len(unmatched_faces)} face(s) across all people?\n\nThis will make them unidentified."
            )
            if not result:
                return
            with self.get_db_connection() as conn:
                cursor = conn.cursor()
                for face_id in unmatched_faces:
                    cursor.execute('UPDATE faces SET person_id = NULL WHERE id = ?', (face_id,))
                conn.commit()
            count = len(unmatched_faces)
            unmatched_faces.clear()
            # Refresh people list and right panel for current selection
            load_people()
            populate_people_list()
            if current_person_id is not None and current_person_name:
                show_person_faces(current_person_id, current_person_name)
            messagebox.showinfo("Changes Saved", f"Successfully unlinked {count} face(s).")

        save_btn_bottom = ttk.Button(control_frame, text="💾 Save changes", command=on_save_all_changes)
        save_btn_bottom.pack(side=tk.RIGHT, padx=(0, 10))
        quit_btn = ttk.Button(control_frame, text="❌ Quit", command=on_quit)
        quit_btn.pack(side=tk.RIGHT)
        
        # Show the window
        try:
            root.deiconify()
            root.lift()
            root.focus_force()
        except tk.TclError:
            # Window was destroyed before we could show it
            return 0
        
        # Main event loop
        try:
            root.mainloop()
        except tk.TclError:
            pass  # Window was destroyed
        
        return 0


def main():
    """Main CLI interface"""
    parser = argparse.ArgumentParser(
        description="PunimTag CLI - Simple photo face tagger",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  photo_tagger.py scan /path/to/photos          # Scan folder for photos
  photo_tagger.py process --limit 20            # Process 20 photos for faces  
  photo_tagger.py identify --batch 10           # Identify 10 faces interactively
  photo_tagger.py auto-match                    # Auto-identify matching faces
  photo_tagger.py modifyidentified              # Show and Modify identified faces
  photo_tagger.py match 15                      # Find faces similar to face ID 15
  photo_tagger.py tag --pattern "vacation"      # Tag photos matching pattern
  photo_tagger.py search "John"                 # Find photos with John
  photo_tagger.py stats                         # Show statistics
        """
    )
    
    parser.add_argument('command', 
                       choices=['scan', 'process', 'identify', 'tag', 'search', 'stats', 'match', 'auto-match', 'modifyidentified'],
                       help='Command to execute')
    
    parser.add_argument('target', nargs='?', 
                       help='Target folder (scan), person name (search), or pattern (tag)')
    
    parser.add_argument('--db', default='data/photos.db', 
                       help='Database file path (default: data/photos.db)')
    
    parser.add_argument('--limit', type=int, default=50,
                       help='Batch size limit for processing (default: 50)')
    
    parser.add_argument('--batch', type=int, default=20,
                       help='Batch size for identification (default: 20)')
    
    parser.add_argument('--pattern', 
                       help='Pattern for filtering photos when tagging')
    
    parser.add_argument('--model', choices=['hog', 'cnn'], default='hog',
                       help='Face detection model: hog (faster) or cnn (more accurate)')
    
    parser.add_argument('--recursive', action='store_true',
                       help='Scan folders recursively')
    
    parser.add_argument('--show-faces', action='store_true',
                       help='Show individual face crops during identification')
    
    parser.add_argument('--tolerance', type=float, default=0.5,
                       help='Face matching tolerance (0.0-1.0, lower = stricter, default: 0.5)')
    
    parser.add_argument('--auto', action='store_true',
                       help='Auto-identify high-confidence matches without confirmation')
    
    parser.add_argument('--include-twins', action='store_true',
                       help='Include same-photo matching (for twins or multiple instances)')
    
    parser.add_argument('-v', '--verbose', action='count', default=0,
                       help='Increase verbosity (-v, -vv, -vvv for more detail)')
    
    parser.add_argument('--debug', action='store_true',
                       help='Enable line-by-line debugging with pdb')
    
    args = parser.parse_args()
    
    # Initialize tagger
    tagger = PhotoTagger(args.db, args.verbose, args.debug)
    
    try:
        if args.command == 'scan':
            if not args.target:
                print("❌ Please specify a folder to scan")
                return 1
            tagger.scan_folder(args.target, args.recursive)
        
        elif args.command == 'process':
            tagger.process_faces(args.limit, args.model)
        
        elif args.command == 'identify':
            show_faces = getattr(args, 'show_faces', False)
            tagger.identify_faces(args.batch, show_faces, args.tolerance)
        
        elif args.command == 'tag':
            tagger.add_tags(args.pattern or args.target, args.batch)
        
        elif args.command == 'search':
            if not args.target:
                print("❌ Please specify a person name to search for")
                return 1
            tagger.search_faces(args.target)
        
        elif args.command == 'stats':
            tagger.stats()
        
        elif args.command == 'match':
            if args.target and args.target.isdigit():
                face_id = int(args.target)
                matches = tagger.find_similar_faces(face_id, args.tolerance)
                if matches:
                    print(f"\n🎯 Found {len(matches)} similar faces:")
                    for match in matches:
                        person_name = "Unknown" if match['person_id'] is None else f"Person ID {match['person_id']}"
                        print(f"   📸 {match['filename']} - {person_name} (confidence: {(1-match['distance']):.1%})")
                else:
                    print("🔍 No similar faces found")
            else:
                print("❌ Please specify a face ID number to find matches for")
        
        elif args.command == 'auto-match':
            show_faces = getattr(args, 'show_faces', False)
            include_twins = getattr(args, 'include_twins', False)
            tagger.auto_identify_matches(args.tolerance, not args.auto, show_faces, include_twins)
        
        elif args.command == 'modifyidentified':
            tagger.modifyidentified()
        
        return 0
        
    except KeyboardInterrupt:
        print("\n\n⚠️  Interrupted by user")
        return 1
    except Exception as e:
        print(f"❌ Error: {e}")
        return 1
    finally:
        # Always cleanup resources
        tagger.cleanup()


if __name__ == "__main__":
    sys.exit(main())