import logging
import requests
from urllib.parse import urlparse
import subprocess
from pathlib import Path
from moviepy.editor import VideoFileClip
import gradio as gr
import http.server
import socketserver
import threading
import socket

# Define output directory
output_dir = Path.cwd() / "output"
output_dir.mkdir(exist_ok=True)

logging.basicConfig(level=logging.INFO)

standard_resolutions = [240, 360, 480, 720, 1080, 1440, 2160, 4320]

def start_http_server(port=8000):
    handler = http.server.SimpleHTTPRequestHandler
    httpd = socketserver.TCPServer(("", port), handler)
    logging.info(f"Serving at port {port}")
    thread = threading.Thread(target=httpd.serve_forever)
    thread.start()

def get_ip_address():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        s.connect(('10.255.255.255', 1))
        IP = s.getsockname()[0]
    except Exception:
        IP = '127.0.0.1'
    finally:
        s.close()
    return IP

def download_file(url, destination):
    response = requests.get(url)
    response.raise_for_status()
    with open(destination, 'wb') as f:
        f.write(response.content)

def get_input_path(video_file, video_url):
    if video_file is not None:
        return Path(video_file.name)
    elif video_url:
        url_path = urlparse(video_url).path
        file_name = Path(url_path).name
        destination = output_dir / file_name
        download_file(video_url, destination)
        return destination
    else:
        raise ValueError("No input was provided.")

def get_output_path(input_path, res):
    output_path = output_dir / (Path(input_path).stem + f"_{res}p.m3u8")
    return output_path

def create_master_playlist(output_paths):
    master_playlist_path = output_dir / "master_playlist.m3u8"
    with open(master_playlist_path, "w") as f:
        f.write("#EXTM3U\n")
        for path in output_paths:
            f.write(f'#EXT-X-STREAM-INF:BANDWIDTH=8000000,RESOLUTION={Path(path).stem.split("_")[1]}\n')
            f.write(f'{Path(path).name}\n')
    return master_playlist_path

def convert_video(video_file, quality, aspect_ratio, video_url):
    input_path = get_input_path(video_file, video_url)

    video = VideoFileClip(str(input_path))

    # Get the original height to avoid upscaling
    original_height = video.size[1]

    output_paths = []

    for res in standard_resolutions:
        if res > original_height:
            continue

        scale = "-1:" + str(res)
        output_path = get_output_path(input_path, str(res) + 'p')

        ffmpeg_command = [
            "ffmpeg", "-i", str(input_path), "-c:v", "libx264", "-crf", str(quality),
            "-vf", f"scale={scale}:force_original_aspect_ratio=decrease,pad=ceil(iw/2)*2:ceil(ih/2)*2",
            "-hls_time", "10", "-hls_playlist_type", "vod", "-hls_segment_filename",
            str(output_dir / f"{output_path.stem}_%03d.ts"), str(output_path)
        ]

        logging.info("Running ffmpeg command: " + ' '.join(ffmpeg_command))
        subprocess.run(ffmpeg_command, check=True)

        output_paths.append(output_path)

    master_playlist_path = create_master_playlist(output_paths)
    output_paths.append(master_playlist_path)

    server_ip = get_ip_address()
    output_links = []
    for path in output_paths:
        output_links.append(f'<a href="http://{server_ip}:8000/{path}" target="_blank">Download {Path(path).stem}</a>')

    output_html = "<br>".join(output_links)
    return output_html

video_file = gr.inputs.File(label="Your video file")
quality = gr.inputs.Slider(minimum=1, maximum=50, label="Quality (1:Speed - 50:Quality)")
aspect_ratio = gr.inputs.Dropdown(["16:9", "4:3", "1:1", "3:4", "9:16", "1:1", "2:1", "1:2"], label="Aspect Ratio", default="16:9")
video_url = gr.inputs.Textbox(lines=1, placeholder="or paste video url here", label="Video URL")

interface = gr.Interface(
    fn=convert_video, 
    inputs=[video_file, quality, aspect_ratio, video_url],
    outputs=gr.outputs.HTML(label="Download Links"),
    title="NEAR Hub Video Transcoder to m3u8",
    description="convert video files to m3u8 for VOD streaming",
    allow_flagging='never'
)

start_http_server()
interface.launch(server_name=get_ip_address(), server_port=7860)