import os
from pathlib import Path
from datetime import datetime
import exiftool
 
class VideoIntake:
    def __init__(self, source_dir, dest_dir):
        self.source = Path(source_dir)
        self.dest = Path(dest_dir)
        
    def organize_by_metadata(self):
        """Organize videos by date and camera"""
        for video in self.source.glob('**/*'):
            if not self.is_video(video):
                continue
                
            metadata = self.extract_metadata(video)
            
            # Create organized structure
            date = metadata.get('date', 'unknown')
            camera = metadata.get('camera', 'default')
            
            destination = self.dest / date / camera / video.name
            destination.parent.mkdir(parents=True, exist_ok=True)
            
            shutil.move(str(video), str(destination))
            
    def extract_metadata(self, file):
        """Extract creation date, camera info, etc."""
        with exiftool.ExifTool() as et:
            metadata = et.get_metadata(str(file))
            
        return {
            'date': self.parse_date(metadata),
            'camera': metadata.get('EXIF:Model', 'unknown'),
            'resolution': f"{metadata.get('ImageWidth')}x{metadata.get('ImageHeight')}",
            'duration': metadata.get('Duration', 0),
        }

import ffmpeg
from typing import Dict, Tuple
 
class SmartTranscoder:
    # Presets for different use cases
    PRESETS = {
        'web': {
            'codec': 'libx264',
            'preset': 'medium',
            'crf': 23,
            'maxrate': '5M',
        },
        'social': {
            'codec': 'libx264', 
            'preset': 'fast',
            'crf': 28,
            'maxrate': '2M',
        },
        'archive': {
            'codec': 'libx265',
            'preset': 'slow',
            'crf': 22,
            'maxrate': '10M',
        }
    }
    
    def transcode(self, input_file: Path, output_dir: Path, purpose: str = 'web'):
        """Intelligently transcode based on purpose"""
        preset = self.PRESETS[purpose]
        
        # Analyze input first
        probe = ffmpeg.probe(str(input_file))
        video_info = next(s for s in probe['streams'] if s['codec_type'] == 'video')
        
        # Determine if we need to scale
        width = int(video_info['width'])
        height = int(video_info['height'])
        
        output_file = output_dir / f"{input_file.stem}_{purpose}.mp4"
        
        stream = ffmpeg.input(str(input_file))
        
        # Apply scaling if needed
        if purpose == 'social' and width > 1920:
            stream = stream.filter('scale', 1920, -2)
        
        # Apply preset settings
        stream = ffmpeg.output(
            stream,
            str(output_file),
            vcodec=preset['codec'],
            preset=preset['preset'],
            crf=preset['crf'],
            maxrate=preset['maxrate'],
            bufsize='10M',
            acodec='aac',
            audio_bitrate='128k'
        )
        
        # Run with progress callback
        stream.run(overwrite_output=True)
        
        return output_file

import cv2
import numpy as np
from typing import List
 
class ThumbnailGenerator:
    def __init__(self, video_path: Path):
        self.video = cv2.VideoCapture(str(video_path))
        self.total_frames = int(self.video.get(cv2.CAP_PROP_FRAME_COUNT))
        
    def find_best_frame(self, num_candidates: int = 30) -> np.ndarray:
        """Find the most interesting frame for thumbnail"""
        candidates = self.sample_frames(num_candidates)
        
        # Score frames based on:
        # 1. Face detection
        # 2. Color variance (avoid black frames)
        # 3. Sharpness (avoid blurry frames)
        # 4. Composition (rule of thirds)
        
        scored = [(frame, self.score_frame(frame)) for frame in candidates]
        best_frame = max(scored, key=lambda x: x[1])[0]
        
        return best_frame
        
    def score_frame(self, frame: np.ndarray) -> float:
        """Score a frame's suitability as thumbnail"""
        score = 0.0
        
        # Color variance (avoid blank/black frames)
        variance = np.var(frame)
        score += min(variance / 1000, 1.0) * 25
        
        # Sharpness (Laplacian variance)
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        sharpness = cv2.Laplacian(gray, cv2.CV_64F).var()
        score += min(sharpness / 500, 1.0) * 25
        
        # Face detection bonus
        face_cascade = cv2.CascadeClassifier(
            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
        )
        faces = face_cascade.detectMultiScale(gray, 1.3, 5)
        score += len(faces) * 30
        
        # Composition (check rule of thirds intersections)
        height, width = frame.shape[:2]
        thirds_points = [
            (width // 3, height // 3),
            (width * 2 // 3, height // 3),
            (width // 3, height * 2 // 3),
            (width * 2 // 3, height * 2 // 3),
        ]
        
        # Check for interesting content near thirds intersections
        for x, y in thirds_points:
            region = frame[y-50:y+50, x-50:x+50]
            if region.size > 0:
                score += np.var(region) / 1000
        
        return score
        
    def generate_thumbnail(self, output_path: Path, width: int = 1280):
        """Generate optimized thumbnail"""
        best_frame = self.find_best_frame()
        
        # Resize maintaining aspect ratio
        height = int(best_frame.shape[0] * (width / best_frame.shape[1]))
        resized = cv2.resize(best_frame, (width, height))
        
        # Enhance colors slightly for better appeal
        enhanced = cv2.convertScaleAbs(resized, alpha=1.1, beta=10)
        
        cv2.imwrite(str(output_path), enhanced, [cv2.IMWRITE_JPEG_QUALITY, 90])

from google.oauth2 import service_account
from googleapiclient.discovery import build
from googleapiclient.http import MediaFileUpload
import boto3
 
class VideoDistributor:
    def __init__(self):
        self.youtube = self.init_youtube()
        self.s3 = boto3.client('s3')
        
    def distribute(self, video: Path, thumbnail: Path, metadata: Dict):
        """Distribute video to all platforms"""
        results = {}
        
        # Upload to YouTube
        results['youtube'] = self.upload_to_youtube(video, thumbnail, metadata)
        
        # Upload to S3 for website
        results['cdn'] = self.upload_to_s3(video)
        
        # Copy to backup storage
        results['backup'] = self.backup_to_archive(video)
        
        return results
        
    def upload_to_youtube(self, video: Path, thumbnail: Path, metadata: Dict):
        """Upload to YouTube with metadata"""
        body = {
            'snippet': {
                'title': metadata['title'],
                'description': metadata['description'],
                'tags': metadata['tags'],
                'categoryId': '22',  # People & Blogs
            },
            'status': {
                'privacyStatus': 'private',  # Start private
            }
        }
        
        media = MediaFileUpload(str(video), chunksize=-1, resumable=True)
        
        request = self.youtube.videos().insert(
            part='snippet,status',
            body=body,
            media_body=media
        )
        
        response = request.execute()
        video_id = response['id']
        
        # Set thumbnail
        self.youtube.thumbnails().set(
            videoId=video_id,
            media_body=MediaFileUpload(str(thumbnail))
        ).execute()
        
        return {'video_id': video_id, 'url': f'https://youtube.com/watch?v={video_id}'}