# -*- coding: utf-8 -*-

import os
import cv2
import gradio as gr
import numpy as np
import shutil
import subprocess
import tempfile
import torch
import torch.nn.functional as F
import warnings
import math

from PIL import Image, ImageFilter, ImageEnhance
from torchvision.transforms import transforms, ToTensor
from torchvision.transforms import Resize, InterpolationMode
from typing import Tuple, List

from model import UNet
from frames import extract_frames

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")

class AudioVideoProcessor:
    def __init__(self):
        self.temp_audio_path = None
        self.original_duration = None
        
    def extract_audio(self, video_path: str) -> str:
        """Extract audio from original video with highest quality"""
        temp_audio = tempfile.mktemp(suffix='.aac')
        self.temp_audio_path = temp_audio
        
        try:
            subprocess.run([
                'ffmpeg', '-i', video_path,
                '-vn', '-acodec', 'aac', '-b:a', '320k', 
                '-ar', '48000', '-ac', '2', '-y', temp_audio
            ], check=True, capture_output=True)
            
            result = subprocess.run([
                'ffprobe', '-v', 'quiet', '-show_entries', 
                'format=duration', '-of', 'default=noprint_wrappers=1:nokey=1',
                video_path
            ], capture_output=True, text=True)
            
            self.original_duration = float(result.stdout.strip())
            print(f"✅ High-quality audio extracted: Duration {self.original_duration}s")
            return temp_audio
            
        except subprocess.CalledProcessError:
            print("⚠️ No audio track found or extraction failed")
            return None
    
    def merge_audio_video(self, video_path: str, output_path: str, target_fps: float) -> str:
        """Merge processed video with original audio using advanced sync"""
        if not self.temp_audio_path or not os.path.exists(self.temp_audio_path):
            print("No audio to merge")
            return video_path
            
        final_output = output_path.replace('.mp4', '_with_audio.mp4')
        
        try:
            subprocess.run([
                'ffmpeg', '-i', video_path, '-i', self.temp_audio_path,
                '-c:v', 'copy', '-c:a', 'aac', '-b:a', '320k',
                '-ar', '48000', '-ac', '2',
                '-af', 'aresample=async=1',  # Audio sync correction
                '-vsync', 'cfr',  # Constant frame rate
                '-shortest', '-y', final_output
            ], check=True, capture_output=True)
            
            print(f"✅ Audio perfectly synchronized: {final_output}")
            return final_output
            
        except subprocess.CalledProcessError as e:
            print(f"❌ Audio merge failed: {e}")
            return video_path
    
    def cleanup(self):
        if self.temp_audio_path and os.path.exists(self.temp_audio_path):
            os.remove(self.temp_audio_path)

class ResolutionManager:
    """Advanced resolution handling with smart upscaling"""
    
    @staticmethod
    def get_optimal_resolution(original_size: Tuple[int, int], max_resolution: Tuple[int, int]) -> Tuple[int, int]:
        """Calculate optimal resolution with intelligent upscaling"""
        width, height = original_size
        max_height, max_width = max_resolution
        
        aspect_ratio = width / height
        
        if width <= max_width and height <= max_height:
            # Intelligent upscaling for better quality
            scale_factor = min(2.0, min(max_width / width, max_height / height))
            if scale_factor > 1.2:
                target_width = int(width * scale_factor)
                target_height = int(height * scale_factor)
            else:
                target_width, target_height = width, height
        else:
            # Scale down proportionally
            scale_factor = min(max_width / width, max_height / height)
            target_width = int(width * scale_factor)
            target_height = int(height * scale_factor)
        
        # Ensure dimensions are divisible by 32 for optimal processing
        target_width = (target_width // 32) * 32
        target_height = (target_height // 32) * 32
        
        # Minimum resolution constraints
        target_width = max(target_width, 512)
        target_height = max(target_height, 512)
        
        print(f"🎯 Smart Resolution: {original_size} → {(target_height, target_width)} (Scale: {target_width/width:.2f}x)")
        return (target_height, target_width)

class AdvancedVideoEnhancer:
    """Professional-grade video enhancement suite"""
    
    def __init__(self, max_resolution: Tuple[int, int] = (2160, 3840)):
        self.max_resolution = max_resolution
        self.device = device
        
    def enhance_image_professional(self, image: Image.Image) -> Image.Image:
        """Apply professional-grade image enhancement"""
        try:
            img_array = np.array(image)
            
            # 1. Advanced denoising with edge preservation
            if len(img_array.shape) == 3 and img_array.shape[2] == 3:
                denoised = cv2.fastNlMeansDenoisingColored(img_array, None, 6, 6, 7, 21)
                enhanced_img = Image.fromarray(denoised)
            else:
                enhanced_img = image
            
            # 2. Unsharp masking for professional sharpening
            enhanced_img = self.apply_unsharp_mask(enhanced_img, radius=1.5, amount=0.8)
            
            # 3. Intelligent contrast enhancement
            enhanced_img = self.enhance_contrast_adaptive(enhanced_img)
            
            # 4. Color grading and saturation
            enhanced_img = self.apply_color_grading(enhanced_img)
            
            # 5. HDR-like processing (주석 처리하여 과도한 안개 효과 방지)
            # enhanced_img = self.simulate_hdr_processing(enhanced_img)
            
            return enhanced_img
            
        except Exception as e:
            print(f"❌ Professional enhancement failed: {e}")
            return image
    
    def apply_unsharp_mask(self, image: Image.Image, radius: float = 1.5, amount: float = 0.8) -> Image.Image:
        """Apply professional unsharp masking"""
        try:
            img_array = np.array(image).astype(np.float32) / 255.0
            
            blurred = cv2.GaussianBlur(img_array, (0, 0), radius)
            
            mask = img_array - blurred
            sharpened = img_array + amount * mask
            
            sharpened = np.clip(sharpened * 255, 0, 255).astype(np.uint8)
            return Image.fromarray(sharpened)
            
        except Exception:
            return image
    
    def enhance_contrast_adaptive(self, image: Image.Image) -> Image.Image:
        """Apply adaptive contrast enhancement using CLAHE"""
        try:
            img_array = np.array(image)
            
            lab = cv2.cvtColor(img_array, cv2.COLOR_RGB2LAB)
            
            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
            lab[:, :, 0] = clahe.apply(lab[:, :, 0])
            
            enhanced = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
            return Image.fromarray(enhanced)
            
        except Exception:
            enhancer = ImageEnhance.Contrast(image)
            return enhancer.enhance(1.1)
    
    def apply_color_grading(self, image: Image.Image) -> Image.Image:
        """Apply cinematic color grading"""
        try:
            enhancer = ImageEnhance.Color(image)
            image = enhancer.enhance(1.08)
            
            img_array = np.array(image).astype(np.float32)
            
            # Warm tone adjustment
            img_array[:, :, 0] *= 1.02  # Red
            img_array[:, :, 1] *= 1.01  # Green  
            img_array[:, :, 2] *= 0.99  # Blue
            
            img_array = np.clip(img_array, 0, 255).astype(np.uint8)
            return Image.fromarray(img_array)
            
        except Exception:
            return image
    
    def simulate_hdr_processing(self, image: Image.Image) -> Image.Image:
        """Simulate HDR-like processing for better dynamic range"""
        try:
            img_array = np.array(image).astype(np.float32) / 255.0
            
            gamma = 0.8
            img_array = np.power(img_array, gamma)
            
            img_gray = cv2.cvtColor((img_array * 255).astype(np.uint8), cv2.COLOR_RGB2GRAY).astype(np.float32) / 255.0
            img_blur = cv2.GaussianBlur(img_gray, (0, 0), 30)
            
            for i in range(3):
                img_array[:, :, i] = img_array[:, :, i] / (img_blur + 0.1)
            
            img_array = img_array / np.max(img_array)
            img_array = np.clip(img_array * 255, 0, 255).astype(np.uint8)
            
            return Image.fromarray(img_array)
            
        except Exception:
            return image

class AdvancedTemporalProcessor:
    """Ultra-smooth temporal consistency with motion-aware processing"""
    
    def __init__(self, alpha=0.06, motion_threshold=0.1):
        self.alpha = alpha
        self.motion_threshold = motion_threshold
        self.previous_frame = None
        self.motion_history = []
        self.frame_buffer = []
        self.buffer_size = 3
        
    def process_frame_sequence(self, frames: List[torch.Tensor]) -> List[torch.Tensor]:
        """Process a sequence of frames for ultra-smooth transitions"""
        if len(frames) < 2:
            return frames
            
        processed_frames = []
        
        for i, frame in enumerate(frames):
            if i == 0:
                processed_frames.append(frame)
                self.previous_frame = frame.clone()
            else:
                motion_magnitude = self.calculate_motion_magnitude(self.previous_frame, frame)
                
                adaptive_alpha = self.calculate_adaptive_alpha(motion_magnitude)
                smooth_frame = self.apply_temporal_smoothing(frame, adaptive_alpha)
                
                if motion_magnitude > self.motion_threshold:
                    smooth_frame = self.apply_motion_blur(smooth_frame, motion_magnitude)
                
                processed_frames.append(smooth_frame)
                self.previous_frame = smooth_frame.clone()
                
        return processed_frames
    
    def calculate_motion_magnitude(self, frame1: torch.Tensor, frame2: torch.Tensor) -> float:
        try:
            diff = torch.abs(frame1 - frame2)
            motion_mag = torch.mean(diff).item()
            return min(motion_mag, 1.0)
        except Exception:
            return 0.1
    
    def calculate_adaptive_alpha(self, motion_magnitude: float) -> float:
        base_alpha = self.alpha
        motion_factor = 1.0 - min(motion_magnitude * 2, 1.0)
        return base_alpha * (0.5 + 0.5 * motion_factor)
    
    def apply_temporal_smoothing(self, current_frame: torch.Tensor, alpha: float) -> torch.Tensor:
        if self.previous_frame is None:
            return current_frame
        if self.previous_frame.shape != current_frame.shape:
            return current_frame
        return (1 - alpha) * current_frame + alpha * self.previous_frame
    
    def apply_motion_blur(self, frame: torch.Tensor, motion_magnitude: float) -> torch.Tensor:
        try:
            if motion_magnitude < 0.05:
                return frame
                
            frame_np = frame.squeeze(0).detach().cpu().numpy()
            frame_np = np.transpose(frame_np, (1, 2, 0))
            
            blur_strength = min(motion_magnitude * 2, 1.0)
            kernel_size = int(3 + blur_strength * 4)
            if kernel_size % 2 == 0:
                kernel_size += 1
                
            blurred = cv2.GaussianBlur(frame_np, (kernel_size, kernel_size), blur_strength)
            
            blend_factor = blur_strength * 0.3
            result = frame_np * (1 - blend_factor) + blurred * blend_factor
            
            result = np.transpose(result, (2, 0, 1))
            return torch.from_numpy(result).unsqueeze(0).to(device)
            
        except Exception:
            return frame
    
    def reset(self):
        self.previous_frame = None
        self.motion_history = []
        self.frame_buffer = []

def save_frames_professional(tensor, out_path, enhancer: AdvancedVideoEnhancer) -> None:
    """Save frames with professional quality enhancement"""
    try:
        image = normalize_frames_professional(tensor)
        pil_image = Image.fromarray(image)
        enhanced_image = enhancer.enhance_image_professional(pil_image)
        
        enhanced_image.save(out_path, "PNG", optimize=False, compress_level=0, pnginfo=None)
        
    except Exception as e:
        print(f"⚠️ Frame save error: {e}")
        image = normalize_frames_professional(tensor)
        pil_image = Image.fromarray(image)
        pil_image.save(out_path, "PNG")

def normalize_frames_professional(tensor):
    """Professional-grade frame normalization"""
    try:
        tensor = tensor.squeeze(0).detach().cpu()
        
        # 추가 감마 보정 제거(주석 처리)
        # tensor = torch.pow(tensor, 0.9)
        
        tensor = torch.clamp(tensor, 0.0, 1.0)
        tensor = (tensor * 255.0).round().clamp(0, 255).to(torch.uint8)
        tensor = tensor.permute(1, 2, 0).numpy()
        
        return tensor
        
    except Exception as e:
        print(f"⚠️ Normalization error: {e}")
        tensor = tensor.squeeze(0).detach().cpu()
        tensor = torch.clamp(tensor, 0.0, 1.0) * 255
        return tensor.permute(1, 2, 0).numpy().astype(np.uint8)

def ensure_tensor_consistency(tensor_a: torch.Tensor, tensor_b: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]:
    if tensor_a.shape == tensor_b.shape:
        return tensor_a, tensor_b
    
    print(f"🔧 Tensor adjustment: A={tensor_a.shape}, B={tensor_b.shape}")
    min_height = min(tensor_a.shape[2], tensor_b.shape[2])
    min_width = min(tensor_a.shape[3], tensor_b.shape[3])
    
    tensor_a = tensor_a[:, :, :min_height, :min_width]
    tensor_b = tensor_b[:, :, :min_height, :min_width]
    
    return tensor_a, tensor_b

def load_allframes_professional(frame_dir, target_resolution):
    frames_path = sorted(
        [os.path.join(frame_dir, f) for f in os.listdir(frame_dir) 
         if f.endswith((".png", ".jpg", ".jpeg"))],
        key=lambda x: int(os.path.splitext(os.path.basename(x))[0].split("_")[-1]),
    )
    print(f"📁 Loading {len(frames_path)} frames at {target_resolution}")
    
    for frame_path in frames_path:
        yield load_frames_professional(frame_path, target_resolution)

def load_frames_professional(image_path, target_resolution) -> torch.Tensor:
    try:
        transform = transforms.Compose([
            Resize(target_resolution, InterpolationMode.LANCZOS, antialias=True),
            ToTensor()
        ])
        
        img = Image.open(image_path).convert("RGB")
        tensor = transform(img).unsqueeze(0).to(device)
        
        expected_h, expected_w = target_resolution
        actual_h, actual_w = tensor.shape[2], tensor.shape[3]
        
        if actual_h != expected_h or actual_w != expected_w:
            tensor = F.interpolate(tensor, size=target_resolution, mode='bicubic', align_corners=True)
        
        return tensor
        
    except Exception as e:
        print(f"❌ Frame loading error: {e}")
        raise

def interpolate_video_professional(frames_dir, model_fc, input_fps, output_fps, output_dir, enhancer):
    os.makedirs(output_dir, exist_ok=True)
    
    first_frame_path = sorted([f for f in os.listdir(frames_dir) if f.endswith((".png", ".jpg", ".jpeg"))])[0]
    first_image = Image.open(os.path.join(frames_dir, first_frame_path))
    target_resolution = ResolutionManager.get_optimal_resolution(first_image.size, enhancer.max_resolution)
    
    print(f"🎬 Professional processing at: {target_resolution}")
    
    temporal_processor = AdvancedTemporalProcessor(alpha=0.04)
    count = 0
    iterator = load_allframes_professional(frames_dir, target_resolution)
    
    try:
        prev_frame = next(iterator)
        
        save_frames_professional(
            prev_frame, os.path.join(output_dir, f"frame_{count:08d}.png"), enhancer
        )
        count += 1
        
        for curr_frame in iterator:
            try:
                prev_frame, curr_frame = ensure_tensor_consistency(prev_frame, curr_frame)
                
                interpolated_frames = interpolate_ultra_smooth(
                    model_fc, prev_frame, curr_frame, input_fps, output_fps
                )
                
                all_frames = [prev_frame] + interpolated_frames + [curr_frame]
                smooth_frames = temporal_processor.process_frame_sequence(all_frames)
                
                for frame in smooth_frames[1:-1]:
                    save_frames_professional(
                        frame[:, :3, :, :] if frame.shape[1] > 3 else frame,
                        os.path.join(output_dir, f"frame_{count:08d}.png"),
                        enhancer
                    )
                    count += 1
                    
            except Exception as e:
                print(f"⚠️ Frame pair processing error: {e}")
                continue
                
            prev_frame = curr_frame
            
        save_frames_professional(
            prev_frame, os.path.join(output_dir, f"frame_{count:08d}.png"), enhancer
        )
        
        print(f"✅ Generated {count + 1} ultra-smooth frames")
        
    except Exception as e:
        print(f"❌ Video interpolation error: {e}")
        raise

def interpolate_ultra_smooth(model_FC, A, B, input_fps, output_fps) -> List[torch.Tensor]:
    interval = time_steps_smooth(input_fps, output_fps)
    if not interval:
        return []
    
    try:
        A, B = ensure_tensor_consistency(A, B)
        input_tensor = torch.cat((A, B), dim=1)
        
        with torch.no_grad():
            with torch.amp.autocast('cuda' if torch.cuda.is_available() else 'cpu'):
                flow_output = model_FC(input_tensor)
                flow_forward = flow_output[:, :2, :, :]
                flow_backward = flow_output[:, 2:4, :, :]
        
        generated_frames = []
        
        with torch.no_grad():
            for i, t in enumerate(interval):
                try:
                    smooth_t = cubic_spline_interpolation(t)
                    t_tensor = torch.tensor([smooth_t], dtype=torch.float32).view(1, 1, 1, 1).to(device)
                    
                    with torch.amp.autocast('cuda' if torch.cuda.is_available() else 'cpu'):
                        warped_A = warp_frames_professional(A, flow_forward * t_tensor)
                        warped_B = warp_frames_professional(B, flow_backward * (1 - t_tensor))
                        
                        warped_A, warped_B = ensure_tensor_consistency(warped_A, warped_B)
                        
                        interpolated_frame = ultra_smooth_blend(warped_A, warped_B, smooth_t, A, B)
                        
                        interpolated_frame = apply_antialiasing(interpolated_frame)
                        
                        interpolated_frame = torch.clamp(interpolated_frame, 0.0, 1.0)
                        
                    generated_frames.append(interpolated_frame)
                    
                except Exception as e:
                    print(f"⚠️ Frame step error: {e}")
                    cubic_t = cubic_spline_interpolation(t)
                    fallback_frame = A * (1 - cubic_t) + B * cubic_t
                    generated_frames.append(torch.clamp(fallback_frame, 0.0, 1.0))
        
        return generated_frames
        
    except Exception as e:
        print(f"❌ Ultra-smooth interpolation error: {e}")
        return []

def cubic_spline_interpolation(t: float) -> float:
    return t * t * (3 - 2 * t)

def ultra_smooth_blend(warped_A: torch.Tensor, warped_B: torch.Tensor, t: float, orig_A: torch.Tensor, orig_B: torch.Tensor) -> torch.Tensor:
    try:
        primary_blend = warped_A * (1 - t) + warped_B * t
        fallback_blend = orig_A * (1 - t) + orig_B * t
        
        motion_confidence = calculate_motion_confidence(warped_A, warped_B, orig_A, orig_B)
        final_blend = primary_blend * motion_confidence + fallback_blend * (1 - motion_confidence)
        
        return final_blend
        
    except Exception:
        return warped_A * (1 - t) + warped_B * t

def calculate_motion_confidence(warped_A: torch.Tensor, warped_B: torch.Tensor, orig_A: torch.Tensor, orig_B: torch.Tensor) -> float:
    try:
        diff_A = torch.mean(torch.abs(warped_A - orig_A)).item()
        diff_B = torch.mean(torch.abs(warped_B - orig_B)).item()
        
        confidence = max(0.3, 1.0 - (diff_A + diff_B) / 2.0)
        return min(confidence, 0.9)
        
    except Exception:
        return 0.7

def apply_antialiasing(frame: torch.Tensor) -> torch.Tensor:
    try:
        kernel_size = 3
        sigma = 0.5
        
        kernel = torch.zeros(kernel_size, kernel_size).to(device)
        center = kernel_size // 2
        
        for i in range(kernel_size):
            for j in range(kernel_size):
                kernel[i, j] = math.exp(-((i - center)**2 + (j - center)**2) / (2 * sigma**2))
        
        kernel = kernel / kernel.sum()
        kernel = kernel.expand(frame.shape[1], 1, kernel_size, kernel_size)
        
        filtered = F.conv2d(frame, kernel, padding=center, groups=frame.shape[1])
        
        return 0.85 * frame + 0.15 * filtered
        
    except Exception:
        return frame

def warp_frames_professional(frame, flow):
    """Professional frame warping with sub-pixel precision"""
    try:
        b, c, h, w = frame.size()
        _, _, flow_h, flow_w = flow.size()
        
        if h != flow_h or w != flow_w:
            frame = F.interpolate(frame, size=(flow_h, flow_w), mode="bicubic", align_corners=True)
        
        grid_y, grid_x = torch.meshgrid(
            torch.linspace(-1, 1, flow_h, dtype=torch.float32),
            torch.linspace(-1, 1, flow_w, dtype=torch.float32),
            indexing="ij"
        )
        grid_x = grid_x.to(device)
        grid_y = grid_y.to(device)
        
        flow_x = flow[:, 0, :, :] / (flow_w / 2.0)
        flow_y = flow[:, 1, :, :] / (flow_h / 2.0)
        
        x = grid_x.unsqueeze(0) + flow_x
        y = grid_y.unsqueeze(0) + flow_y
        
        grid = torch.stack((x, y), dim=-1)
        
        warped_frame = F.grid_sample(frame, grid, align_corners=True, mode="bilinear", padding_mode="reflection")
        
        return warped_frame
        
    except Exception as e:
        print(f"⚠️ Professional warping error: {e}")
        return frame

def time_steps_smooth(input_fps, output_fps) -> List[float]:
    if output_fps <= input_fps:
        return []
    
    k = output_fps // input_fps
    n = k - 1
    
    intervals = []
    for i in range(1, n + 1):
        linear_t = i / (n + 1)
        smooth_t = cubic_spline_interpolation(linear_t)
        intervals.append(smooth_t)
    
    return intervals

def frames_to_video_professional(frame_dir, output_video, fps):
    frame_files = sorted(
        [f for f in os.listdir(frame_dir) if f.endswith(".png")],
        key=lambda x: int(os.path.splitext(x)[0].split("_")[-1]),
    )
    
    if not frame_files:
        raise ValueError("No frames found")
    
    print(f"🎬 Encoding {len(frame_files)} frames to professional video...")
    
    for i, frame in enumerate(frame_files):
        old_path = os.path.join(frame_dir, frame)
        new_path = os.path.join(frame_dir, f"frame_{i:08d}.png")
        if old_path != new_path:
            os.rename(old_path, new_path)
    
    frame_pattern = os.path.join(frame_dir, "frame_%08d.png")
    
    ffmpeg_cmd = [
        "ffmpeg", "-y", "-framerate", str(fps), "-i", frame_pattern,
        "-c:v", "libx264", "-preset", "slow",
        "-crf", "18",
        "-pix_fmt", "yuv420p", "-profile:v", "high", "-level", "4.1",
        "-movflags", "+faststart", "-bf", "3", "-refs", "5",
        "-vf", "scale=trunc(iw/2)*2:trunc(ih/2)*2,unsharp=5:5:0.8:3:3:0.4",
        "-x264opts", "me=umh:subme=8:ref=5:bframes=3:b-adapt=2:direct=auto:me-range=16:analyse=all",
        output_video
    ]
    
    result = subprocess.run(ffmpeg_cmd, capture_output=True, text=True)
    
    if result.returncode != 0:
        print(f"❌ Professional encoding failed: {result.stderr}")
        raise subprocess.CalledProcessError(result.returncode, ffmpeg_cmd)
    
    print("✅ Professional encoding completed!")

def process_video_professional(video_path, output_fps, max_resolution_preset="4K"):
    """Professional video processing pipeline"""
    print(f"🎬 PROFESSIONAL PROCESSING STARTED")
    print(f"📁 Video: {video_path}")
    print(f"🎯 Target: {output_fps} FPS @ {max_resolution_preset}")
    
    audio_processor = AudioVideoProcessor()
    
    try:
        audio_path = audio_processor.extract_audio(video_path)
        
        resolution_presets = {
            "HD": (1080, 1920),
            "2K": (1440, 2560), 
            "4K": (2160, 3840),
            "8K": (4320, 7680),
            "Original": (4320, 7680)
        }
        
        max_res = resolution_presets.get(max_resolution_preset, (2160, 3840))
        enhancer = AdvancedVideoEnhancer(max_res)
        
        input_fps = extract_frames(video_path, "output_frames")
        print(f"📊 Source: {input_fps} FPS → Target: {output_fps} FPS")
        
        model_FC = UNet(6, 4).to(device)
        with warnings.catch_warnings():
            warnings.simplefilter("ignore")
            checkpoint = torch.load("SuperSloMo.ckpt", map_location=device, weights_only=False)
        model_FC.load_state_dict(checkpoint["state_dictFC"])
        model_FC.eval()
        print("✅ Professional model loaded")
        
        output_dir = "professional_frames"
        if os.path.exists(output_dir):
            shutil.rmtree(output_dir)
        
        interpolate_video_professional("output_frames", model_FC, input_fps, output_fps, output_dir, enhancer)
        
        temp_video_path = f"temp_professional_{output_fps}fps.mp4"
        frames_to_video_professional(output_dir, temp_video_path, output_fps)
        
        final_video_path = f"PROFESSIONAL_{output_fps}fps_{max_resolution_preset}.mp4"
        if audio_path:
            final_path = audio_processor.merge_audio_video(temp_video_path, final_video_path, output_fps)
        else:
            os.rename(temp_video_path, final_video_path)
            final_path = final_video_path
        
        print(f"🎉 PROFESSIONAL VIDEO COMPLETED: {final_path}")
        return final_path
        
    except Exception as e:
        print(f"💥 PROFESSIONAL PROCESSING FAILED: {e}")
        raise e
    finally:
        audio_processor.cleanup()
        for temp_dir in ["output_frames", "professional_frames"]:
            if os.path.exists(temp_dir):
                try:
                    shutil.rmtree(temp_dir)
                except:
                    pass

interface = gr.Interface(
    fn=process_video_professional,
    inputs=[
        gr.Video(label="🎬 Upload Your Video"),
        gr.Slider(minimum=30, maximum=120, step=6, value=60, label="🎯 Target FPS (60 recommended for 4K)"),
        gr.Dropdown(
            choices=["HD", "2K", "4K", "8K", "Original"],
            value="4K",
            label="📐 Resolution Preset (4K recommended)"
        )
    ],
    outputs=gr.File(label="📥 Download Professional Enhanced Video"),
    title="🎬 PROFESSIONAL VIDEO ENHANCEMENT STUDIO",
    description="""
    ## 🚀 **ULTRA-PROFESSIONAL FEATURES**
    
    ### 🎯 **Ultra-Smooth Motion**
    - **Cubic Spline Interpolation** for natural acceleration/deceleration
    - **Advanced Temporal Processing** with motion-aware smoothing  
    - **Sub-pixel Motion Estimation** for precise frame transitions
    - **Motion Blur Simulation** for realistic high-speed motion
    - **Anti-aliasing Filters** for smooth edges
    
    ### ✨ **Professional Quality Enhancement**
    - **Non-Local Means Denoising** - Superior noise reduction
    - **Unsharp Masking** - Professional sharpening technique
    - **CLAHE Adaptive Contrast** - Intelligent contrast enhancement
    - **Cinematic Color Grading** - Film-quality color processing
    - **HDR-like Processing** - Enhanced dynamic range
    
    ### 🎵 **Perfect Audio Sync**
    - **48kHz/320kbps Audio** - Studio quality preservation
    - **Advanced Sync Correction** - Frame-perfect audio alignment
    - **Constant Frame Rate** - Eliminates audio drift
    
    ### 🎬 **Encoding Excellence**
    - **CRF 18 Quality** - Near-lossless video output
    - **Slow Preset** - Maximum compression efficiency
    - **Professional x264** - Broadcast-quality encoding
    - **Optimized Settings** - Perfect for streaming/archival
    """,
    article="""
    ## 🎯 **PROFESSIONAL TIPS**
    
    **🏆 Recommended Settings:**
    - **4K @ 60 FPS** - Perfect balance of quality and smoothness
    - **2K @ 120 FPS** - Ultra-smooth for action content  
    - **HD @ 60 FPS** - Fast processing with great quality
    
    **⚡ Performance Notes:**
    - 4K processing: 5-15 minutes depending on length
    - Higher FPS = longer processing time but smoother result
    - GPU acceleration automatically enabled when available
    
    **🎨 Best Results:**
    - Use high-quality source videos (avoid heavily compressed inputs)
    - Recommended input: 1080p+ resolution, good lighting
    - Works excellently with: Gaming, Sports, Cinema, Animation
    """
)

if __name__ == "__main__":
    interface.launch(share=True)