# Monkey patch MUST be first - before any other imports!
import eventlet
eventlet.monkey_patch()

import os
import json
import re
import subprocess
import threading
import queue
import time
import collections
import hmac
from flask import Flask, send_from_directory, jsonify, request, session, Response, stream_with_context, abort, render_template, make_response
from flask_socketio import SocketIO, emit
from dotenv import load_dotenv
load_dotenv()



def _load_config():
    """Loads optional config.json from the project root.

    If missing or invalid, returns an empty dict.
    """
    try:
        with open('config.json', 'r', encoding='utf-8') as f:
            data = json.load(f)
        return data if isinstance(data, dict) else {}
    except FileNotFoundError:
        return {}
    except Exception:
        return {}


CONFIG = _load_config()

# --- Config-driven settings (config.json > env vars > defaults) ---
CONFIG_HOST = (CONFIG.get('host') or os.environ.get('HOST') or '0.0.0.0').strip()
CONFIG_DJ_PORT = int(CONFIG.get('dj_port') or os.environ.get('DJ_PORT') or 5000)
CONFIG_LISTENER_PORT = int(CONFIG.get('listener_port') or os.environ.get('LISTEN_PORT') or 5001)
CONFIG_SECRET = (CONFIG.get('secret_key') or '').strip() or 'dj_panel_secret'
CONFIG_CORS = CONFIG.get('cors_origins', '*')
CONFIG_MAX_UPLOAD_MB = int(CONFIG.get('max_upload_mb') or 500)
CONFIG_DEBUG = bool(CONFIG.get('debug', False))
CONFIG_LISTENER_URL = (CONFIG.get('listener_url') or '').strip()

# MediaMTX / SRT integration
# secret shared with MediaMTX webhook requests (leave blank to disable auth)
_SRT_WEBHOOK_SECRET = (CONFIG.get('mediamtx_webhook_secret') or '').strip()
# SRT ingest port MediaMTX listens on (Flask does not bind this — configure in mediamtx.yml)
_MEDIAMTX_SRT_PORT  = int(CONFIG.get('mediamtx_srt_port') or 8890)
# RTSP URL MediaMTX exposes for the incoming SRT path (used by ffmpeg to pull audio)
_MEDIAMTX_RTSP_URL = (CONFIG.get('mediamtx_rtsp_url') or 'rtsp://127.0.0.1:8554/live').strip()
_MEDIAMTX_HLS_URL  = (CONFIG.get('mediamtx_hls_url')  or 'http://techy.music:8888/aussie_dj/index.m3u8').strip()

DJ_PANEL_PASSWORD = (CONFIG.get('dj_panel_password') or '').strip()
DJ_AUTH_ENABLED = bool(DJ_PANEL_PASSWORD)

# Broadcast State
broadcast_state = {
    'active': False,
}

# SRT stream state — updated by the /api/webhook MediaMTX callback
_srt_state = {
    'active': False,
    'path': None,
    'source_id': None,
    'started_at': None,
}

# ffmpeg process that pulls audio from MediaMTX's RTSP output for an SRT session
_srt_ffmpeg_proc = None

listener_sids = set()
dj_sids = set()

# Set to True once the first audio chunk arrives in MP3-direct mode.
# broadcast_started is held back until then so listeners don't connect
# to /stream.mp3 before any data is flowing (e.g. before the DJ presses play).
_mp3_broadcast_announced = False

# Current listener glow intensity — persisted so new/reloaded listeners get the
# correct level immediately without waiting for the DJ to move the slider again.
_current_glow_intensity = 30

# Grace-period greenlet: auto-stop broadcast if DJ doesn't reconnect in time
_dj_grace_greenlet = None
DJ_GRACE_PERIOD_SECS = 20  # seconds to wait before auto-stopping

# === Optional MP3 fallback stream (server-side transcoding) ===
_ffmpeg_proc = None
_ffmpeg_in_q = queue.Queue(maxsize=200)
_current_bitrate = (CONFIG.get('stream_bitrate') or '192k').strip()
_mp3_clients = set()  # set[queue.Queue]
_mp3_lock = threading.Lock()
_transcoder_bytes_out = 0
_transcoder_last_error = None
_last_audio_chunk_ts = 0.0
_mp3_preroll = collections.deque()  # byte-budget FIFO; evicted from the front when over limit
_mp3_preroll_bytes = 0
_MP3_PREROLL_MAX_BYTES = 256 * 1024  # 256 KB ≈ 10 s at 192 kbps — enough for smooth reconnects


def _preroll_append(data: bytes) -> None:
    """Add a chunk to the pre-roll buffer, evicting the oldest data from the
    front when the byte budget is exceeded.
    MUST be called with _mp3_lock already held.
    """
    global _mp3_preroll_bytes
    _mp3_preroll.append(data)
    _mp3_preroll_bytes += len(data)
    while _mp3_preroll_bytes > _MP3_PREROLL_MAX_BYTES and _mp3_preroll:
        _mp3_preroll_bytes -= len(_mp3_preroll.popleft())


def _preroll_clear() -> None:
    """Empty the pre-roll buffer and reset its byte counter.
    MUST be called with _mp3_lock already held.
    """
    global _mp3_preroll_bytes
    _mp3_preroll.clear()
    _mp3_preroll_bytes = 0


def _start_transcoder_if_needed(is_mp3_input=False):
    global _ffmpeg_proc, _transcoder_last_error
    
    # If already running, check if we need to restart
    if _ffmpeg_proc is not None and _ffmpeg_proc.poll() is None:
        return

    # Ensure stale process is cleaned up
    if _ffmpeg_proc:
        try: _ffmpeg_proc.terminate()
        except: pass
        _ffmpeg_proc = None

    codec = 'copy' if is_mp3_input else 'libmp3lame'
    
    cmd = [
        'ffmpeg',
        '-hide_banner',
        '-loglevel', 'error',
        '-fflags', 'nobuffer',
        '-flags', 'low_delay',
        '-probesize', '32',
        '-analyzeduration', '0'
    ]
    
    if is_mp3_input:
        cmd.extend(['-f', 'mp3'])
        
    cmd.extend([
        '-i', 'pipe:0',
        '-vn',
        '-acodec', codec,
    ])
    
    if not is_mp3_input:
        cmd.extend(['-b:a', _current_bitrate])
        
    cmd.extend([
        '-flush_packets', '1',
        '-f', 'mp3',
        'pipe:1',
    ])

    try:
        _ffmpeg_proc = subprocess.Popen(
            cmd,
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            bufsize=0,
        )
    except FileNotFoundError:
        _ffmpeg_proc = None
        print('WARNING: ffmpeg not found; /stream.mp3 fallback disabled')
        return

    mode_str = "PASSTHROUGH (copy)" if is_mp3_input else f"TRANSCODE ({_current_bitrate})"
    print(f'INFO: ffmpeg transcoder started ({mode_str})')
    
    _transcoder_last_error = None

    # Clear queue to avoid stale data
    while not _ffmpeg_in_q.empty():
        try: _ffmpeg_in_q.get_nowait()
        except: break

    # Define greenlets INSIDE so they close over THIS specific 'proc'.
    # Blocking subprocess pipe I/O is delegated to eventlet.tpool so it runs
    # in a real OS thread, preventing it from stalling the eventlet hub.
    def _writer(proc):
        global _transcoder_last_error
        print(f"[THREAD] Transcoder writer started (PID: {proc.pid})")
        while proc.poll() is None:
            try:
                chunk = _ffmpeg_in_q.get(timeout=1.0)
                if chunk is None: break

                if proc.stdin:
                    proc.stdin.write(chunk)
                    proc.stdin.flush()
            except queue.Empty:
                continue
            except (BrokenPipeError, ConnectionResetError):
                _transcoder_last_error = "Broken pipe in writer"
                break
            except Exception as e:
                print(f"WARNING: Transcoder writer error: {e}")
                _transcoder_last_error = str(e)
                break

        # Ensure process is killed if greenlet exits unexpectedly
        if proc.poll() is None:
            try: proc.terminate()
            except: pass
        print(f"[THREAD] Transcoder writer finished (PID: {proc.pid})")

    def _reader(proc):
        global _transcoder_bytes_out, _transcoder_last_error
        print(f"[THREAD] Transcoder reader started (PID: {proc.pid})")
        while proc.poll() is None:
            try:
                data = proc.stdout.read(1024)
                if not data: break
                _transcoder_bytes_out += len(data)

                with _mp3_lock:
                    _preroll_append(data)
                    clients = list(_mp3_clients)

                for q in clients:
                    try:
                        q.put_nowait(data)
                    except queue.Full:
                        # Client is too slow — skip this chunk for them
                        pass
            except Exception as e:
                print(f"WARNING: Transcoder reader error: {e}")
                _transcoder_last_error = str(e)
                break

        # Ensure process is killed if greenlet exits unexpectedly
        if proc.poll() is None:
            try: proc.terminate()
            except: pass
        print(f"[THREAD] Transcoder reader finished (PID: {proc.pid})")

    # Spawn as greenlets — tpool handles the blocking subprocess I/O internally
    eventlet.spawn(_writer, _ffmpeg_proc)
    eventlet.spawn(_reader, _ffmpeg_proc)


def _stop_transcoder():
    global _ffmpeg_proc
    print("STOPPING: Transcoder process")

    proc = _ffmpeg_proc
    _ffmpeg_proc = None  # Null first so _feed_transcoder stops enqueuing

    # Drain stale input chunks so the None sentinel is guaranteed to fit and
    # the writer greenlet exits on its next get() instead of stalling.
    while True:
        try: _ffmpeg_in_q.get_nowait()
        except queue.Empty: break
    try: _ffmpeg_in_q.put_nowait(None)
    except queue.Full: pass

    if proc:
        try:
            proc.terminate()
            proc.communicate(timeout=1.0)
        except:
            try: proc.kill()
            except: pass

    with _mp3_lock:
        clients = list(_mp3_clients)
        for q in clients:
            try: q.put_nowait(None)
            except: pass
        _mp3_clients.clear()
        _preroll_clear()


# === SRT / MediaMTX transcoder ===
# When MediaMTX receives the incoming SRT stream it exposes it as an RTSP endpoint.
# We launch a dedicated ffmpeg process that *pulls* from that RTSP URL and feeds the
# same _mp3_clients / _mp3_preroll distribution system used by all other stream modes.

def _start_srt_transcoder():
    """Start an ffmpeg process that pulls from MediaMTX's RTSP output."""
    global _srt_ffmpeg_proc, _transcoder_last_error

    if _srt_ffmpeg_proc is not None and _srt_ffmpeg_proc.poll() is None:
        return  # Already running

    if _srt_ffmpeg_proc:
        try: _srt_ffmpeg_proc.terminate()
        except: pass
        _srt_ffmpeg_proc = None

    cmd = [
        'ffmpeg',
        '-hide_banner', '-loglevel', 'error',
        '-fflags', 'nobuffer', '-flags', 'low_delay',
        '-rtsp_transport', 'tcp',
        '-i', _MEDIAMTX_RTSP_URL,
        '-vn',
        '-acodec', 'libmp3lame',
        '-b:a', _current_bitrate,
        '-flush_packets', '1',
        '-f', 'mp3', 'pipe:1',
    ]

    try:
        _srt_ffmpeg_proc = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            bufsize=0,
        )
    except FileNotFoundError:
        _srt_ffmpeg_proc = None
        print('WARNING: ffmpeg not found; SRT→MP3 bridge disabled')
        return

    print(f'INFO: SRT transcoder started — pulling from {_MEDIAMTX_RTSP_URL} @ {_current_bitrate}')
    _transcoder_last_error = None

    def _srt_reader(proc):
        global _transcoder_bytes_out, _transcoder_last_error
        print(f'[THREAD] SRT reader started (PID: {proc.pid})')
        while proc.poll() is None:
            try:
                data = proc.stdout.read(4096)
                if not data:
                    break
                _transcoder_bytes_out += len(data)
                with _mp3_lock:
                    _preroll_append(data)
                    clients = list(_mp3_clients)
                for q in clients:
                    try:
                        q.put_nowait(data)
                    except queue.Full:
                        pass
            except Exception as e:
                print(f'WARNING: SRT reader error: {e}')
                _transcoder_last_error = str(e)
                break

        # Log any ffmpeg stderr output to help diagnose failures
        try:
            err = proc.stderr.read().decode(errors='replace').strip()
            if err:
                print(f'[FFMPEG SRT] {err}')
        except Exception:
            pass

        if proc.poll() is None:
            try: proc.terminate()
            except: pass
        print(f'[THREAD] SRT reader finished (PID: {proc.pid})')

    eventlet.spawn(_srt_reader, _srt_ffmpeg_proc)


def _stop_srt_transcoder():
    """Terminate the SRT→MP3 ffmpeg process and flush all listener queues."""
    global _srt_ffmpeg_proc
    print('STOPPING: SRT transcoder')

    proc = _srt_ffmpeg_proc
    _srt_ffmpeg_proc = None

    if proc:
        try:
            proc.terminate()
            proc.communicate(timeout=2.0)
        except Exception:
            try: proc.kill()
            except: pass

    with _mp3_lock:
        clients = list(_mp3_clients)
        for q in clients:
            try: q.put_nowait(None)
            except: pass
        _mp3_clients.clear()
        _preroll_clear()


def _feed_transcoder(data: bytes):
    global _last_audio_chunk_ts
    if _ffmpeg_proc is None or _ffmpeg_proc.poll() is not None:
        # If active but dead, restart it automatically (non-MP3 mode only)
        if broadcast_state.get('active'):
            _start_transcoder_if_needed(is_mp3_input=False)
        else:
            return
            
    _last_audio_chunk_ts = time.time()
    try:
        _ffmpeg_in_q.put_nowait(data)
    except queue.Full:
        # Drop chunk if overflow to prevent memory bloat
        pass


def _distribute_mp3(data: bytes):
    """Distribute MP3 bytes directly to preroll buffer and all connected listener
    clients, bypassing the ffmpeg transcoder entirely.

    Used when the DJ is already sending valid MP3 (e.g. the Qt desktop client)
    to eliminate the unnecessary encode/decode round-trip and cut pipeline latency
    roughly in half.
    """
    global _transcoder_bytes_out, _last_audio_chunk_ts
    _last_audio_chunk_ts = time.time()
    _transcoder_bytes_out += len(data)
    with _mp3_lock:
        _preroll_append(data)
        for q in list(_mp3_clients):
            try:
                q.put_nowait(data)
            except queue.Full:
                pass


# Load settings to get MUSIC_FOLDER
def _load_settings():
    try:
        if os.path.exists('settings.json'):
            with open('settings.json', 'r', encoding='utf-8') as f:
                return json.load(f)
    except:
        pass
    return {}

SETTINGS = _load_settings()
_config_music = (CONFIG.get('music_folder') or '').strip()
MUSIC_FOLDER = _config_music or SETTINGS.get('library', {}).get('music_folder', 'music')

# Ensure music folder exists
if not os.path.exists(MUSIC_FOLDER):
    try:
        os.makedirs(MUSIC_FOLDER)
    except:
        # Fallback to default if custom path fails
        MUSIC_FOLDER = "music"
        if not os.path.exists(MUSIC_FOLDER):
            os.makedirs(MUSIC_FOLDER)

# Helper for shared routes
def setup_shared_routes(app, index_file='index.html'):
    @app.route('/library.json')
    def get_library():
        library = []
        global MUSIC_FOLDER
        if os.path.exists(MUSIC_FOLDER):
            for root, dirs, files in os.walk(MUSIC_FOLDER):
                for filename in sorted(files):
                    if filename.lower().endswith(('.mp3', '.m4a', '.wav', '.flac', '.ogg')):
                        rel_path = os.path.relpath(os.path.join(root, filename), MUSIC_FOLDER)
                        library.append({
                            "title": os.path.splitext(filename)[0],
                            "file": f"music_proxy/{rel_path}",
                            # Absolute path exposed for Tauri's asset protocol (convertFileSrc).
                            # The web fallback keeps using the music_proxy route above.
                            "absolutePath": os.path.abspath(os.path.join(root, filename))
                        })
                break  # Top-level only
        return jsonify(library)

    @app.route('/music_proxy/<path:filename>')
    def music_proxy(filename):
        return send_from_directory(MUSIC_FOLDER, filename)

    @app.route('/browse_directories', methods=['GET'])
    def browse_directories():
        path = request.args.get('path', os.path.expanduser('~'))
        try:
            entries = []
            if os.path.exists(path) and os.path.isdir(path):
                # Add parent
                parent = os.path.dirname(os.path.abspath(path))
                entries.append({"name": "..", "path": parent, "isDir": True})
                
                for item in sorted(os.listdir(path)):
                    full_path = os.path.join(path, item)
                    if os.path.isdir(full_path) and not item.startswith('.'):
                        entries.append({
                            "name": item,
                            "path": full_path,
                            "isDir": True
                        })
            return jsonify({"success": True, "path": os.path.abspath(path), "entries": entries})
        except Exception as e:
            return jsonify({"success": False, "error": str(e)}), 500

    @app.route('/update_settings', methods=['POST'])
    def update_settings():
        try:
            data = request.get_json()
            # Load existing
            settings = _load_settings()
            
            # Update selectively
            if 'library' not in settings: settings['library'] = {}
            if 'music_folder' in data.get('library', {}):
                new_folder = data['library']['music_folder']
                if os.path.exists(new_folder) and os.path.isdir(new_folder):
                    settings['library']['music_folder'] = new_folder
                    global MUSIC_FOLDER
                    MUSIC_FOLDER = new_folder
                else:
                    return jsonify({"success": False, "error": "Invalid folder path"}), 400
            
            with open('settings.json', 'w', encoding='utf-8') as f:
                json.dump(settings, f, indent=4)
            
            return jsonify({"success": True})
        except Exception as e:
            return jsonify({"success": False, "error": str(e)}), 500


    @app.route('/<path:filename>')
    def serve_static(filename):
        # Prevent path traversal
        if '..' in filename or filename.startswith('/'):
            abort(403)
        # Allow only known safe static file extensions
        allowed_extensions = ('.css', '.js', '.html', '.htm', '.png', '.jpg', '.jpeg',
                              '.gif', '.svg', '.ico', '.woff', '.woff2', '.ttf', '.eot', '.map')
        if not filename.endswith(allowed_extensions):
            abort(403)
        response = send_from_directory('.', filename)
        if filename.endswith(('.css', '.js', '.html')):
            response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, max-age=0'
        return response

    @app.route('/')
    def index():
        response = send_from_directory('.', index_file)
        response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, max-age=0'
        response.headers['Pragma'] = 'no-cache'
        response.headers['Expires'] = '0'
        return response
    
    @app.route('/upload', methods=['POST'])
    def upload_file():
        if 'file' not in request.files:
            return jsonify({"success": False, "error": "No file provided"}), 400
        
        file = request.files['file']
        
        if file.filename == '':
            return jsonify({"success": False, "error": "No file selected"}), 400
        
        allowed_exts = ('.mp3', '.m4a', '.wav', '.flac', '.ogg')
        ext = os.path.splitext(file.filename)[1].lower()
        if ext not in allowed_exts:
            return jsonify({"success": False, "error": f"Supported formats: {', '.join(allowed_exts)}"}), 400
        
        # Sanitize filename (keep extension)
        name_without_ext = os.path.splitext(file.filename)[0]
        name_without_ext = re.sub(r'[^\w\s-]', '', name_without_ext)
        name_without_ext = re.sub(r'\s+', ' ', name_without_ext).strip()
        filename = f"{name_without_ext}{ext}"
        
        filepath = os.path.join(MUSIC_FOLDER, filename)
        
        if os.path.exists(filepath):
            return jsonify({"success": False, "error": "File already exists in library"}), 409
        
        try:
            file.save(filepath)
            print(f"UPLOADED: {filename}")
            return jsonify({"success": True, "filename": filename})
        except Exception as e:
            print(f"ERROR: Upload error: {e}")
            return jsonify({"success": False, "error": str(e)}), 500

    @app.route('/save_keymaps', methods=['POST'])
    def save_keymaps():
        try:
            data = request.get_json()
            with open('keymaps.json', 'w', encoding='utf-8') as f:
                json.dump(data, f, indent=4)
            print("SAVED: Keymaps saved to keymaps.json")
            return jsonify({"success": True})
        except Exception as e:
            print(f"ERROR: Save keymaps error: {e}")
            return jsonify({"success": False, "error": str(e)}), 500

    @app.route('/load_keymaps', methods=['GET'])
    def load_keymaps():
        try:
            if os.path.exists('keymaps.json'):
                with open('keymaps.json', 'r', encoding='utf-8') as f:
                    data = json.load(f)
                return jsonify({"success": True, "keymaps": data})
            else:
                return jsonify({"success": True, "keymaps": None})
        except Exception as e:
            print(f"ERROR: Load keymaps error: {e}")
            return jsonify({"success": False, "error": str(e)}), 500

    @app.route('/stream.mp3')
    def stream_mp3():
        """Live MP3 audio stream from the ffmpeg transcoder."""
        # If broadcast is not active, return 503 with audio/mpeg content type.
        # Returning JSON here would confuse the browser's <audio> element.
        if not broadcast_state.get('active'):
            return Response(b'', status=503, content_type='audio/mpeg', headers={
                'Retry-After': '5',
                'Access-Control-Allow-Origin': '*',
                'Cache-Control': 'no-cache, no-store',
            })

        # For non-MP3 input the server runs an ffmpeg transcoder; wait for it to start.
        # For MP3 input (e.g. Qt client) chunks are distributed directly — no ffmpeg needed.
        is_mp3_direct = broadcast_state.get('is_mp3_input', False)
        if not is_mp3_direct:
            def _active_transcoder():
                """Return True if either the WebSocket or SRT ffmpeg transcoder is alive."""
                if _ffmpeg_proc is not None and _ffmpeg_proc.poll() is None:
                    return True
                if _srt_ffmpeg_proc is not None and _srt_ffmpeg_proc.poll() is None:
                    return True
                return False

            waited = 0.0
            while not _active_transcoder() and waited < 5.0:
                eventlet.sleep(0.5)
                waited += 0.5

            if not _active_transcoder():
                return Response(b'', status=503, content_type='audio/mpeg', headers={
                    'Retry-After': '3',
                    'Access-Control-Allow-Origin': '*',
                    'Cache-Control': 'no-cache, no-store',
                })

        client_q = queue.Queue(maxsize=500)
        with _mp3_lock:
            preroll_bytes = _mp3_preroll_bytes
            for chunk in _mp3_preroll:
                try:
                    client_q.put_nowait(chunk)
                except Exception:
                    break
            _mp3_clients.add(client_q)
        print(f"LISTENER: New listener joined stream (Pre-roll: {preroll_bytes} bytes)")

        def gen():
            idle_checks = 0
            try:
                while True:
                    try:
                        chunk = client_q.get(timeout=5)
                        idle_checks = 0
                    except queue.Empty:
                        if not broadcast_state.get('active'):
                            break
                        idle_checks += 1
                        if idle_checks >= 12:  # 60s total with no audio data
                            break
                        continue
                    if chunk is None:
                        break
                    yield chunk
            finally:
                with _mp3_lock:
                    _mp3_clients.discard(client_q)
                print("LISTENER: Listener disconnected from stream")

        return Response(stream_with_context(gen()), content_type='audio/mpeg', headers={
            'Cache-Control': 'no-cache, no-store, must-revalidate',
            'Connection': 'keep-alive',
            'Pragma': 'no-cache',
            'Expires': '0',
            'X-Content-Type-Options': 'nosniff',
            'Access-Control-Allow-Origin': '*',
            'Icy-Name': 'TechDJ Live',
            'X-Accel-Buffering': 'no',  # Tell nginx/Cloudflare not to buffer this stream
        })

    @app.route('/stream_debug')
    def stream_debug():
        proc = _ffmpeg_proc
        running = proc is not None and proc.poll() is None
        return jsonify({
            'broadcast_active': broadcast_state.get('active', False),
            'broadcast_mimeType': broadcast_state.get('mimeType'),
            'ffmpeg_running': running,
            'ffmpeg_found': (proc is not None),
            'mp3_clients': len(_mp3_clients),
            'preroll_chunks': len(_mp3_preroll),
            'preroll_bytes': _mp3_preroll_bytes,
            'transcoder_bytes_out': _transcoder_bytes_out,
            'transcoder_last_error': _transcoder_last_error,
            'last_audio_chunk_ts': _last_audio_chunk_ts,
        })

# === DJ SERVER ===
dj_app = Flask(__name__, static_folder='.', static_url_path='')
dj_app.config['SECRET_KEY'] = CONFIG_SECRET
dj_app.config['MAX_CONTENT_LENGTH'] = CONFIG_MAX_UPLOAD_MB * 1024 * 1024
setup_shared_routes(dj_app)


@dj_app.before_request
def _protect_dj_panel():
    """Optionally require a password for the DJ panel only (port 5000).

    This does not affect the listener server (port 5001).
    """
    if not DJ_AUTH_ENABLED:
        return None

    # Allow login/logout endpoints
    if request.path in ('/login', '/logout'):
        return None

    # If already authenticated, allow
    if session.get('dj_authed') is True:
        return None

    # Redirect everything else to login
    return (
        "<!doctype html><html><head><meta http-equiv='refresh' content='0; url=/login' /></head>"
        "<body>Redirecting to <a href='/login'>/login</a>...</body></html>",
        302,
        {'Location': '/login'}
    )


@dj_app.route('/login', methods=['GET', 'POST'])
def dj_login():
    if not DJ_AUTH_ENABLED:
        # If auth is disabled, just go to the panel.
        session['dj_authed'] = True
        return (
            "<!doctype html><html><head><meta http-equiv='refresh' content='0; url=/' /></head>"
            "<body>Auth disabled. Redirecting...</body></html>",
            302,
            {'Location': '/'}
        )

    error = None
    if request.method == 'POST':
        pw = (request.form.get('password') or '').strip()
        if pw == DJ_PANEL_PASSWORD:
            session['dj_authed'] = True
            return (
                "<!doctype html><html><head><meta http-equiv='refresh' content='0; url=/' /></head>"
                "<body>Logged in. Redirecting...</body></html>",
                302,
                {'Location': '/'}
            )
        error = 'Invalid password'

    # Minimal inline login page (no new assets)
    return f"""<!doctype html>
<html lang=\"en\">
    <head>
        <meta charset=\"utf-8\" />
        <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\" />
        <title>TechDJ - DJ Login</title>
        <style>
            body {{ background:#0a0a12; color:#eee; font-family: system-ui, -apple-system, Segoe UI, Roboto, Arial; margin:0; }}
            .wrap {{ min-height:100vh; display:flex; align-items:center; justify-content:center; padding:24px; }}
            .card {{ width:100%; max-width:420px; background:rgba(10,10,20,0.85); border:2px solid #bc13fe; border-radius:16px; padding:24px; box-shadow:0 0 40px rgba(188,19,254,0.25); }}
            h1 {{ margin:0 0 16px 0; font-size:22px; }}
            label {{ display:block; margin:12px 0 8px; opacity:0.9; }}
            input {{ width:100%; padding:12px; border-radius:10px; border:1px solid rgba(255,255,255,0.15); background:rgba(0,0,0,0.35); color:#fff; }}
            button {{ width:100%; margin-top:14px; padding:12px; border-radius:10px; border:2px solid #bc13fe; background:rgba(188,19,254,0.15); color:#fff; font-weight:700; cursor:pointer; }}
            .err {{ margin-top:12px; color:#ffb3ff; }}
            .hint {{ margin-top:10px; font-size:12px; opacity:0.7; }}
        </style>
    </head>
    <body>
        <div class=\"wrap\">
            <div class=\"card\">
                <h1>DJ Panel Locked</h1>
                <form method=\"post\" action=\"/login\">
                    <label for=\"password\">Password</label>
                    <input id=\"password\" name=\"password\" type=\"password\" autocomplete=\"current-password\" autofocus />
                    <button type=\"submit\">Unlock DJ Panel</button>
                    {f"<div class='err'>{error}</div>" if error else ""}
                </form>
            </div>
        </div>
    </body>
</html>"""


@dj_app.route('/logout')
def dj_logout():
    session.pop('dj_authed', None)
    return (
        "<!doctype html><html><head><meta http-equiv='refresh' content='0; url=/login' /></head>"
        "<body>Logged out. Redirecting...</body></html>",
        302,
        {'Location': '/login'}
    )

@dj_app.route('/client_config')
def client_config():
    """Expose server-side config values needed by the DJ panel client."""
    return jsonify({'listener_url': CONFIG_LISTENER_URL})

dj_socketio = SocketIO(
    dj_app, 
    cors_allowed_origins=CONFIG_CORS, 
    async_mode='eventlet',
    max_http_buffer_size=CONFIG_MAX_UPLOAD_MB * 1024 * 1024,
    ping_timeout=60, 
    ping_interval=25,
    logger=CONFIG_DEBUG,
    engineio_logger=CONFIG_DEBUG
)

@dj_socketio.on('connect')
def dj_connect():
    if DJ_AUTH_ENABLED and session.get('dj_authed') is not True:
        print(f"REJECTED: DJ socket rejected (unauthorized): {request.sid}")
        return False
    print(f"STREAMPANEL: DJ connected: {request.sid}")
    dj_sids.add(request.sid)

def _dj_disconnect_grace():
    """Auto-stop broadcast if no DJ reconnects within the grace period."""
    global _dj_grace_greenlet, _mp3_broadcast_announced
    print(f"INFO: Grace period started — {DJ_GRACE_PERIOD_SECS}s for DJ to reconnect")
    eventlet.sleep(DJ_GRACE_PERIOD_SECS)
    if broadcast_state.get('active') and not dj_sids:
        print("WARNING: Grace period expired, no DJ reconnected — auto-stopping broadcast")
        broadcast_state['active'] = False
        broadcast_state['is_mp3_input'] = False
        _mp3_broadcast_announced = False
        _stop_transcoder()
        listener_socketio.emit('broadcast_stopped', namespace='/')
        listener_socketio.emit('stream_status', {'active': False}, namespace='/')
    _dj_grace_greenlet = None


@dj_socketio.on('disconnect')
def dj_disconnect():
    global _dj_grace_greenlet
    dj_sids.discard(request.sid)
    print(f"WARNING: DJ disconnected ({request.sid}). Remaining DJs: {len(dj_sids)}")

    # If broadcast is active and no other DJs remain, start the grace period
    if broadcast_state.get('active') and not dj_sids:
        if _dj_grace_greenlet is None:
            _dj_grace_greenlet = eventlet.spawn(_dj_disconnect_grace)
    elif not broadcast_state.get('active'):
        # Nothing to do — no active broadcast
        pass
    else:
        print("INFO: Other DJ(s) still connected — broadcast continues uninterrupted")

@dj_socketio.on('start_broadcast')
def dj_start(data=None):
    global _dj_grace_greenlet, _mp3_broadcast_announced

    # Cancel any pending auto-stop grace period (DJ reconnected in time)
    if _dj_grace_greenlet is not None:
        _dj_grace_greenlet.kill(block=True)  # block=True prevents a GreenletExit race
        _dj_grace_greenlet = None
        print("INFO: DJ reconnected within grace period — broadcast continues")

    was_already_active = broadcast_state.get('active', False)
    broadcast_state['active'] = True
    session['is_dj'] = True
    print("BROADCAST: ACTIVE")

    is_mp3_input = False
    if data:
        if 'bitrate' in data:
            global _current_bitrate
            _current_bitrate = data['bitrate']
            print(f"BITRATE: Setting stream bitrate to: {_current_bitrate}")
        if data.get('format') == 'mp3':
            is_mp3_input = True
    broadcast_state['is_mp3_input'] = is_mp3_input

    if not was_already_active:
        # Fresh broadcast start — clear pre-roll and reset announcement flag.
        with _mp3_lock:
            _preroll_clear()

        if is_mp3_input:
            # MP3-direct mode (Qt client): the DJ still needs to press play before
            # audio flows.  Firing broadcast_started now would cause listeners to
            # connect to /stream.mp3 before any data exists, wait 60 s, then
            # disconnect.  Instead we hold back the announcement and send it on
            # the very first audio_chunk so listeners connect when data is ready.
            _mp3_broadcast_announced = False
            print("BROADCAST: MP3-direct mode — deferring broadcast_started until first chunk")
        else:
            # Non-MP3 (browser webm/opus): ffmpeg transcoder starts immediately,
            # so listeners can connect right away.
            _start_transcoder_if_needed(is_mp3_input=False)
            listener_socketio.emit('broadcast_started', namespace='/')
    else:
        # DJ reconnected mid-broadcast - just ensure transcoder is alive (non-MP3 only)
        # Do NOT clear pre-roll or trigger listener reload
        print("BROADCAST: DJ reconnected - resuming existing broadcast")
        if not is_mp3_input:
            _start_transcoder_if_needed(is_mp3_input=False)

    # For MP3-direct fresh broadcast, hold back stream_status active=true too
    # so listeners don't auto-connect before audio data is flowing.
    # It will be sent alongside broadcast_started on the first audio_chunk.
    # For non-MP3 (browser) mode or DJ reconnects, send immediately.
    if not (is_mp3_input and not was_already_active):
        listener_socketio.emit('stream_status', {'active': True}, namespace='/')

@dj_socketio.on('get_listener_count')
def dj_get_listener_count():
    emit('listener_count', {'count': len(listener_sids)})

@dj_socketio.on('listener_glow')
def dj_listener_glow(data):
    """DJ sets the glow intensity on the listener page."""
    global _current_glow_intensity
    intensity = int(data.get('intensity', 30)) if isinstance(data, dict) else 30
    intensity = max(0, min(100, intensity))
    _current_glow_intensity = intensity
    listener_socketio.emit('listener_glow', {'intensity': intensity}, namespace='/')

@dj_socketio.on('deck_glow')
def dj_deck_glow(data):
    """Relay which decks are playing so the listener page can mirror the glow colour."""
    if not isinstance(data, dict):
        return
    listener_socketio.emit('deck_glow', {
        'A': bool(data.get('A', False)),
        'B': bool(data.get('B', False)),
    }, namespace='/')

@dj_socketio.on('now_playing')
def dj_now_playing(data):
    """Relay the currently playing track title to all listener pages."""
    if not isinstance(data, dict):
        return
    # Track changed — flush the pre-roll so listeners who reconnect (e.g. after
    # a stall watchdog trigger) start at the current song, not a replay of the
    # previous one.  This is the primary guard against the audio-loop symptom.
    with _mp3_lock:
        _preroll_clear()
    listener_socketio.emit('now_playing', {
        'title': str(data.get('title', '')),
        'deck': str(data.get('deck', '')),
    }, namespace='/')

@dj_socketio.on('stop_broadcast')
def dj_stop():
    global _mp3_broadcast_announced
    broadcast_state['active'] = False
    broadcast_state['is_mp3_input'] = False
    _mp3_broadcast_announced = False
    session['is_dj'] = False
    print("STOPPED: DJ stopped broadcasting")

    _stop_transcoder()
    
    listener_socketio.emit('broadcast_stopped', namespace='/')
    listener_socketio.emit('stream_status', {'active': False}, namespace='/')

@dj_socketio.on('audio_chunk')
def dj_audio(data):
    global _mp3_broadcast_announced
    if broadcast_state['active'] and isinstance(data, (bytes, bytearray)):
        if broadcast_state.get('is_mp3_input', False):
            # MP3 input (e.g. Qt client): skip ffmpeg, send directly to listeners.
            # Fire broadcast_started on the very first chunk so listeners connect
            # only once actual audio data is flowing (the DJ has pressed play).
            if not _mp3_broadcast_announced:
                _mp3_broadcast_announced = True
                print("BROADCAST: First MP3 chunk received — announcing broadcast_started to listeners")
                listener_socketio.emit('broadcast_started', namespace='/')
                listener_socketio.emit('stream_status', {'active': True}, namespace='/')
            _distribute_mp3(bytes(data))
        else:
            # Other formats (e.g. webm/opus from browser): route through ffmpeg transcoder
            if _ffmpeg_proc is None or _ffmpeg_proc.poll() is not None:
                _start_transcoder_if_needed(is_mp3_input=False)
            _feed_transcoder(bytes(data))

# === LISTENER SERVER ===
# static_folder=None prevents Flask's built-in static handler from serving
# DJ files (like index.html) at /<path> — all static files go through our
# custom serve_static route which has security checks.
listener_app = Flask(__name__, static_folder=None, template_folder='.')
listener_app.config['SECRET_KEY'] = CONFIG_SECRET + '_listener'
listener_app.config['MAX_CONTENT_LENGTH'] = CONFIG_MAX_UPLOAD_MB * 1024 * 1024
setup_shared_routes(listener_app, index_file='listener.html')


def _listener_home():
    """Serve listener.html as a Jinja2 template so live context is injected."""
    ctx = _listener_template_context()
    response = make_response(render_template('listener.html', **ctx))
    response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, max-age=0'
    response.headers['Pragma'] = 'no-cache'
    response.headers['Expires'] = '0'
    return response


# Replace the static file serve registered by setup_shared_routes with the
# template-rendering version so Jinja2 context is injected on every page load.
listener_app.view_functions['index'] = _listener_home


# Block write/admin endpoints AND DJ-only files on the listener server
@listener_app.before_request
def _restrict_listener_routes():
    """Prevent listeners from accessing DJ-only endpoints and files."""
    blocked_paths = ('/update_settings', '/upload', '/save_keymaps', '/browse_directories')
    if request.path in blocked_paths:
        abort(403)
    # Block DJ-only files — prevents serving the DJ panel even via direct URL
    dj_only_files = ('/index.html', '/script.js', '/style.css')
    if request.path in dj_only_files:
        abort(403)
listener_socketio = SocketIO(
    listener_app, 
    cors_allowed_origins=CONFIG_CORS, 
    async_mode='eventlet',
    max_http_buffer_size=CONFIG_MAX_UPLOAD_MB * 1024 * 1024,
    # Lower timeouts: stale connections detected in ~25s instead of ~85s
    # ping_interval: how often to probe (seconds)
    # ping_timeout: how long to wait for pong before declaring dead
    ping_timeout=15,
    ping_interval=10,
    logger=CONFIG_DEBUG,
    engineio_logger=CONFIG_DEBUG
)

def _broadcast_listener_count():
    """Compute the most accurate listener count and broadcast to both panels.

    Uses the larger of:
    - listener_sids: Socket.IO connections (people with the page open)
    - _mp3_clients: active /stream.mp3 HTTP connections (people actually hearing audio)

    Taking the max avoids undercounting when someone hasn't clicked Enable Audio
    yet, and also avoids undercounting direct stream URL listeners (e.g. VLC).
    """
    with _mp3_lock:
        stream_count = len(_mp3_clients)
    count = max(len(listener_sids), stream_count)
    listener_socketio.emit('listener_count', {'count': count}, namespace='/')
    dj_socketio.emit('listener_count', {'count': count}, namespace='/')
    return count


@listener_socketio.on('connect')
def listener_connect():
    # Count immediately on connect — don't wait for join_listener
    listener_sids.add(request.sid)
    count = _broadcast_listener_count()
    print(f"LISTENER: Connected {request.sid}. Total: {count}")

@listener_socketio.on('disconnect')
def listener_disconnect():
    listener_sids.discard(request.sid)
    count = _broadcast_listener_count()
    print(f"REMOVED: Listener left {request.sid}. Total: {count}")

@listener_socketio.on('join_listener')
def listener_join():
    # SID already added in listener_connect(); send stream status and current glow
    emit('stream_status', {'active': broadcast_state['active']})
    emit('listener_glow', {'intensity': _current_glow_intensity})

@listener_socketio.on('get_listener_count')
def listener_get_count():
    emit('listener_count', {'count': len(listener_sids)})


# === MediaMTX webhook — SRT publish / unpublish events ===

def _listener_template_context() -> dict:
    return {
        'live': _srt_state['active'],
    }


@listener_app.route('/api/webhook', methods=['POST'])
def mediamtx_webhook():
    """Receive publish/unpublish events from MediaMTX.

    MediaMTX path config example (mediamtx.yml):
        paths:
          live:
            runOnPublish:   'curl -s -X POST http://127.0.0.1:5001/api/webhook -H "Content-Type: application/json" -d \'{"event":"publish","path":"%MTX_PATH%","id":"%MTX_ID%"}\''
            runOnUnpublish: 'curl -s -X POST http://127.0.0.1:5001/api/webhook -H "Content-Type: application/json" -d \'{"event":"unpublish","path":"%MTX_PATH%","id":"%MTX_ID%"}\''

    Or if using MediaMTX >= 1.x webhook integration, point:
        api > hooks > [publish|unpublish] > url: http://127.0.0.1:5001/api/webhook
    """
    global _mp3_broadcast_announced

    # ── Localhost-only: MediaMTX is co-located on the same server ──────────
    if request.remote_addr not in ('127.0.0.1', '::1'):
        abort(403)

    # ── Optional shared-secret authentication ──────────────────────────────
    # Set mediamtx_webhook_secret in config.json and pass the same value in
    # the X-MediaMTX-Webhook-Secret request header (or as ?secret= query arg).
    if _SRT_WEBHOOK_SECRET:
        provided = (
            request.headers.get('X-MediaMTX-Webhook-Secret')
            or request.args.get('secret', '')
        )
        # Constant-time comparison prevents timing side-channels.
        if not hmac.compare_digest(provided, _SRT_WEBHOOK_SECRET):
            abort(403)

    data = request.get_json(silent=True) or {}
    # Support both JSON body fields and legacy query-string parameters.
    event     = (data.get('event')  or request.args.get('event',  '')).lower().strip()
    path      = (data.get('path')   or data.get('MTX_PATH', '')       or request.args.get('path', '')).strip()
    source_id = (data.get('id')     or data.get('sourceID', '')       or '').strip()

    if event == 'publish':
        _srt_state.update({
            'active':     True,
            'path':       path,
            'source_id':  source_id,
            'started_at': time.time(),
        })
        broadcast_state['active']       = True
        broadcast_state['is_mp3_input'] = False
        _mp3_broadcast_announced        = True   # SRT audio starts flowing immediately

        print(f"SRT: Stream PUBLISHED — path='{path}' source='{source_id}'")
        with _mp3_lock:
            _preroll_clear()

        _start_srt_transcoder()
        listener_socketio.emit('broadcast_started', namespace='/')
        listener_socketio.emit('stream_status', {'active': True},                namespace='/')
        dj_socketio.emit(      'stream_status', {'active': True, 'source': 'srt'}, namespace='/')
        return jsonify({'ok': True, 'event': 'publish', 'path': path})

    if event == 'unpublish':
        _srt_state.update({
            'active':     False,
            'path':       None,
            'source_id':  None,
            'started_at': None,
        })
        broadcast_state['active']       = False
        broadcast_state['is_mp3_input'] = False
        _mp3_broadcast_announced        = False

        print(f"SRT: Stream UNPUBLISHED — path='{path}'")
        _stop_srt_transcoder()
        listener_socketio.emit('broadcast_stopped', namespace='/')
        listener_socketio.emit('stream_status', {'active': False},                 namespace='/')
        dj_socketio.emit(      'stream_status', {'active': False, 'source': 'srt'}, namespace='/')
        return jsonify({'ok': True, 'event': 'unpublish', 'path': path})

    return jsonify({'ok': False, 'error': f"Unknown or missing 'event' field: '{event}'"}), 400


@listener_app.route('/api/srt_auth', methods=['POST'])
def srt_auth():
    """MediaMTX externalAuthenticationURL handler.

    MediaMTX calls this endpoint for every new SRT (and RTSP/HLS) connection
    attempt.  Returning HTTP 200 allows the connection; anything else rejects it.

    mediamtx.yml:
        externalAuthenticationURL: http://127.0.0.1:5001/api/srt_auth

    MediaMTX sends JSON like:
        {"ip": "1.2.3.4", "action": "publish", "protocol": "srt",
         "path": "aussie_dj", "user": "", "password": "", "query": "", "id": "..."}
    """
    # Only MediaMTX (localhost) should be calling this
    if request.remote_addr not in ('127.0.0.1', '::1'):
        abort(403)

    data = request.get_json(silent=True) or {}
    action   = (data.get('action')   or '').strip().lower()
    protocol = (data.get('protocol') or '').strip().lower()
    client_ip = (data.get('ip')      or '').strip()

    return '', 200


@listener_app.route('/api/srt_status')
def srt_status():
    """Polling endpoint — returns current SRT / broadcast live state."""
    proc = _srt_ffmpeg_proc
    return jsonify({
        'srt_active':            _srt_state['active'],
        'srt_path':              _srt_state['path'],
        'srt_source_id':         _srt_state['source_id'],
        'srt_started_at':        _srt_state['started_at'],
        'broadcast_active':      broadcast_state.get('active', False),
        'srt_transcoder_running': proc is not None and proc.poll() is None,
    })


# DJ Panel Routes (No engine commands needed in local mode)
def _transcoder_watchdog():
    """Periodic check to ensure the ffmpeg transcoder stays alive.
    Only applies to non-MP3 input; MP3 input (Qt client) is distributed directly.
    """
    while True:
        is_mp3_direct = broadcast_state.get('is_mp3_input', False)
        if broadcast_state.get('active') and not is_mp3_direct:
            # Browser WebM/opus path — watchdog for the push-based transcoder
            if _srt_state['active']:
                # SRT path — watchdog for the pull-based SRT transcoder
                if _srt_ffmpeg_proc is None or _srt_ffmpeg_proc.poll() is not None:
                    print('WARNING: Watchdog: SRT transcoder dead during active stream, reviving...')
                    _start_srt_transcoder()
            else:
                if _ffmpeg_proc is None or _ffmpeg_proc.poll() is not None:
                    print('WARNING: Watchdog: Transcoder dead during active broadcast, reviving...')
                    _start_transcoder_if_needed(is_mp3_input=False)
        eventlet.sleep(5)


def _listener_count_sync_loop():
    """Periodic reconciliation — catches any edge cases where connect/disconnect
    events were missed (e.g. server under load, eventlet greenlet delays)."""
    while True:
        eventlet.sleep(5)
        _broadcast_listener_count()


_background_tasks_started = False
_background_tasks_lock = threading.Lock()

def _start_background_tasks():
    """Start the listener server and background greenlets.

    Safe to call multiple times — only the first call has any effect.
    Called from __main__ (direct run) and from gunicorn's post_worker_init
    hook (production run via gunicorn.conf.py).
    """
    global _background_tasks_started
    with _background_tasks_lock:
        if _background_tasks_started:
            return
        _background_tasks_started = True

    eventlet.spawn(_listener_count_sync_loop)
    eventlet.spawn(_transcoder_watchdog)
    eventlet.spawn(
        listener_socketio.run,
        listener_app,
        host=CONFIG_HOST,
        port=CONFIG_LISTENER_PORT,
        debug=False,
    )


if __name__ == '__main__':
    print("=" * 50)
    print("TECHDJ PRO - DUAL PORT ARCHITECTURE")
    print("=" * 50)
    print(f"HOST:  {CONFIG_HOST}")
    print(f"URL:   DJ PANEL  -> http://{CONFIG_HOST}:{CONFIG_DJ_PORT}")
    print(f"URL:   LISTENER  -> http://{CONFIG_HOST}:{CONFIG_LISTENER_PORT}")
    if DJ_AUTH_ENABLED:
        print("AUTH:  DJ panel password ENABLED")
    else:
        print("AUTH:  DJ panel password DISABLED")
    print(f"DEBUG: {CONFIG_DEBUG}")
    print("=" * 50)
    print(f"READY: Server ready on {CONFIG_HOST}:{CONFIG_DJ_PORT} & {CONFIG_HOST}:{CONFIG_LISTENER_PORT}")

    _start_background_tasks()
    dj_socketio.run(dj_app, host=CONFIG_HOST, port=CONFIG_DJ_PORT, debug=False)