app.py

from flask import Flask, render_template, request, Response, stream_with_context
import os
import signal
import requests
import time
import json
import threading
from dotenv import load_dotenv

load_dotenv()

# ─────────────────────────────────────────────────────────────
# APP SETTINGS
# ─────────────────────────────────────────────────────────────

app = Flask(__name__)
app.secret_key = os.getenv("CODEBARR_SECRET_KEY", "your_secret_key_here")

LIDARR_URL = os.getenv("LIDARR_URL").rstrip("/")
API_KEY = os.getenv("LIDARR_API_KEY")
HEADERS = {"X-Api-Key": API_KEY}

REQUEST_TIMEOUT = 10

USERNAME = os.getenv("CODEBARR_USERNAME")
PASSWORD = os.getenv("CODEBARR_PASSWORD")

LIDARR_DEFAULTS = {
    "rootFolderPath": os.getenv("LIDARR_ROOT_FOLDER_PATH", "/music"),
    "qualityProfileId": int(os.getenv("LIDARR_QUALITY_PROFILE", 2)),
    "metadataProfileId": int(os.getenv("LIDARR_METADATA_PROFILE", 1)),
    "monitorNewItems": os.getenv("LIDARR_MONITOR_NEW_ITEMS", "none"),
    "addOptions": {
        "searchForMissingAlbums": os.getenv("LIDARR_SEARCH_ON_ADD", "False").lower() in {"true","1","yes"}
    }
}

# ─────────────────────────────────────────────────────────────
# AUTH
# ─────────────────────────────────────────────────────────────

def check_auth(username, password):
    return username == USERNAME and password == PASSWORD

def authenticate():
    return Response("Authentication required", 401,
                    {"WWW-Authenticate": 'Basic realm="Codebarr"'})

def requires_auth(f):
    def decorated(*args, **kwargs):
        auth = request.authorization
        if not auth or not check_auth(auth.username, auth.password):
            return authenticate()
        return f(*args, **kwargs)
    decorated.__name__ = f.__name__
    return decorated

# ─────────────────────────────────────────────────────────────
# MUSICBRAINZ
# ─────────────────────────────────────────────────────────────

def get_release_from_barcode(barcode):
    r = requests.get(
        f"https://musicbrainz.org/ws/2/release/?query=barcode:{barcode}&fmt=json",
        timeout=REQUEST_TIMEOUT
    )
    r.raise_for_status()
    data = r.json()

    if not data.get("releases"):
        raise Exception(f"No release found for barcode {barcode}")

    return data["releases"][0]

# ─────────────────────────────────────────────────────────────
# LIDARR HELPERS (SAFE)
# ─────────────────────────────────────────────────────────────

def get_artist_by_mbid(artist_mbid):
    artists = requests.get(
        f"{LIDARR_URL}/api/v1/artist",
        headers=HEADERS,
        timeout=REQUEST_TIMEOUT
    ).json()

    return next(
        (a for a in artists if a.get("foreignArtistId") == artist_mbid),
        None
    )
def wait_for_album_ready(album_id, timeout=60):
    elapsed = 0
    while elapsed < timeout:
        album = requests.get(
            f"{LIDARR_URL}/api/v1/album/{album_id}",
            headers=HEADERS,
            timeout=REQUEST_TIMEOUT
        ).json()

        # Album refresh is done when statistics exist
        if album.get("statistics"):
            return album

        time.sleep(2)
        elapsed += 2

    raise Exception("Album never finished refreshing")


def create_artist(artist_name, artist_mbid):
    payload = {
        "artistName": artist_name,
        "foreignArtistId": artist_mbid,
        "rootFolderPath": LIDARR_DEFAULTS["rootFolderPath"],
        "qualityProfileId": LIDARR_DEFAULTS["qualityProfileId"],
        "metadataProfileId": LIDARR_DEFAULTS["metadataProfileId"],
        "monitored": False,
        "monitorNewItems": LIDARR_DEFAULTS["monitorNewItems"],
        "addOptions": LIDARR_DEFAULTS["addOptions"]
    }

    r = requests.post(
        f"{LIDARR_URL}/api/v1/artist",
        headers=HEADERS,
        json=payload,
        timeout=REQUEST_TIMEOUT
    )
    r.raise_for_status()
    return r.json()["id"]

def wait_for_album(artist_id, release_group_mbid, timeout=60):
    elapsed = 0
    while elapsed < timeout:
        albums = requests.get(
            f"{LIDARR_URL}/api/v1/album?artistId={artist_id}",
            headers=HEADERS,
            timeout=REQUEST_TIMEOUT
        ).json()

        album = next(
            (a for a in albums if a.get("foreignAlbumId") == release_group_mbid),
            None
        )

        if album:
            return album

        time.sleep(2)
        elapsed += 2

    raise Exception("Album never appeared in Lidarr")

def wait_for_release(album_id, release_mbid, timeout=60):
    elapsed = 0
    while elapsed < timeout:
        r = requests.get(
            f"{LIDARR_URL}/api/v1/album/{album_id}",
            headers=HEADERS,
            timeout=REQUEST_TIMEOUT
        )

        if r.status_code == 404:
            time.sleep(2)
            elapsed += 2
            continue

        album = r.json()
        releases = album.get("releases", [])

        release = next(
            (rel for rel in releases if rel.get("foreignReleaseId") == release_mbid),
            None
        )

        if release:
            return album, releases

        time.sleep(2)
        elapsed += 2

    raise Exception("Exact release never appeared")

# ─────────────────────────────────────────────────────────────
# MAIN PROCESS (BULLETPROOF)
# ─────────────────────────────────────────────────────────────

def process_barcode(barcode):
    try:
        yield json.dumps({"status": "🔍 Looking up barcode...", "progress": 5}) + "\n\n"
        release = get_release_from_barcode(barcode)

        release_mbid = release["id"]
        release_group_mbid = release["release-group"]["id"]
        album_title = release["title"]

        artist_credit = release["artist-credit"][0]
        artist_name = artist_credit["name"]
        artist_mbid = artist_credit["artist"]["id"]

        yield json.dumps({"status": f"🎵 Found '{album_title}' by {artist_name}", "progress": 15}) + "\n\n"

        # ───── ARTIST ─────
        yield json.dumps({"status": "👤 Checking artist...", "progress": 30}) + "\n\n"
        artist = get_artist_by_mbid(artist_mbid)
        if not artist:
            artist_id = create_artist(artist_name, artist_mbid)
        else:
            artist_id = artist["id"]

        # ───── ALBUM ─────
        yield json.dumps({"status": "📀 Checking album...", "progress": 50}) + "\n\n"
        try:
            album = wait_for_album(artist_id, release_group_mbid)
            album_id = album["id"]
            yield json.dumps({"status": f"Album '{album_title}' exists", "progress": 55}) + "\n\n"
        except Exception:
            # Album not yet created by Lidarr, create it
            artist_data = requests.get(f"{LIDARR_URL}/api/v1/artist/{artist_id}", headers=HEADERS, timeout=REQUEST_TIMEOUT).json()
            payload = {
                "artistId": artist_id,
                "artist": artist_data,
                "foreignAlbumId": release_group_mbid,
                "title": album_title,
                "monitored": False,
                "addOptions": {"searchForNewAlbum": False}
            }
            r = requests.post(f"{LIDARR_URL}/api/v1/album", headers=HEADERS, json=payload, timeout=REQUEST_TIMEOUT)
            r.raise_for_status()
            album_id = r.json()["id"]
            yield json.dumps({"status": f"Album '{album_title}' created", "progress": 55}) + "\n\n"

        # ───── WAIT FOR ALBUM REFRESH ─────
        yield json.dumps({"status": "⏳ Waiting for album refresh...", "progress": 75}) + "\n\n"
        album_data = wait_for_album_ready(album_id)

        # ───── PIN AND MONITOR EXACT RELEASE ─────
        album_data["monitored"] = True
        album_data["foreignReleaseId"] = release_mbid
        releases = album_data.get("releases", [])
        for r in releases:
            r["monitored"] = (r.get("foreignReleaseId") == release_mbid)
        album_data["releases"] = releases

        requests.put(f"{LIDARR_URL}/api/v1/album/{album_id}", headers=HEADERS, json=album_data, timeout=REQUEST_TIMEOUT).raise_for_status()

        yield json.dumps({"status": f"✅ Monitoring exact release of '{album_title}'", "progress": 100}) + "\n\n"

    except requests.exceptions.RequestException as e:
        yield json.dumps({"status": f"❌ Network/Lidarr error: {e}", "progress": 100}) + "\n\n"

    except Exception as e:
        yield json.dumps({"status": f"❌ Error: {e}", "progress": 100}) + "\n\n"


# ─────────────────────────────────────────────────────────────
# ROUTES
# ─────────────────────────────────────────────────────────────

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

@app.route("/submit", methods=["POST"])
def submit():
    barcode = request.form.get("barcode")
    if not barcode:
        return Response("No barcode", status=400)

    return Response(
        stream_with_context(process_barcode(barcode)),
        mimetype="text/event-stream"
    )

@app.route("/shutdown", methods=["POST"])
def shutdown():
    def delayed():
        time.sleep(1)
        os.kill(os.getpid(), signal.SIGTERM)

    threading.Thread(target=delayed).start()
    return Response("Codebarr is shutting down...", mimetype="text/plain")

# ─────────────────────────────────────────────────────────────

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