#!/usr/bin/env python3
"""
AI Video Generation + Cloud Upload Pipeline
Generate video from text prompt and upload to Google Drive
"""

import os
import sys
import json
import time
import requests
from pathlib import Path
from datetime import datetime

# 🔧 CONFIG
CONFIG = {
    # AI Video Provider: 'veo', 'runway', 'pika'
    "provider": os.getenv("VIDEO_PROVIDER", "runway"),
    
    # API Keys (use environment variables!)
    "runway_api_key": os.getenv("RUNWAY_API_KEY"),
    "veo_project_id": os.getenv("VEO_PROJECT_ID"),
    
    # Google Drive
    "drive_folder_id": os.getenv("DRIVE_FOLDER_ID"),
    "drive_service_account": os.path.expanduser("~/.config/gcloud/drive-service-account.json"),
    
    # Output
    "output_dir": os.path.expanduser("~/ai-video-pipeline/output"),
    "max_duration": 8,  # seconds
}


def log(message):
    """Log with timestamp"""
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    print(f"[{timestamp}] {message}")


def generate_video_runway(prompt: str, duration: int = 4) -> str:
    """
    Generate video using Runway ML API
    Returns: video_url or None
    """
    api_key = CONFIG["runway_api_key"]
    if not api_key:
        raise ValueError("RUNWAY_API_KEY not set!")
    
    headers = {
        "Authorization": f"Bearer {api_key}",
        "Content-Type": "application/json"
    }
    
    # Create generation task
    payload = {
        "prompt": prompt,
        "duration": duration,  # 4 or 10 seconds
        "ratio": "16:9",  # or "9:16" for vertical
    }
    
    log(f"🎬 Submitting video generation task...")
    log(f"📝 Prompt: {prompt[:60]}...")
    
    response = requests.post(
        "https://api.runwayml.com/v1/generations",
        headers=headers,
        json=payload,
        timeout=30
    )
    
    if response.status_code != 200:
        log(f"❌ Error creating task: {response.text}")
        return None
    
    task_id = response.json().get("id")
    log(f"⏳ Task created: {task_id}")
    
    # Poll for completion (Runway takes 30-120 seconds)
    max_attempts = 60
    for attempt in range(max_attempts):
        time.sleep(5)
        
        status_resp = requests.get(
            f"https://api.runwayml.com/v1/generations/{task_id}",
            headers=headers,
            timeout=30
        )
        
        status_data = status_resp.json()
        status = status_data.get("status")
        
        log(f"   Attempt {attempt+1}/{max_attempts}: {status}")
        
        if status == "succeeded":
            video_url = status_data.get("url")
            log(f"✅ Video generated!")
            return video_url
        elif status == "failed":
            log(f"❌ Generation failed: {status_data.get('error')}")
            return None
    
    log("❌ Timeout waiting for video generation")
    return None


def download_video(url: str, filename: str) -> str:
    """Download video to local storage"""
    output_path = Path(CONFIG["output_dir"]) / filename
    output_path.parent.mkdir(parents=True, exist_ok=True)
    
    log(f"⬇️  Downloading video...")
    response = requests.get(url, stream=True, timeout=120)
    
    with open(output_path, "wb") as f:
        for chunk in response.iter_content(chunk_size=8192):
            f.write(chunk)
    
    log(f"✅ Downloaded: {output_path}")
    return str(output_path)


def upload_to_drive(local_path: str, filename: str) -> str:
    """
    Upload video to Google Drive
    Returns: Drive file URL
    """
    from google.oauth2 import service_account
    from googleapiclient.discovery import build
    from googleapiclient.http import MediaFileUpload
    
    # Authenticate
    credentials = service_account.Credentials.from_service_account_file(
        CONFIG["drive_service_account"],
        scopes=["https://www.googleapis.com/auth/drive"]
    )
    
    service = build("drive", "v3", credentials=credentials)
    
    # Upload file
    file_metadata = {
        "name": filename,
        "parents": [CONFIG["drive_folder_id"]]
    }
    
    media = MediaFileUpload(local_path, resumable=True)
    
    log(f"☁️  Uploading to Google Drive...")
    file = service.files().create(
        body=file_metadata,
        media_body=media,
        fields="id, webViewLink"
    ).execute()
    
    drive_link = file.get("webViewLink")
    log(f"✅ Uploaded: {drive_link}")
    
    # Make publicly viewable (optional)
    service.permissions().create(
        fileId=file.get("id"),
        body={"role": "reader", "type": "anyone"}
    ).execute()
    
    return drive_link


def process_video_generation(prompt: str) -> dict:
    """
    Main pipeline: Generate → Download → Upload
    """
    result = {
        "success": False,
        "prompt": prompt,
        "local_path": None,
        "drive_link": None,
        "error": None
    }
    
    try:
        # 1. Generate video
        video_url = generate_video_runway(prompt)
        if not video_url:
            result["error"] = "Video generation failed"
            return result
        
        # 2. Download
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"ai_video_{timestamp}.mp4"
        local_path = download_video(video_url, filename)
        result["local_path"] = local_path
        
        # 3. Upload to Drive
        drive_link = upload_to_drive(local_path, filename)
        result["drive_link"] = drive_link
        result["success"] = True
        
        log(f"🎉 Pipeline complete!")
        
    except Exception as e:
        log(f"❌ Error: {str(e)}")
        result["error"] = str(e)
    
    return result


if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python3 generate_video.py [prompt]")
        print('Example: python3 generate_video.py "Sunset over mountains"')
        sys.exit(1)
    
    prompt = " ".join(sys.argv[1:])
    result = process_video_generation(prompt)
    
    # Output result as JSON for OpenClaw parsing
    print(json.dumps(result, indent=2))

#!/usr/bin/env python3
"""Batch generate videos dari text file"""

import sys
from generate_video import process_video_generation

def batch_process(prompts_file):
    with open(prompts_file, 'r') as f:
        prompts = [line.strip() for line in f if line.strip()]
    
    results = []
    for i, prompt in enumerate(prompts, 1):
        print(f"\n{'='*60}")
        print(f"Processing {i}/{len(prompts)}: {prompt[:50]}...")
        print('='*60)
        
        result = process_video_generation(prompt)
        results.append(result)
        
        if result['success']:
            print(f"✅ Done: {result['drive_link']}")
        else:
            print(f"❌ Failed: {result['error']}")
    
    # Summary
    success_count = sum(1 for r in results if r['success'])
    print(f"\n{'='*60}")
    print(f"Batch complete: {success_count}/{len(prompts)} successful")

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python3 batch_generate.py prompts.txt")
        sys.exit(1)
    
    batch_process(sys.argv[1])

def notify_telegram(message: str):
    """Send notification to Telegram"""
    bot_token = os.getenv("TELEGRAM_BOT_TOKEN")
    chat_id = os.getenv("TELEGRAM_CHAT_ID")
    
    if not bot_token or not chat_id:
        return
    
    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
    payload = {
        "chat_id": chat_id,
        "text": message,
        "parse_mode": "Markdown"
    }
    
    requests.post(url, json=payload, timeout=10)

# Gunakan di process_video_generation:
if result["success"]:
    notify_telegram(f"🎬 *Video Generated!*\n\n{result['drive_link']}")

TEMPLATES = {
    "nature": "Beautiful {subject} in 4K nature documentary style",
    "urban": "Cinematic shot of {subject}, cyberpunk city aesthetic",
    "abstract": "Fluid abstract visualization of {subject}, vibrant colors",
    "product": "Sleek product showcase of {subject}, studio lighting"
}

def generate_from_template(template_name: str, subject: str):
    template = TEMPLATES.get(template_name, TEMPLATES["nature"])
    prompt = template.format(subject=subject)
    return process_video_generation(prompt)

# Usage: /genvideo template nature waterfall

COST_PER_SECOND = {
    "runway": 0.05,  # $0.05 per second
    "veo": 0.20,
}

def track_cost(duration: int, provider: str):
    cost = duration * COST_PER_SECOND.get(provider, 0.05)
    log(f"💰 Estimated cost: ${cost:.2f}")
    
    # Save to log file
    with open("logs/costs.txt", "a") as f:
        f.write(f"{datetime.now()},{provider},{duration},{cost}\n")