"""
Deepfaic Edge tutorial script.

This script:
1. Loads the edge API key from api_cred.txt
2. Verifies the edge API is reachable
3. Copies a media file into the default edge uploads directory
4. Creates a job through the edge API
5. Polls the partial job endpoint until completion
6. Fetches the full job and prints raw scores

Usage:
    python deepfaic_edge.py /path/to/media.mp4
    python deepfaic_edge.py /path/to/media.mp4 --base-url http://localhost:9123
    python deepfaic_edge.py /path/to/media.mp4 --runtime-root /opt/deepfaic
"""

from __future__ import annotations

import argparse
import shutil
import sys
import time
from pathlib import Path
from typing import Any

import requests


DEFAULT_BASE_URL = "http://localhost:9123"
CONTAINER_UPLOADS_ROOT = Path("/var/lib/deepfaic/uploads")


class DeepfaicEdgeClient:
    def __init__(self, base_url: str, api_key: str):
        self.base_url = base_url.rstrip("/")
        self.session = requests.Session()
        self.session.headers.update(
            {
                "Authorization": f"Bearer {api_key}",
                "Accept": "application/json",
            }
        )

    def _request(self, method: str, path: str, **kwargs: Any) -> dict[str, Any]:
        response = self.session.request(
            method,
            f"{self.base_url}{path}",
            timeout=60,
            **kwargs,
        )
        response.raise_for_status()

        payload = response.json()
        if not payload.get("status", False):
            raise RuntimeError(
                f"Edge API returned an error for {path}: {payload.get('message', 'unknown error')}"
            )
        return payload

    def health(self) -> dict[str, Any]:
        payload = self._request("GET", "/v1/health")
        return payload["data"]

    def create_job(self, input_path: str, title: str) -> int:
        payload = self._request(
            "POST",
            "/v1/jobs",
            json={
                "input_path": input_path,
                "title": title,
            },
        )
        return int(payload["data"]["job_id"])

    def get_partial_job(self, job_id: int) -> dict[str, Any]:
        payload = self._request("GET", f"/v1/jobs/partial/{job_id}")
        records = payload.get("data", [])
        if not records:
            raise RuntimeError(f"Partial job {job_id} was not found")
        return records[0]

    def get_full_job(self, job_id: int) -> dict[str, Any]:
        payload = self._request("GET", f"/v1/jobs/{job_id}")
        records = payload.get("data", [])
        if not records:
            raise RuntimeError(f"Full job {job_id} was not found")
        return records[0]


def load_api_key(runtime_root: Path) -> str:
    credential_path = runtime_root / "api_cred.txt"
    if not credential_path.exists():
        raise RuntimeError(
            f"Missing api_cred.txt at {credential_path}. Run this script from the edge runtime root or pass --runtime-root."
        )

    api_key = credential_path.read_text(encoding="utf-8").strip()
    if not api_key.startswith("df_"):
        raise RuntimeError(
            f"{credential_path} does not contain a valid edge API key starting with 'df_'."
        )
    return api_key


def stage_media_file(source_path: Path, runtime_root: Path) -> tuple[Path, str]:
    if not source_path.exists():
        raise RuntimeError(f"Media file was not found: {source_path}")
    if not source_path.is_file():
        raise RuntimeError(f"Expected a file, received: {source_path}")

    uploads_dir = runtime_root / "data" / "uploads"
    uploads_dir.mkdir(parents=True, exist_ok=True)

    staged_name = f"{int(time.time())}-{source_path.name}"
    staged_host_path = uploads_dir / staged_name
    shutil.copy2(source_path, staged_host_path)

    container_path = str(CONTAINER_UPLOADS_ROOT / staged_name)
    return staged_host_path, container_path


def format_optional(value: Any) -> str:
    if value is None:
        return "n/a"
    return str(value)


def format_float(value: Any) -> str:
    if value is None:
        return "n/a"
    try:
        return f"{float(value):.4f}"
    except (TypeError, ValueError):
        return str(value)


def print_lane(name: str, lane: dict[str, Any]) -> None:
    print(f"{name} score: {format_float(lane.get('score'))}")
    print(f"{name} threshold: {format_float(lane.get('threshold'))}")
    print(f"{name} coverage: {format_float(lane.get('coverage'))}")
    print(f"{name} status: {format_optional(lane.get('status'))}")
    print(f"{name} error: {format_optional(lane.get('error'))}")
    print(f"{name} chunk_scores: {lane.get('chunk_scores', [])}")

    if "frame_scores" in lane:
        print(f"{name} frame_scores: {lane.get('frame_scores', [])}")
    if "face_box" in lane:
        print(f"{name} face_box: {lane.get('face_box')}")

    print()


def wait_for_completion(
    client: DeepfaicEdgeClient,
    job_id: int,
    poll_interval_seconds: float,
    started_at: float,
) -> dict[str, Any]:
    while True:
        partial = client.get_partial_job(job_id)
        elapsed = time.perf_counter() - started_at

        status = partial.get("status", "unknown")
        progress = partial.get("progress")
        progress_text = (
            f"{float(progress):.2f}%"
            if isinstance(progress, (int, float))
            else "n/a"
        )

        print(
            f"[{elapsed:7.2f}s] job_id={job_id} status={status} progress={progress_text}"
        )

        if "video_score" in partial:
            print(
                f"  partial video_score={format_float(partial.get('video_score'))} "
                f"threshold={format_float(partial.get('video_threshold'))}"
            )
        if "audio_score" in partial:
            print(
                f"  partial audio_score={format_float(partial.get('audio_score'))} "
                f"threshold={format_float(partial.get('audio_threshold'))}"
            )
        if "image_score" in partial:
            print(
                f"  partial image_score={format_float(partial.get('image_score'))} "
                f"threshold={format_float(partial.get('image_threshold'))}"
            )

        if status == "complete":
            return partial
        if status in {"error", "failed"}:
            raise RuntimeError(f"Job {job_id} failed with status '{status}'")

        time.sleep(poll_interval_seconds)


def main() -> None:
    parser = argparse.ArgumentParser(
        description="Run a Deepfaic Edge impersonation check for a media file."
    )
    parser.add_argument("media_file", help="Path to the local media file to analyze")
    parser.add_argument(
        "--base-url",
        default=DEFAULT_BASE_URL,
        help=f"Edge API base URL. Defaults to {DEFAULT_BASE_URL}",
    )
    parser.add_argument(
        "--runtime-root",
        default=".",
        help="Path to the edge runtime root containing CONFIG.yaml and api_cred.txt",
    )
    parser.add_argument(
        "--poll-interval",
        type=float,
        default=2.0,
        help="Polling interval in seconds for the partial job endpoint",
    )
    args = parser.parse_args()

    runtime_root = Path(args.runtime_root).resolve()
    media_path = Path(args.media_file).resolve()

    try:
        api_key = load_api_key(runtime_root)
        client = DeepfaicEdgeClient(args.base_url, api_key)

        health = client.health()
        print("Deepfaic Edge service:", health.get("service"))
        print("Organization:", health.get("org"))
        print("Allowed models:", ", ".join(health.get("allowed_models", [])))
        print()

        staged_host_path, container_input_path = stage_media_file(media_path, runtime_root)
        print("Staged media file:", staged_host_path)
        print("Container input_path:", container_input_path)
        print()

        job_title = f"Edge impersonation check - {media_path.name}"

        started_at = time.perf_counter()
        job_id = client.create_job(container_input_path, job_title)
        print(f"Created edge job {job_id}")
        print()

        wait_for_completion(
            client=client,
            job_id=job_id,
            poll_interval_seconds=args.poll_interval,
            started_at=started_at,
        )

        full_job = client.get_full_job(job_id)
        total_seconds = time.perf_counter() - started_at

        print()
        print("Final job details")
        print("-----------------")
        print("job_id:", full_job.get("id"))
        print("title:", full_job.get("title"))
        print("file_type:", full_job.get("file_type"))
        print("status:", full_job.get("status"))
        print("models:", ", ".join(full_job.get("models", [])))
        print("video_time:", format_optional(full_job.get("video_time")))
        print("audio_time:", format_optional(full_job.get("audio_time")))
        print("progress:", format_optional(full_job.get("progress")))
        print(f"pipeline_time_seconds: {total_seconds:.2f}")
        print()

        if "video" in full_job:
            print_lane("video", full_job["video"])
        if "audio" in full_job:
            print_lane("audio", full_job["audio"])
        if "image" in full_job:
            print_lane("image", full_job["image"])

    except KeyboardInterrupt:
        print("Interrupted by user")
        sys.exit(1)
    except requests.HTTPError as error:
        response_text = ""
        if error.response is not None:
            response_text = error.response.text
        print(f"HTTP error: {error}\n{response_text}")
        sys.exit(1)
    except Exception as error:
        print(f"Error: {error}")
        sys.exit(1)


if __name__ == "__main__":
    main()

"""
Deepfaic API Tutorial Script
A simple command-line tool for deepfake detection using the Deepfaic API.

Usage: python deepfaic.py <filepath>
"""

import requests
import time
import sys
import os
from typing import Dict, Any

# Configuration
API_BASE_URL = "https://api.deepfaic.com/v1"
API_KEY = "your_key_here"  # Replace with your actual API key

class DeepfaicClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
        self.session = requests.Session()
        self.session.headers.update(self.headers)
    
    def upload_file(self, file_path: str) -> str:
        """Upload a file to Deepfaic and return the file ID."""
        print(f"📤 Uploading file: {os.path.basename(file_path)}")
        
        # Prepare file upload - note: don't include Content-Type for multipart
        upload_headers = {"Authorization": f"Bearer {self.api_key}"}
        
        with open(file_path, 'rb') as file:
            files = {'file': (os.path.basename(file_path), file)}
            response = requests.post(
                f"{API_BASE_URL}/file/upload",
                headers=upload_headers,
                files=files
            )
        
        if response.status_code != 200:
            raise Exception(f"File upload failed: {response.text}")
        
        result = response.json()
        file_id = result['data']['id']
        print(f"✅ File uploaded successfully! File ID: {file_id}")
        return file_id
    
    def create_job(self, file_id: str) -> int:
        """Create a deepfake analysis job and return the job ID."""
        print(f"🚀 Creating analysis job for file ID: {file_id}")
        
        job_data = {
            "file_id": file_id,
            "title": f"API Tutorial Analysis - {time.strftime('%Y-%m-%d %H:%M:%S')}"
        }
        
        response = self.session.post(f"{API_BASE_URL}/job/create", json=job_data)
        
        if response.status_code != 200:
            raise Exception(f"Job creation failed: {response.text}")
        
        result = response.json()
        job_data_response = result['data']
        
        # Extract the actual job ID from the response
        if isinstance(job_data_response, dict) and 'job_id' in job_data_response:
            job_id = job_data_response['job_id']
        else:
            job_id = job_data_response
        
        print(f"✅ Job created successfully! Job ID: {job_id}")
        return job_id
    
    def get_job_status(self, job_id: int) -> Dict[str, Any]:
        """Get the current status and results of a job."""
        response = self.session.get(f"{API_BASE_URL}/job/get/full?job_id={job_id}")
        
        if response.status_code != 200:
            raise Exception(f"Failed to get job status: {response.text}")
        
        result = response.json()
        return result['data'][0] if result['data'] else None
    
    def wait_for_completion(self, job_id: int) -> Dict[str, Any]:
        """Wait for job completion and return the final results."""
        print(f"⏱️ Monitoring job {job_id} for completion...")
        
        while True:
            job_data = self.get_job_status(job_id)
            
            if not job_data:
                raise Exception("Job not found")
            
            status = job_data['job']['status']
            print(f"📊 Current status: {status}")
            
            if status == 'complete':
                print("🎉 Analysis completed!")
                return job_data
            elif 'error' in status.lower():
                raise Exception(f"Job failed with status: {status}")
            
            # Wait 2 seconds before checking again
            time.sleep(2)
    
    def display_results(self, job_data: Dict[str, Any]):
        """Display the analysis results in a user-friendly format."""
        print("\n" + "="*60)
        print("🔍 DEEPFAKE ANALYSIS RESULTS")
        print("="*60)
        
        job_info = job_data['job']
        print(f"📁 File: {job_info['file_name']}")
        print(f"📅 Analyzed: {job_info['created_at']}")
        print(f"⏱️ Duration: {job_info.get('length', 'N/A')}")
        print(f"📝 Type: {job_info['file_type']}")
        
        print("\n🤖 AI Model Results:")
        print("-" * 40)
        
        # Video Model Results (Visual Analysis)
        video = job_data.get('video')
        if video and video.get('status') == 'complete':
            score = video.get('score')
            if score is not None:
                # Score is between 0-1, convert to percentage for display
                score_percent = score * 100
                confidence = "HIGH" if score >= 0.6 else "MEDIUM" if score > 0.5 else "LOW"
                print(f"🎥 Video Analysis: {score_percent:.1f}% | {confidence} CONFIDENCE")
                if score >= 0.6:
                    print("   ⚠️  High probability of visual deepfake detected!")
                else:
                    print("   ✅ Video appears authentic")
            else:
                print("🎥 Video: Analysis completed with no detections")
        
        # Audio Model Results
        audio = job_data.get('audio')
        if audio and audio.get('status') == 'complete':
            score = audio.get('score')
            if score is not None:
                # Score is between 0-1, convert to percentage for display
                score_percent = score * 100
                confidence = "HIGH" if score >= 0.6 else "MEDIUM" if score > 0.5 else "LOW"
                print(f"�️ Audio Analysis: {score_percent:.1f}% | {confidence} CONFIDENCE")
                if score >= 0.6:
                    print("   ⚠️  High probability of synthetic audio detected!")
                else:
                    print("   ✅ Audio appears authentic")
            else:
                print("🎙️ Audio: Analysis completed with no detections")
        
        print("\n" + "="*60)
        
        # Overall assessment
        all_scores = [s for s in [video.get('score') if video else None, 
                                   audio.get('score') if audio else None] if s is not None]
        if all_scores:
            avg_score = sum(all_scores) / len(all_scores)
            if avg_score >= 0.6:
                print("🚨 VERDICT: HIGH RISK - Potential deepfake detected!")
            elif avg_score > 0.4:
                print("⚠️ VERDICT: MEDIUM RISK - Manual review recommended")
            else:
                print("✅ VERDICT: LOW RISK - Content appears authentic")
        
        print("="*60)

def main():
    """Main function to run the deepfake detection script."""
    
    # Check command line arguments
    if len(sys.argv) != 2:
        print("❌ Usage: python deepfaic.py <filepath>")
        print("📝 Example: python deepfaic.py ./video.mp4")
        sys.exit(1)
    
    file_path = sys.argv[1]
    
    # Validate file exists
    if not os.path.exists(file_path):
        print(f"❌ Error: File '{file_path}' not found!")
        sys.exit(1)
    
    try:
        print("🚀 Starting Deepfaic Analysis...")
        print(f"📁 Target file: {file_path}")
        
        # Initialize client
        client = DeepfaicClient(API_KEY)
        
        # Step 1: Upload file
        file_id = client.upload_file(file_path)
        
        # Step 2: Create job
        job_id = client.create_job(file_id)
        
        # Step 3: Wait for completion
        job_data = client.wait_for_completion(job_id)
        
        # Step 4: Display results
        client.display_results(job_data)
        
    except KeyboardInterrupt:
        print("\n⏹️ Analysis interrupted by user")
        sys.exit(0)
    except Exception as e:
        print(f"\n❌ Error: {str(e)}")
        sys.exit(1)

if __name__ == "__main__":
    main()