app.py

"""Manifold Visualizer — Flask backend.

Serves manifold generation, presets, and live performance APIs.
Also serves as a fallback when the GPU server is unreachable — nginx
routes to this if the GPU upstream returns 502/503/504.
"""

import os
import re
import subprocess
import sys
from flask import Flask, jsonify, render_template, request

# Add lambda/ to sys.path so we can import from it (can't use 'from lambda.x'
# because 'lambda' is a Python keyword)
sys.path.insert(0, os.path.join(os.path.dirname(__file__), "lambda"))

app = Flask(__name__)


# ---------------------------------------------------------------------------
# Fallback: serve the full app when GPU server is down
# ---------------------------------------------------------------------------

@app.route("/")
def index():
    return render_template("index.html")


# Import manifold generators for fallback API
from manifolds import GENERATORS, MANIFOLD_INFO, MANIFOLD_PARAMS


@app.route("/api/manifold/<manifold_type>")
def manifold(manifold_type):
    if manifold_type not in GENERATORS:
        return jsonify({"error": f"Unknown manifold type: {manifold_type}",
                        "available": list(GENERATORS.keys())}), 404

    resolution = request.args.get("resolution", 30, type=int)
    resolution = max(4, min(resolution, 120))

    kwargs = {}
    param_defs = MANIFOLD_PARAMS.get(manifold_type, {})
    for pname, pdef in param_defs.items():
        val = request.args.get(pname, type=float)
        if val is not None:
            kwargs[pname] = val

    result = GENERATORS[manifold_type](resolution, **kwargs)

    if isinstance(result, dict) and result.get("gpu_fractal"):
        result["params"] = {**result.get("params", {}), **kwargs}
        result["info"] = MANIFOLD_INFO.get(manifold_type, {})
        resp = jsonify(result)
        resp.headers["Access-Control-Allow-Origin"] = "*"
        return resp

    verts, faces, normals, curvature = result

    info = MANIFOLD_INFO.get(manifold_type, {})
    resp = jsonify({
        "type": manifold_type,
        "vertices": verts,
        "faces": faces,
        "normals": normals,
        "curvature": curvature,
        "params": {"resolution": resolution, **kwargs},
        "info": info,
    })
    resp.headers["Access-Control-Allow-Origin"] = "*"
    return resp


@app.route("/api/manifold/<manifold_type>/params")
def manifold_params(manifold_type):
    if manifold_type not in GENERATORS:
        return jsonify({"error": f"Unknown manifold type: {manifold_type}"}), 404
    params = MANIFOLD_PARAMS.get(manifold_type, {})
    info = MANIFOLD_INFO.get(manifold_type, {})
    return jsonify({"type": manifold_type, "params": params, "info": info})


@app.route("/api/manifolds")
def list_manifolds():
    manifolds = {}
    for name in GENERATORS:
        info = MANIFOLD_INFO.get(name, {})
        manifolds[name] = {
            "category": info.get("category", "classic"),
            "has_params": bool(MANIFOLD_PARAMS.get(name)),
        }
    return jsonify({"manifolds": manifolds})


# Fallback presets (import from extracted module)
from presets import PresetStore

_preset_store = PresetStore()


@app.route("/api/presets", methods=["GET"])
def list_presets():
    return jsonify(_preset_store.list_all())


@app.route("/api/presets/<name>", methods=["GET"])
def get_preset(name):
    preset = _preset_store.get(name)
    if preset is None:
        return jsonify({"error": f"Preset not found: {name}"}), 404
    return jsonify(preset)


@app.route("/api/presets", methods=["POST"])
def save_preset():
    body = request.get_json()
    if not body or "name" not in body:
        return jsonify({"error": "Preset must have a 'name' field"}), 400
    result, status = _preset_store.save(body)
    return jsonify(result), status


@app.route("/api/presets/<name>", methods=["DELETE"])
def delete_preset(name):
    result, status = _preset_store.delete(name)
    return jsonify(result), status


# ---------------------------------------------------------------------------
# Live Performance — SuperCollider proxy endpoints
# ---------------------------------------------------------------------------

ALLOWED_SYNTHS = {
    'dubKick', 'dubSnare', 'dubHat', 'wobbleClassic', 'wobbleGrowl',
    'fmBassClassic', 'neuroReese', 'riddimBass', 'riser', 'impact',
    'fxSweep', 'dubstepBass', 'padWarm', 'leadSharp',
}

ALLOWED_PARAM_KEYS = {'amp', 'freq', 'dur', 'pan', 'gate', 'attack', 'release', 'sustain', 'decay'}


@app.route("/api/live/trigger", methods=["POST"])
def live_trigger():
    """Trigger a SuperCollider synth via the audio-processing-suite CLI."""
    body = request.get_json() or {}
    synth = body.get("synth", "dubKick")

    if synth not in ALLOWED_SYNTHS:
        return jsonify({"error": f"Unknown synth: {synth}"}), 400

    params = body.get("params", {})

    cmd = ["audio-suite", "system", "osc-send", "/s_new", synth, "1000", "0", "0"]
    for k, v in params.items():
        if k not in ALLOWED_PARAM_KEYS:
            continue
        try:
            float(v)
            cmd.extend([str(k), str(v)])
        except (TypeError, ValueError):
            continue

    try:
        subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
    except FileNotFoundError:
        pass

    return jsonify({"status": "triggered", "synth": synth})


@app.route("/api/live/pattern", methods=["POST"])
def live_pattern():
    """Control the pattern sequencer."""
    body = request.get_json() or {}
    action = body.get("action")

    if action == "start":
        pattern = body.get("pattern", "dubstep_classic")
        if not re.match(r'^[a-zA-Z0-9_]+$', pattern):
            return jsonify({"error": "Invalid pattern name"}), 400
        try:
            subprocess.Popen(["audio-suite", "pattern", "quick", pattern],
                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        except FileNotFoundError:
            pass
    elif action == "stop":
        try:
            subprocess.Popen(["audio-suite", "pattern", "stop"],
                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        except FileNotFoundError:
            pass
    elif action == "bpm":
        bpm = body.get("value", 140)
        try:
            bpm = int(float(bpm))
            bpm = max(40, min(300, bpm))
            subprocess.Popen(["audio-suite", "pattern", "bpm", str(bpm)],
                             stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
        except (TypeError, ValueError, FileNotFoundError):
            pass

    return jsonify({"status": "ok", "action": action})


@app.route("/api/live/status")
def live_status():
    """Check SuperCollider connection status."""
    try:
        result = subprocess.run(
            ["audio-suite", "system", "status"],
            capture_output=True, text=True, timeout=3
        )
        connected = result.returncode == 0
    except (FileNotFoundError, subprocess.TimeoutExpired):
        connected = False

    return jsonify({"connected": connected})


# ---------------------------------------------------------------------------
# CORS + Cache headers
# ---------------------------------------------------------------------------

@app.after_request
def add_cors(response):
    response.headers["Access-Control-Allow-Origin"] = "*"
    response.headers["Access-Control-Allow-Headers"] = "Content-Type"
    response.headers["Access-Control-Allow-Methods"] = "GET, POST, DELETE, OPTIONS"
    response.headers["Cache-Control"] = "no-store, no-cache, must-revalidate"
    return response


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8123, debug=False)