import gradio as gr
from reports.pdf_report import generate_pdf_report
from utils.youtube_utils import download_youtube_video
import modal

verify_faces_remote = modal.Function.lookup("deepface-agent", "verify_faces_remote")
verify_voices_remote = modal.Function.lookup("deepface-agent", "verify_voices_remote")
verify_faces_in_video_remote = modal.Function.lookup(
    "deepface-agent", "verify_faces_in_video_remote"
)


# Holds latest results
last_face_result = None
last_voice_result = None
last_video_results = None


def compare_faces(img1_path: str, img2_path: str) -> str:
    """Use this tool to compare to faces for a match
    Args:
        img1_path: The path to the first image
        img2_path: The path to the second image
    """
    global last_face_result

    # Read image files as bytes
    with open(img1_path, "rb") as f1, open(img2_path, "rb") as f2:
        img1_bytes = f1.read()
        img2_bytes = f2.read()

    result = verify_faces_remote.remote(img1_bytes, img2_bytes)
    result_text = ""

    if "error" in result:
        return f"❌ Error: {result['error']}"

    if result["verified"]:
        result_text = f"✅ Match! Distance: {result['distance']:.4f} (Threshold: {result['threshold']})"
        last_face_result = result_text
        return result_text

    else:
        result_text = f"❌ No Match. Distance: {result['distance']:.4f} (Threshold: {result['threshold']})"
        last_face_result = result_text
        return result_text


def compare_voices(audio1: str, audio2: str) -> str:
    """Use this tool to compare two voices for a match
    Args:
        audio1: The path to the first audio file
        audio2: The path to the second audio file
    """
    global last_voice_result

    try:
        with open(audio1, "rb") as a1, open(audio2, "rb") as a2:
            audio1_bytes = a1.read()
            audio2_bytes = a2.read()

        result = verify_voices_remote.remote(audio1_bytes, audio2_bytes)
        result_text = ""

        if "error" in result:
            return f"❌ Error: {result['error']}"

        if result["match"]:
            result_text = f"✅ Same speaker detected. Similarity: {result['similarity']} (Threshold: {result['threshold']})"
            last_voice_result = result_text
            return result_text
        else:
            result_text = f"❌ Different speakers. Similarity: {result['similarity']} (Threshold: {result['threshold']})"
            last_voice_result = result_text
            return result_text
    except Exception as e:
        return f"❌ Error reading audio files: {str(e)}"


def scan_video(video_file: str, ref_img: str, youtube_url="") -> str:
    """Use this tool to scan a video for deepfake face swaps
    Args:
        video_file: The path to the video file
        ref_img: The path to the reference image
        youtube_url: The YouTube URL (optional)
    """
    global last_video_results

    if youtube_url:
        try:
            video_file = download_youtube_video(youtube_url)
        except Exception as e:
            return f"❌ Error downloading YouTube video: {str(e)}"

    with open(video_file, "rb") as vf, open(ref_img, "rb") as rf:
        video_bytes = vf.read()
        ref_img_bytes = rf.read()
    try:
        results = verify_faces_in_video_remote.remote(video_bytes, ref_img_bytes, interval=30)
        
    except Exception as e:
        return f"❌ Error processing  video: {str(e)}"

    report = ""
    last_video_results = results
    for r in results:
        if "error" in r:
            report += f"\n⚠️ Frame {r['frame']}: {r['error']}"

        else:
            status = "✅ Match" if r["verified"] else "❌ Mismatch"
            report += f"\n🖼 Frame {r['frame']}: {status} (Distance: {r['distance']})"

    return report


def generate_report():
    return generate_pdf_report(last_face_result, last_voice_result, last_video_results)


with gr.Blocks(title="Deepfake Watchdog") as demo:
    gr.Markdown("# 🛡️Deepfake Watchdog 🤗")
    gr.Markdown("## Upload your image and/or voice to scan for deepfake misuse online.")

    # Face Verification
    with gr.Tab("Face Verification"):
        image1 = gr.Image(label="Upload your face", type="filepath")
        # audio = gr.Audio(label="Upload your voice (optional)", type="filepath")
        image2 = gr.Image(label="Upload another face", type="filepath")

        # face_btn = gr.Button("Compare Faces")

        run_button = gr.Button("Compare Faces")
        output_text = gr.Textbox(label="Result")
        # output_gallery = gr.Gallery(label="Matched Results")

        run_button.click(compare_faces, inputs=[image1, image2], outputs=[output_text])

    # Voice Verification
    with gr.Tab("🎤 Voice Verification"):
        gr.Markdown("Upload two audio files to check if the voices match.")

        audio1 = gr.Audio(type="filepath", label="Voice Sample 1")
        audio2 = gr.Audio(type="filepath", label="Voice Sample 2")

        voice_btn = gr.Button("Compare Voices")
        voice_output = gr.Textbox(label="Result")

        voice_btn.click(compare_voices, inputs=[audio1, audio2], outputs=voice_output)

    with gr.Tab("📹 Video Deepfake Scan"):
        gr.Markdown(
            "🔍 Upload a video or paste a YouTube link and we'll analyze it for deepfake face swaps."
        )

        ref_img = gr.Image(type="filepath", label="Reference Face")
        video_input = gr.Video(label="Video File (optional)")
        youtube_url = gr.Textbox(label="YouTube URL (optional)")
        scan_btn = gr.Button("Scan Video")
        scan_output = gr.Textbox(label="Scan Results", lines=10)

        scan_btn.click(
            scan_video, inputs=[video_input, ref_img, youtube_url], outputs=scan_output
        )

    with gr.Tab("📄 Generate Report"):
        report_btn = gr.Button("Generate PDF Report")
        report_output = gr.File(label="Download Report")

        report_btn.click(generate_report, outputs=report_output)


demo.launch(mcp_server=True)