# AI Smart Camera - Main Application
import cv2
import numpy as np
from ultralytics import YOLO
import mediapipe as mp
import threading
import time
import requests
import json
from datetime import datetime
import RPi.GPIO as GPIO

class AISmartCamera:
    def __init__(self):
        print("🤖 Initializing AI Smart Camera...")
        
        # Initialize YOLO model
        self.yolo_model = YOLO('yolov8n.pt')
        
        # Initialize MediaPipe
        self.mp_face = mp.solutions.face_detection
        self.face_detection = self.mp_face.FaceDetection(
            model_selection=0, min_detection_confidence=0.5
        )
        self.mp_draw = mp.solutions.drawing_utils
        
        # Initialize camera
        self.cap = cv2.VideoCapture(0)
        self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 1280)
        self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 720)
        self.cap.set(cv2.CAP_PROP_FPS, 30)
        
        # Initialize PIR sensor
        self.PIR_PIN = 18
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(self.PIR_PIN, GPIO.IN)
        
        # Configuration
        self.LINE_TOKEN = "YOUR_LINE_NOTIFY_TOKEN"
        self.CONFIDENCE_THRESHOLD = 0.5
        self.ALERT_COOLDOWN = 30  # seconds
        
        # State variables
        self.last_alert_time = 0
        self.detected_objects = []
        self.known_faces = self.load_known_faces()
        self.recording = False
        
        print("✅ AI Smart Camera initialized successfully!")
    
    def load_known_faces(self):
        """โหลดใบหน้าที่รู้จัก"""
        try:
            with open('known_faces.json', 'r') as f:
                return json.load(f)
        except FileNotFoundError:
            print("⚠️ Known faces file not found, creating new one")
            return {}
    
    def save_known_faces(self):
        """บันทึกใบหน้าที่รู้จัก"""
        with open('known_faces.json', 'w') as f:
            json.dump(self.known_faces, f)
    
    def detect_objects(self, frame):
        """ตรวจจับวัตถุด้วย YOLO"""
        results = self.yolo_model(frame, verbose=False)
        detections = []
        
        for result in results:
            boxes = result.boxes
            if boxes is not None:
                for box in boxes:
                    # Get coordinates and confidence
                    x1, y1, x2, y2 = box.xyxy[0].cpu().numpy()
                    confidence = box.conf[0].cpu().numpy()
                    class_id = int(box.cls[0].cpu().numpy())
                    
                    if confidence > self.CONFIDENCE_THRESHOLD:
                        class_name = self.yolo_model.names[class_id]
                        detections.append({
                            'bbox': [int(x1), int(y1), int(x2), int(y2)],
                            'confidence': float(confidence),
                            'class': class_name,
                            'class_id': class_id
                        })
                        
                        # Draw bounding box
                        cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), (0, 255, 0), 2)
                        cv2.putText(frame, f'{class_name}: {confidence:.2f}', 
                                   (int(x1), int(y1)-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
        
        return detections, frame
    
    def detect_faces(self, frame):
        """ตรวจจับใบหน้าด้วย MediaPipe"""
        rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
        results = self.face_detection.process(rgb_frame)
        
        faces = []
        if results.detections:
            for detection in results.detections:
                bboxC = detection.location_data.relative_bounding_box
                ih, iw, _ = frame.shape
                
                # Convert to absolute coordinates
                x = int(bboxC.xmin * iw)
                y = int(bboxC.ymin * ih)
                w = int(bboxC.width * iw)
                h = int(bboxC.height * ih)
                
                faces.append({
                    'bbox': [x, y, x+w, y+h],
                    'confidence': detection.score[0]
                })
                
                # Draw face rectangle
                cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
                cv2.putText(frame, f'Face: {detection.score[0]:.2f}', 
                           (x, y-10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 0, 0), 2)
        
        return faces, frame
    
    def check_motion_sensor(self):
        """ตรวจสอบ PIR Motion Sensor"""
        return GPIO.input(self.PIR_PIN)
    
    def send_line_notification(self, message, image_path=None):
        """ส่งการแจ้งเตือนผ่าน LINE"""
        try:
            url = 'https://notify-api.line.me/api/notify'
            headers = {'Authorization': f'Bearer {self.LINE_TOKEN}'}
            
            data = {'message': message}
            files = None
            
            if image_path:
                files = {'imageFile': open(image_path, 'rb')}
            
            response = requests.post(url, headers=headers, data=data, files=files)
            
            if files:
                files['imageFile'].close()
                
            return response.status_code == 200
            
        except Exception as e:
            print(f"❌ LINE notification error: {e}")
            return False
    
    def should_send_alert(self, detections):
        """ตรวจสอบว่าควรส่งการแจ้งเตือนหรือไม่"""
        current_time = time.time()
        
        # Check cooldown
        if current_time - self.last_alert_time < self.ALERT_COOLDOWN:
            return False
        
        # Check for important objects
        important_classes = ['person', 'car', 'truck', 'bicycle', 'motorcycle']
        
        for detection in detections:
            if detection['class'] in important_classes:
                if detection['confidence'] > 0.7:
                    return True
        
        return False
    
    def save_alert_image(self, frame):
        """บันทึกภาพเมื่อมีการแจ้งเตือน"""
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"alert_{timestamp}.jpg"
        cv2.imwrite(filename, frame)
        return filename
    
    def process_frame(self, frame):
        """ประมวลผลเฟรมหลัก"""
        # Detect objects
        object_detections, frame = self.detect_objects(frame)
        
        # Detect faces
        face_detections, frame = self.detect_faces(frame)
        
        # Check motion sensor
        motion_detected = self.check_motion_sensor()
        
        # Add motion indicator
        motion_color = (0, 255, 0) if motion_detected else (0, 0, 255)
        cv2.circle(frame, (30, 30), 10, motion_color, -1)
        cv2.putText(frame, "MOTION" if motion_detected else "NO MOTION", 
                   (50, 35), cv2.FONT_HERSHEY_SIMPLEX, 0.5, motion_color, 2)
        
        # Check for alerts
        if motion_detected and self.should_send_alert(object_detections):
            self.last_alert_time = time.time()
            
            # Save alert image
            alert_image = self.save_alert_image(frame)
            
            # Create alert message
            detected_objects = [det['class'] for det in object_detections]
            message = f"🚨 Motion Alert!\n"
            message += f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
            message += f"Objects: {', '.join(set(detected_objects))}\n"
            message += f"Faces: {len(face_detections)} detected"
            
            # Send notification
            threading.Thread(
                target=self.send_line_notification,
                args=(message, alert_image)
            ).start()
            
            print(f"🚨 Alert sent: {message}")
        
        # Add timestamp
        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        cv2.putText(frame, timestamp, (10, frame.shape[0]-10), 
                   cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
        
        return frame
    
    def run(self):
        """เริ่มการทำงานหลัก"""
        print("🚀 Starting AI Smart Camera...")
        
        try:
            while True:
                ret, frame = self.cap.read()
                if not ret:
                    print("❌ Failed to read frame")
                    break
                
                # Process frame
                processed_frame = self.process_frame(frame)
                
                # Display frame
                cv2.imshow('AI Smart Camera', processed_frame)
                
                # Exit on 'q' key
                if cv2.waitKey(1) & 0xFF == ord('q'):
                    break
                    
        except KeyboardInterrupt:
            print("\n⏹️ Camera stopped by user")
        except Exception as e:
            print(f"❌ Runtime error: {e}")
        finally:
            self.cleanup()
    
    def cleanup(self):
        """ทำความสะอาดทรัพยากร"""
        print("🧹 Cleaning up resources...")
        
        self.cap.release()
        cv2.destroyAllWindows()
        GPIO.cleanup()
        
        print("✅ Cleanup completed")

# การใช้งาน
if __name__ == "__main__":
    camera = AISmartCamera()
    camera.run()