import streamlit as st
import os
import subprocess

def main():
    st.title("Smart Edit Assistant")

    # 1. Upload a video
    uploaded_file = st.file_uploader("Upload your video", type=["mp4", "mov", "mkv"])

    if uploaded_file:
        # Save the uploaded file to temp_input.mp4
        with open("temp_input.mp4", "wb") as f:
            f.write(uploaded_file.getbuffer())

        # Display the original video
        st.video("temp_input.mp4")

        # Button to process the video
        if st.button("Process Video"):
            # Extract audio using FFmpeg
            with st.spinner("Extracting audio..."):
                audio_path = extract_audio_ffmpeg("temp_input.mp4", "temp_audio.wav")

            # Transcribe audio (placeholder)
            with st.spinner("Transcribing..."):
                transcript_text = transcribe_audio(audio_path)
            st.text_area("Transcript", transcript_text, height=200)

            # Generate editing instructions (placeholder)
            with st.spinner("Generating edit instructions..."):
                edit_instructions = generate_edit_instructions(transcript_text)
            st.write("AI Edit Instructions:", edit_instructions)

            # Apply edits (placeholder) with FFmpeg
            with st.spinner("Applying edits..."):
                edited_video_path = apply_edits("temp_input.mp4", edit_instructions)

            # Verify the edited video file
            abs_edited_path = os.path.join(os.getcwd(), edited_video_path)
            if not os.path.exists(abs_edited_path):
                st.error(f"Edited video file not found at '{abs_edited_path}'. Check logs.")
                return

            file_size = os.path.getsize(abs_edited_path)
            if file_size == 0:
                st.error("Edited video file is empty (0 bytes). Check ffmpeg or editing logic.")
                return

            st.success("Edit complete! Now previewing the edited video.")
            st.video(abs_edited_path)

            # Provide a download button for the edited file
            with open(abs_edited_path, "rb") as f_out:
                st.download_button(
                    label="Download Edited Video",
                    data=f_out,
                    file_name="edited_result.mp4",
                    mime="video/mp4",
                )


def extract_audio_ffmpeg(input_video, output_audio):
    """
    Calls ffmpeg to extract audio. Returns the output_audio path if successful; raises if not.
    """
    cmd = [
        "ffmpeg", "-y",
        "-i", input_video,
        "-vn",  # Strip out the video
        "-acodec", "pcm_s16le",
        "-ar", "16000",
        "-ac", "1",
        output_audio
    ]
    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    if result.returncode != 0:
        raise RuntimeError(f"ffmpeg error: {result.stderr.decode()}")
    return output_audio


def transcribe_audio(audio_path):
    """
    Placeholder for your transcription logic (local Whisper, OpenAI Whisper API, etc.).
    Here, we simply return a mock transcript for demonstration.
    """
    return "This is a mock transcript."


def generate_edit_instructions(transcript_text):
    """
    Placeholder for GPT or other LLM-based logic. 
    Return instructions (text, JSON, etc.) detailing how to edit the video.
    """
    return "Keep everything; no major edits."


def apply_edits(input_video, edit_instructions):
    """
    A simple placeholder function. In practice, you'd parse instructions 
    and run ffmpeg/moviepy to cut or reassemble the video. 
    Here, we just do a direct copy with ffmpeg to simulate a final step.
    """
    output_video = "edited_video.mp4"
    cmd = ["ffmpeg", "-y", "-i", input_video, "-c", "copy", output_video]
    result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    if result.returncode != 0:
        raise RuntimeError(f"ffmpeg editing error: {result.stderr.decode()}")
    return output_video


if __name__ == "__main__":
    main()