#!/usr/bin/env python3
"""
Gradio app to convert one or more MIDI files into Geometry Dash .gmd files
(using midi_to_gd.py). For each uploaded MIDI the app will create a .gmd
file (plist wrapper with compressed k4 level string) and return a zip
containing all generated .gmd files.
"""
import os
import sys
import tempfile
import zipfile
import traceback
from typing import List, Tuple

HERE = os.path.dirname(os.path.abspath(__file__))
if HERE not in sys.path:
    sys.path.insert(0, HERE)

try:
    import gradio as gr
except Exception as e:
    raise RuntimeError("Gradio is required. Install with: pip install gradio") from e

# Import functions from the provided script
try:
    from midi_to_gd import (
        parse_midi_notes,
        generate_gd_level_objects,
        build_full_level_string,
        encrypt_level_string,
    )
except Exception as e:
    raise RuntimeError("Failed to import from midi_to_gd.py. Ensure the file is in the same directory.") from e


def _get_local_path_from_gr_file(f) -> str:
    """
    Accepts the various shapes Gradio may pass:
      - a filesystem path string
      - a dict like {'name': '/tmp/....'}
      - a list of the above (we only call this per-file)
    Returns a single filesystem path string or empty if not found.
    """
    if not f:
        return ""
    if isinstance(f, str):
        return f
    if isinstance(f, (list, tuple)) and f:
        # take first element
        return _get_local_path_from_gr_file(f[0])
    if isinstance(f, dict):
        # Gradio sometimes returns {'name': '/tmp/...'}
        return f.get("name") or f.get("file") or ""
    # Fallback: try attribute .name
    return getattr(f, "name", "")


def convert_midis_to_zip(midi_files: List, beats_scale: float = 2.0, name_prefix: str = "") -> Tuple[str, str]:
    """
    Process uploaded midi files (list), generate .gmd files for each, and return
    a path to a zip archive and a status text message.

    Returns:
      (zip_file_path, status_message)
    """
    try:
        if not midi_files:
            return None, "No MIDI files uploaded."

        out_dir = tempfile.mkdtemp(prefix="gd_midis_")
        created_files = []

        # midi_files is expected to be a list of file paths (type="filepath")
        for idx, f in enumerate(midi_files, start=1):
            midi_path = _get_local_path_from_gr_file(f)
            if not os.path.exists(midi_path):
                return None, f"Uploaded file not found on disk: {midi_path}"

            base = os.path.splitext(os.path.basename(midi_path))[0]
            level_name = f"{name_prefix}{'_' if name_prefix else ''}{base}" if name_prefix else base

            notes = parse_midi_notes(midi_path)
            raw_objects = generate_gd_level_objects(notes, blocks_per_beat=beats_scale)

            full_level_data = build_full_level_string(raw_objects)
            encrypted_k4 = encrypt_level_string(full_level_data)

            gmd_content = f"""<?xml version="1.0"?>
<plist version="1.0" gjver="2.0">
    <dict>
        <key>kCEK</key><i>4</i>
        <key>k2</key><s>{level_name}</s>
        <key>k3</key><s>MIDI converted Piano Roll</s>
        <key>k4</key><s>{encrypted_k4}</s>
        <key>k5</key><s>Player</s>
    </dict>
</plist>"""

            out_path = os.path.join(out_dir, f"{level_name}.gmd")
            with open(out_path, "w", encoding="utf-8") as wf:
                wf.write(gmd_content)
            created_files.append(out_path)

        zip_path = os.path.join(out_dir, "gd_levels.zip")
        with zipfile.ZipFile(zip_path, "w", compression=zipfile.ZIP_DEFLATED) as zf:
            for p in created_files:
                zf.write(p, arcname=os.path.basename(p))

        status_lines = [
            f"Generated {len(created_files)} .gmd file(s).",
            f"ZIP archive: {os.path.basename(zip_path)}",
            "Files:",
        ] + [f"- {os.path.basename(p)}" for p in created_files]

        return zip_path, "\n".join(status_lines)
    except Exception:
        tb = traceback.format_exc()
        return None, f"Error during conversion:\n{tb}"


def launch_ui():
    with gr.Blocks() as demo:
        gr.Markdown("# MIDI → Geometry Dash (.gmd) Converter")
        gr.Markdown(
            "Upload one or more MIDI files. The app will convert each MIDI into a Geometry Dash .gmd "
            "file (plist wrapper with compressed level string) and return a ZIP archive containing all generated .gmd files."
        )

        with gr.Row():
            # NOTE: type="filepath" is the correct modern API. 'file' is invalid.
            midi_input = gr.File(label="Upload MIDI files (.mid/.midi)", file_count="multiple", type="filepath")
            settings_col = gr.Column(scale=1)
            beats_scale = gr.Number(value=2.0, label="Blocks per beat (blocks/quarter-note)", precision=2)
            name_prefix = gr.Textbox(label="Optional level name prefix", placeholder="Prefix (optional)")
        convert_btn = gr.Button("Convert and Download ZIP")

        output_zip = gr.File(label="Download ZIP of .gmd files")
        status = gr.Textbox(label="Status", interactive=False, lines=6)

        def _on_click(files, beats, prefix):
            zip_path, status_text = convert_midis_to_zip(files, beats, prefix)
            return zip_path, status_text

        convert_btn.click(fn=_on_click, inputs=[midi_input, beats_scale, name_prefix], outputs=[output_zip, status])

        gr.Markdown("Notes: mido is required to parse MIDI files. Install with `pip install mido`.")
        gr.Markdown("If the app cannot find your local CCLocalLevels.dat or you just want the .gmd files, use the ZIP to import them with your editor.")

    demo.launch()


if __name__ == "__main__":
    launch_ui()