"""
Pika Labs Video Provider

API Docs: https://docs.pika.art/
Pricing:  ~$0.04/video (basic), credit-based system
Auth:     Bearer token (API Key)
Endpoint: https://api.pika.art/v1/generate

Setup:
  1. Register at https://pika.art → API access
  2. Generate API key
  3. Set PIKA_API_KEY in .env
"""
import aiohttp
import asyncio
from flask import current_app
from . import BaseVideoProvider


class PikaProvider(BaseVideoProvider):
    """Pika Labs video generation — creative/stylized videos, affordable."""

    BASE_URL = "https://api.pika.art/v1"

    def _get_api_key(self):
        from .key_helper import get_provider_key
        key, _ = get_provider_key("pika", "PIKA_API_KEY")
        return key

    async def generate_video(self, prompt: str, duration: int = 4, **kwargs) -> dict:
        api_key = self._get_api_key()
        if not api_key:
            return {"status": "error", "error": "Pika API key not configured. Set PIKA_API_KEY in .env"}

        url = f"{self.BASE_URL}/generate"
        headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        }
        # Pika supports 3-4 second clips
        payload = {
            "promptText": prompt,
            "style": kwargs.get("style", "realistic"),
            "aspectRatio": "16:9",
            "duration": min(duration, 4),
            "model": kwargs.get("model", "pika-2.2"),
        }

        try:
            timeout = aiohttp.ClientTimeout(total=60)
            async with aiohttp.ClientSession(timeout=timeout) as session:
                async with session.post(url, json=payload, headers=headers) as resp:
                    if resp.content_type and "json" in resp.content_type:
                        result = await resp.json()
                    else:
                        text = await resp.text()
                        return {"status": "error", "error": f"Unexpected response ({resp.status}): {text[:300]}"}

                    if resp.status in (200, 201, 202):
                        task_id = result.get("id", "") or result.get("task_id", "")
                        if not task_id:
                            return {"status": "error", "error": f"No task ID returned: {result}"}
                        return {"status": "processing", "video_id": task_id, "provider": "pika"}
                    elif resp.status == 401:
                        return {"status": "error", "error": "Invalid Pika API key"}
                    elif resp.status == 402:
                        return {"status": "error", "error": "Insufficient Pika credits"}
                    elif resp.status == 429:
                        return {"status": "error", "error": "Rate limit exceeded. Try again later."}
                    else:
                        error_msg = result.get("error", result.get("message", str(result)))
                        return {"status": "error", "error": f"Pika API error ({resp.status}): {error_msg}"}
        except asyncio.TimeoutError:
            return {"status": "error", "error": "Request timed out"}
        except aiohttp.ClientError as e:
            return {"status": "error", "error": f"Connection error: {e}"}
        except Exception as e:
            return {"status": "error", "error": f"Unexpected error: {e}"}

    async def check_status(self, task_id: str) -> dict:
        api_key = self._get_api_key()
        if not api_key:
            return {"status": "error", "error": "Pika API key not configured"}

        url = f"{self.BASE_URL}/generate/{task_id}"
        headers = {"Authorization": f"Bearer {api_key}"}

        try:
            timeout = aiohttp.ClientTimeout(total=60)
            async with aiohttp.ClientSession(timeout=timeout) as session:
                async with session.get(url, headers=headers) as resp:
                    if resp.content_type and "json" in resp.content_type:
                        result = await resp.json()
                    else:
                        return {"status": "error", "error": f"Unexpected response ({resp.status})"}

                    status = result.get("status", "")

                    if status in ("completed", "finished", "success"):
                        video_url = result.get("video", {}).get("url", "") or result.get("resultUrl", "")
                        if video_url:
                            return {"status": "completed", "video_url": video_url}
                        return {"status": "error", "error": "No video URL in result"}
                    elif status in ("failed", "error"):
                        msg = result.get("error", result.get("message", "Generation failed"))
                        return {"status": "error", "error": str(msg)}
                    else:
                        # pending, processing, queued
                        return {"status": "processing", "progress": 0}
        except asyncio.TimeoutError:
            return {"status": "error", "error": "Status check timed out"}
        except aiohttp.ClientError as e:
            return {"status": "error", "error": f"Connection error: {e}"}
        except Exception as e:
            return {"status": "error", "error": f"Unexpected error: {e}"}