import os
import random
import ffmpeg
import gradio as gr
import traceback

# Global variable to store logs
debug_logs = []

# Function to log messages
def log_message(message):
    global debug_logs
    debug_logs.append(message)
    print(message)  # Print to console as well for backend debugging

# Function to add music to video
def add_music_to_video(video_path, chunks_folder="chunks", output_path="output_with_music.mp4"):
    try:
        log_message("Starting the process to add music to video...")
        
        # Check if chunks folder exists
        if not os.path.exists(chunks_folder):
            error_message = "Error: Chunks folder does not exist."
            log_message(error_message)
            return error_message

        # List all MP3 files in the chunks folder
        music_files = [os.path.join(chunks_folder, f) for f in os.listdir(chunks_folder) if f.endswith('.mp3')]
        if not music_files:
            error_message = "Error: No audio files found in the chunks folder."
            log_message(error_message)
            return error_message

        # Randomly select one MP3 file
        music_file_path = random.choice(music_files)
        log_message(f"Selected music file: {music_file_path}")

        # Get the duration of the video
        video_info = ffmpeg.probe(video_path)
        video_duration = float(video_info['streams'][0]['duration'])
        log_message(f"Video duration: {video_duration} seconds")

        # Trim the music file to match the video duration
        trimmed_music_path = "trimmed_music.mp3"
        ffmpeg.input(music_file_path).output(
            trimmed_music_path, ss=0, t=video_duration
        ).run(overwrite_output=True)
        log_message(f"Trimmed music saved at: {trimmed_music_path}")

        # Combine video and audio
        video_input = ffmpeg.input(video_path)
        audio_input = ffmpeg.input(trimmed_music_path)
        ffmpeg.concat(video_input, audio_input, v=1, a=1).output(
            output_path, vcodec="libx264", acodec="aac", strict="experimental"
        ).run(overwrite_output=True)
        log_message(f"Output video saved at: {output_path}")

        return output_path
    except Exception as e:
        error_message = f"Error during processing: {str(e)}"
        log_message(error_message)
        traceback.print_exc()
        return error_message

# Define Gradio interface
def process_video(uploaded_video):
    try:
        log_message("Video received for processing.")
        video_path = uploaded_video.name
        log_message(f"Uploaded video path: {video_path}")

        output_video = add_music_to_video(video_path, chunks_folder="/content/chunks")
        if "Error" in output_video:
            return None, "\n".join(debug_logs)

        return output_video, "\n".join(debug_logs)
    except Exception as e:
        error_message = f"Error in process_video: {str(e)}"
        log_message(error_message)
        traceback.print_exc()
        return None, "\n".join(debug_logs)

# Gradio Interface
with gr.Blocks() as interface:
    gr.Markdown("# Add Background Music to Video")
    gr.Markdown("Upload a video, and this app will add a background music track that matches the video duration.")
    
    with gr.Row():
        with gr.Column():
            video_input = gr.Video(label="Upload Video")
            submit_button = gr.Button("Generate Video")
        with gr.Column():
            video_output = gr.Video(label="Video with Background Music")
            debug_output = gr.Textbox(label="Debug Logs", lines=10, interactive=False)
    
    submit_button.click(
        fn=process_video,
        inputs=[video_input],
        outputs=[video_output, debug_output]
    )

# Launch Gradio app
interface.launch(share=True, debug=True)