import cv2
import face_recognition
import numpy as np
import pickle
 
class FaceRecognitionSystem:
    def __init__(self):
        self.known_face_encodings = []
        self.known_face_names = []
        self.face_locations = []
        self.face_encodings = []
        self.face_names = []
        self.process_this_frame = True
        
    def load_known_faces(self, encodings_file):
        """Load pre-computed face encodings from file"""
        try:
            with open(encodings_file, 'rb') as f:
                data = pickle.load(f)
                self.known_face_encodings = data['encodings']
                self.known_face_names = data['names']
            print(f"Loaded {len(self.known_face_names)} known faces")
        except FileNotFoundError:
            print("No existing encodings found. Starting fresh.")
    
    def process_frame(self, frame):
        """Process a single frame for face recognition"""
        # Resize frame for faster processing
        small_frame = cv2.resize(frame, (0, 0), fx=0.25, fy=0.25)
        rgb_small_frame = small_frame[:, :, ::-1]
        
        if self.process_this_frame:
            # Find all faces and encodings in current frame
            self.face_locations = face_recognition.face_locations(rgb_small_frame)
            self.face_encodings = face_recognition.face_encodings(
                rgb_small_frame, self.face_locations
            )
            
            self.face_names = []
            for face_encoding in self.face_encodings:
                matches = face_recognition.compare_faces(
                    self.known_face_encodings, face_encoding, tolerance=0.6
                )
                name = "Unknown"
                confidence = 0
                
                # Use the known face with smallest distance
                face_distances = face_recognition.face_distance(
                    self.known_face_encodings, face_encoding
                )
                
                if len(face_distances) > 0:
                    best_match_index = np.argmin(face_distances)
                    if matches[best_match_index]:
                        name = self.known_face_names[best_match_index]
                        confidence = 1 - face_distances[best_match_index]
                
                self.face_names.append((name, confidence))
        
        # Process every other frame for performance
        self.process_this_frame = not self.process_this_frame
        
        return self.draw_results(frame)

def generate_face_encoding(self, image_path, name):
    """Generate face encoding from an image file"""
    # Load image
    image = face_recognition.load_image_file(image_path)
    
    # Find face locations
    face_locations = face_recognition.face_locations(image)
    
    if len(face_locations) == 0:
        raise ValueError(f"No faces found in {image_path}")
    
    if len(face_locations) > 1:
        print(f"Warning: Multiple faces found in {image_path}. Using the first one.")
    
    # Generate encoding
    face_encodings = face_recognition.face_encodings(image, face_locations)
    
    if len(face_encodings) > 0:
        return face_encodings[0]
    else:
        raise ValueError(f"Could not generate encoding for {image_path}")
 
def add_person(self, image_paths, name):
    """Add a new person to the recognition system"""
    encodings = []
    
    for image_path in image_paths:
        try:
            encoding = self.generate_face_encoding(image_path, name)
            encodings.append(encoding)
        except ValueError as e:
            print(f"Error processing {image_path}: {e}")
    
    if encodings:
        # Average multiple encodings for better accuracy
        if len(encodings) > 1:
            average_encoding = np.mean(encodings, axis=0)
        else:
            average_encoding = encodings[0]
        
        self.known_face_encodings.append(average_encoding)
        self.known_face_names.append(name)
        
        # Save updated encodings
        self.save_encodings()
        print(f"Added {name} to the system with {len(encodings)} encoding(s)")

def start_video_recognition(self):
    """Start real-time face recognition from webcam"""
    video_capture = cv2.VideoCapture(0)
    
    # Set camera properties for better performance
    video_capture.set(cv2.CAP_PROP_FRAME_WIDTH, 640)
    video_capture.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
    video_capture.set(cv2.CAP_PROP_FPS, 30)
    
    while True:
        ret, frame = video_capture.read()
        
        if not ret:
            print("Failed to grab frame")
            break
        
        # Process frame
        processed_frame = self.process_frame(frame)
        
        # Display result
        cv2.imshow('FaceQuest - Face Recognition', processed_frame)
        
        # Break on 'q' key press
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break
    
    video_capture.release()
    cv2.destroyAllWindows()

class OptimizedProcessor:
    def __init__(self, skip_frames=2):
        self.skip_frames = skip_frames
        self.frame_count = 0
        self.last_results = []
    
    def should_process_frame(self):
        self.frame_count += 1
        return self.frame_count % (self.skip_frames + 1) == 0
    
    def process_optimized(self, frame):
        if self.should_process_frame():
            # Process this frame
            self.last_results = self.full_process(frame)
        
        # Use cached results for skipped frames
        return self.apply_cached_results(frame, self.last_results)

import threading
from queue import Queue
 
class ThreadedProcessor:
    def __init__(self):
        self.frame_queue = Queue(maxsize=5)
        self.result_queue = Queue(maxsize=5)
        self.processing_thread = None
        self.running = False
    
    def start_processing_thread(self):
        self.running = True
        self.processing_thread = threading.Thread(target=self._process_frames)
        self.processing_thread.start()
    
    def _process_frames(self):
        while self.running:
            if not self.frame_queue.empty():
                frame = self.frame_queue.get()
                result = self.process_frame(frame)
                
                if not self.result_queue.full():
                    self.result_queue.put(result)

def detect_liveness(self, face_region):
    """Simple liveness detection using texture analysis"""
    # Convert to grayscale
    gray = cv2.cvtColor(face_region, cv2.COLOR_BGR2GRAY)
    
    # Calculate texture variance
    variance = cv2.Laplacian(gray, cv2.CV_64F).var()
    
    # Real faces have higher texture variance than photos
    return variance > 100  # Threshold determined experimentally
 
def enhanced_recognition(self, frame, face_location, face_encoding):
    """Enhanced recognition with liveness detection"""
    top, right, bottom, left = face_location
    face_region = frame[top:bottom, left:right]
    
    # Check if it's a real face
    is_live = self.detect_liveness(face_region)
    
    if not is_live:
        return "SPOOFING_DETECTED", 0.0
    
    # Proceed with normal recognition
    return self.recognize_face(face_encoding)

def calculate_confidence_score(self, face_distance, threshold=0.6):
    """Convert face distance to confidence percentage"""
    if face_distance > threshold:
        return 0.0
    
    # Linear mapping: distance 0 = 100% confidence, threshold = 0% confidence
    confidence = (1 - (face_distance / threshold)) * 100
    return min(100, max(0, confidence))
 
def get_recognition_result(self, face_encoding):
    """Get recognition result with confidence score"""
    if len(self.known_face_encodings) == 0:
        return "No known faces", 0.0
    
    face_distances = face_recognition.face_distance(
        self.known_face_encodings, face_encoding
    )
    
    best_match_index = np.argmin(face_distances)
    best_distance = face_distances[best_match_index]
    
    confidence = self.calculate_confidence_score(best_distance)
    
    if confidence > 50:  # Minimum confidence threshold
        name = self.known_face_names[best_match_index]
        return name, confidence
    else:
        return "Unknown", confidence

import sqlite3
import json
 
class FaceDatabase:
    def __init__(self, db_path="faces.db"):
        self.db_path = db_path
        self.init_database()
    
    def init_database(self):
        """Initialize the face database"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        cursor.execute('''
            CREATE TABLE IF NOT EXISTS faces (
                id INTEGER PRIMARY KEY AUTOINCREMENT,
                name TEXT NOT NULL,
                encoding BLOB NOT NULL,
                created_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
                last_seen TIMESTAMP,
                confidence_history TEXT
            )
        ''')
        
        conn.commit()
        conn.close()
    
    def add_face(self, name, encoding):
        """Add a new face to the database"""
        conn = sqlite3.connect(self.db_path)
        cursor = conn.cursor()
        
        # Serialize encoding
        encoding_blob = pickle.dumps(encoding)
        
        cursor.execute('''
            INSERT INTO faces (name, encoding) VALUES (?, ?)
        ''', (name, encoding_blob))
        
        conn.commit()
        conn.close()

import tkinter as tk
from tkinter import filedialog, messagebox
import threading
 
class FaceQuestGUI:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("FaceQuest - Face Recognition System")
        self.recognition_system = FaceRecognitionSystem()
        self.setup_ui()
    
    def setup_ui(self):
        # Main frame
        main_frame = tk.Frame(self.root)
        main_frame.pack(padx=20, pady=20)
        
        # Add person button
        add_button = tk.Button(
            main_frame, 
            text="Add New Person", 
            command=self.add_person_dialog,
            bg="#4CAF50",
            fg="white",
            font=("Arial", 12),
            padx=20,
            pady=10
        )
        add_button.pack(pady=10)
        
        # Start recognition button
        start_button = tk.Button(
            main_frame,
            text="Start Recognition",
            command=self.start_recognition,
            bg="#2196F3",
            fg="white",
            font=("Arial", 12),
            padx=20,
            pady=10
        )
        start_button.pack(pady=10)
        
        # Status label
        self.status_label = tk.Label(
            main_frame,
            text="Ready to start face recognition",
            font=("Arial", 10)
        )
        self.status_label.pack(pady=10)