furumi-ng/furumi-agent/src/web/api.rs

use std::sync::Arc;

use axum::{
    extract::{Path, Query, State},
    http::StatusCode,
    response::{IntoResponse, Json},
};
use serde::Deserialize;
use uuid::Uuid;

use crate::db;
use super::AppState;

type S = Arc<AppState>;

// --- Stats ---

pub async fn stats(State(state): State<S>) -> impl IntoResponse {
    match db::get_stats(&state.pool).await {
        Ok(stats) => (StatusCode::OK, Json(serde_json::to_value(stats).unwrap())).into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

// --- Queue ---

#[derive(Deserialize)]
pub struct QueueQuery {
    #[serde(default)]
    pub status: Option<String>,
    #[serde(default = "default_limit")]
    pub limit: i64,
    #[serde(default)]
    pub offset: i64,
}

fn default_limit() -> i64 {
    50
}

pub async fn list_queue(State(state): State<S>, Query(q): Query<QueueQuery>) -> impl IntoResponse {
    match db::list_pending(&state.pool, q.status.as_deref(), q.limit, q.offset).await {
        Ok(items) => (StatusCode::OK, Json(serde_json::to_value(items).unwrap())).into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn get_queue_item(State(state): State<S>, Path(id): Path<Uuid>) -> impl IntoResponse {
    match db::get_pending(&state.pool, id).await {
        Ok(Some(item)) => (StatusCode::OK, Json(serde_json::to_value(item).unwrap())).into_response(),
        Ok(None) => error_response(StatusCode::NOT_FOUND, "not found"),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn delete_queue_item(State(state): State<S>, Path(id): Path<Uuid>) -> impl IntoResponse {
    match db::delete_pending(&state.pool, id).await {
        Ok(true) => StatusCode::NO_CONTENT.into_response(),
        Ok(false) => error_response(StatusCode::NOT_FOUND, "not found"),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn approve_queue_item(State(state): State<S>, Path(id): Path<Uuid>) -> impl IntoResponse {
    // Get pending track, move file, finalize in DB
    let pt = match db::get_pending(&state.pool, id).await {
        Ok(Some(pt)) => pt,
        Ok(None) => return error_response(StatusCode::NOT_FOUND, "not found"),
        Err(e) => return error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    };

    let artist = pt.norm_artist.as_deref().unwrap_or("Unknown Artist");
    let album = pt.norm_album.as_deref().unwrap_or("Unknown Album");
    let title = pt.norm_title.as_deref().unwrap_or("Unknown Title");
    let source = std::path::Path::new(&pt.inbox_path);
    let ext = source.extension().and_then(|e| e.to_str()).unwrap_or("flac");
    let track_num = pt.norm_track_number.unwrap_or(0);

    let filename = if track_num > 0 {
        format!("{:02} - {}.{}", track_num, sanitize_filename(title), ext)
    } else {
        format!("{}.{}", sanitize_filename(title), ext)
    };

    let artist_dir = sanitize_filename(artist);
    let album_dir = sanitize_filename(album);
    let dest = state.config.storage_dir.join(&artist_dir).join(&album_dir).join(&filename);

    use crate::ingest::mover::MoveOutcome;
    let (storage_path, was_merged) = if dest.exists() && !source.exists() {
        // File already moved (e.g. auto-approved earlier but DB not finalized)
        (dest.to_string_lossy().to_string(), false)
    } else {
        match crate::ingest::mover::move_to_storage(
            &state.config.storage_dir, artist, album, &filename, source,
        ).await {
            Ok(MoveOutcome::Moved(p)) => (p.to_string_lossy().to_string(), false),
            Ok(MoveOutcome::Merged(p)) => (p.to_string_lossy().to_string(), true),
            Err(e) => return error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
        }
    };

    match db::approve_and_finalize(&state.pool, id, &storage_path).await {
        Ok(track_id) => {
            if was_merged {
                let _ = db::update_pending_status(&state.pool, id, "merged", None).await;
            }
            (StatusCode::OK, Json(serde_json::json!({"track_id": track_id}))).into_response()
        }
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn reject_queue_item(State(state): State<S>, Path(id): Path<Uuid>) -> impl IntoResponse {
    match db::update_pending_status(&state.pool, id, "rejected", None).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

#[derive(Deserialize)]
pub struct UpdateQueueItem {
    pub norm_title: Option<String>,
    pub norm_artist: Option<String>,
    pub norm_album: Option<String>,
    pub norm_year: Option<i32>,
    pub norm_track_number: Option<i32>,
    pub norm_genre: Option<String>,
    #[serde(default)]
    pub featured_artists: Vec<String>,
}

pub async fn update_queue_item(
    State(state): State<S>,
    Path(id): Path<Uuid>,
    Json(body): Json<UpdateQueueItem>,
) -> impl IntoResponse {
    let norm = db::NormalizedFields {
        title: body.norm_title,
        artist: body.norm_artist,
        album: body.norm_album,
        year: body.norm_year,
        track_number: body.norm_track_number,
        genre: body.norm_genre,
        featured_artists: body.featured_artists,
        release_type: None,
        confidence: Some(1.0), // manual edit = full confidence
        notes: Some("Manually edited".to_owned()),
    };

    match db::update_pending_normalized(&state.pool, id, "review", &norm, None).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

// --- Retry ---

pub async fn retry_queue_item(State(state): State<S>, Path(id): Path<Uuid>) -> impl IntoResponse {
    match db::update_pending_status(&state.pool, id, "pending", None).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

// --- Batch operations ---

#[derive(Deserialize)]
pub struct BatchIds {
    pub ids: Vec<Uuid>,
}

pub async fn batch_approve(State(state): State<S>, Json(body): Json<BatchIds>) -> impl IntoResponse {
    let mut ok = 0u32;
    let mut errors = Vec::new();
    for id in &body.ids {
        let pt = match db::get_pending(&state.pool, *id).await {
            Ok(Some(pt)) => pt,
            Ok(None) => { errors.push(format!("{}: not found", id)); continue; }
            Err(e) => { errors.push(format!("{}: {}", id, e)); continue; }
        };

        let artist = pt.norm_artist.as_deref().unwrap_or("Unknown Artist");
        let album = pt.norm_album.as_deref().unwrap_or("Unknown Album");
        let title = pt.norm_title.as_deref().unwrap_or("Unknown Title");
        let source = std::path::Path::new(&pt.inbox_path);
        let ext = source.extension().and_then(|e| e.to_str()).unwrap_or("flac");
        let track_num = pt.norm_track_number.unwrap_or(0);

        let filename = if track_num > 0 {
            format!("{:02} - {}.{}", track_num, sanitize_filename(title), ext)
        } else {
            format!("{}.{}", sanitize_filename(title), ext)
        };

        let artist_dir = sanitize_filename(artist);
        let album_dir = sanitize_filename(album);
        let dest = state.config.storage_dir.join(&artist_dir).join(&album_dir).join(&filename);

        use crate::ingest::mover::MoveOutcome;
        let (rel_path, was_merged) = if dest.exists() && !source.exists() {
            (dest.to_string_lossy().to_string(), false)
        } else {
            match crate::ingest::mover::move_to_storage(
                &state.config.storage_dir, artist, album, &filename, source,
            ).await {
                Ok(MoveOutcome::Moved(p)) => (p.to_string_lossy().to_string(), false),
                Ok(MoveOutcome::Merged(p)) => (p.to_string_lossy().to_string(), true),
                Err(e) => { errors.push(format!("{}: {}", id, e)); continue; }
            }
        };

        match db::approve_and_finalize(&state.pool, *id, &rel_path).await {
            Ok(_) => {
                if was_merged {
                    let _ = db::update_pending_status(&state.pool, *id, "merged", None).await;
                }
                ok += 1;
            }
            Err(e) => errors.push(format!("{}: {}", id, e)),
        }
    }
    (StatusCode::OK, Json(serde_json::json!({"approved": ok, "errors": errors}))).into_response()
}

pub async fn batch_reject(State(state): State<S>, Json(body): Json<BatchIds>) -> impl IntoResponse {
    let mut ok = 0u32;
    for id in &body.ids {
        if db::update_pending_status(&state.pool, *id, "rejected", None).await.is_ok() {
            ok += 1;
        }
    }
    (StatusCode::OK, Json(serde_json::json!({"rejected": ok}))).into_response()
}

pub async fn batch_retry(State(state): State<S>, Json(body): Json<BatchIds>) -> impl IntoResponse {
    let mut ok = 0u32;
    for id in &body.ids {
        if db::update_pending_status(&state.pool, *id, "pending", None).await.is_ok() {
            ok += 1;
        }
    }
    (StatusCode::OK, Json(serde_json::json!({"retried": ok}))).into_response()
}

pub async fn batch_delete(State(state): State<S>, Json(body): Json<BatchIds>) -> impl IntoResponse {
    let mut ok = 0u32;
    for id in &body.ids {
        if db::delete_pending(&state.pool, *id).await.unwrap_or(false) {
            ok += 1;
        }
    }
    (StatusCode::OK, Json(serde_json::json!({"deleted": ok}))).into_response()
}

// --- Artists ---

#[derive(Deserialize)]
pub struct SearchArtistsQuery {
    pub q: String,
    #[serde(default = "default_search_limit")]
    pub limit: i32,
}

fn default_search_limit() -> i32 {
    10
}

pub async fn search_artists(State(state): State<S>, Query(q): Query<SearchArtistsQuery>) -> impl IntoResponse {
    if q.q.is_empty() {
        return (StatusCode::OK, Json(serde_json::json!([]))).into_response();
    }
    match db::find_similar_artists(&state.pool, &q.q, q.limit).await {
        Ok(artists) => (StatusCode::OK, Json(serde_json::to_value(artists).unwrap())).into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn list_artists(State(state): State<S>) -> impl IntoResponse {
    match db::list_artists_all(&state.pool).await {
        Ok(artists) => (StatusCode::OK, Json(serde_json::to_value(artists).unwrap())).into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

#[derive(Deserialize)]
pub struct UpdateArtistBody {
    pub name: String,
}

pub async fn update_artist(
    State(state): State<S>,
    Path(id): Path<i64>,
    Json(body): Json<UpdateArtistBody>,
) -> impl IntoResponse {
    match db::update_artist_name(&state.pool, id, &body.name).await {
        Ok(true) => StatusCode::NO_CONTENT.into_response(),
        Ok(false) => error_response(StatusCode::NOT_FOUND, "not found"),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

// --- Albums ---

pub async fn list_albums(State(state): State<S>, Path(artist_id): Path<i64>) -> impl IntoResponse {
    match db::list_albums_by_artist(&state.pool, artist_id).await {
        Ok(albums) => (StatusCode::OK, Json(serde_json::to_value(albums).unwrap())).into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

#[derive(Deserialize)]
pub struct UpdateAlbumBody {
    pub name: String,
    pub year: Option<i32>,
}

pub async fn update_album(
    State(state): State<S>,
    Path(id): Path<i64>,
    Json(body): Json<UpdateAlbumBody>,
) -> impl IntoResponse {
    match db::update_album(&state.pool, id, &body.name, body.year).await {
        Ok(true) => StatusCode::NO_CONTENT.into_response(),
        Ok(false) => error_response(StatusCode::NOT_FOUND, "not found"),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

// --- Merges ---

#[derive(Deserialize)]
pub struct CreateMergeBody {
    pub artist_ids: Vec<i64>,
}

pub async fn create_merge(State(state): State<S>, Json(body): Json<CreateMergeBody>) -> impl IntoResponse {
    if body.artist_ids.len() < 2 {
        return error_response(StatusCode::BAD_REQUEST, "need at least 2 artists to merge");
    }
    match db::insert_artist_merge(&state.pool, &body.artist_ids).await {
        Ok(id) => (StatusCode::OK, Json(serde_json::json!({"id": id}))).into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn list_merges(State(state): State<S>) -> impl IntoResponse {
    match db::list_artist_merges(&state.pool).await {
        Ok(items) => (StatusCode::OK, Json(serde_json::to_value(items).unwrap())).into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn get_merge(State(state): State<S>, Path(id): Path<Uuid>) -> impl IntoResponse {
    let merge = match db::get_artist_merge(&state.pool, id).await {
        Ok(Some(m)) => m,
        Ok(None) => return error_response(StatusCode::NOT_FOUND, "not found"),
        Err(e) => return error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    };

    let source_ids: Vec<i64> = serde_json::from_str(&merge.source_artist_ids).unwrap_or_default();
    let artists = match db::get_artists_full_data(&state.pool, &source_ids).await {
        Ok(a) => a,
        Err(e) => return error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    };

    let proposal: Option<serde_json::Value> = merge.proposal.as_deref()
        .and_then(|p| serde_json::from_str(p).ok());

    (StatusCode::OK, Json(serde_json::json!({
        "merge": {
            "id": merge.id,
            "status": merge.status,
            "source_artist_ids": source_ids,
            "llm_notes": merge.llm_notes,
            "error_message": merge.error_message,
            "created_at": merge.created_at,
            "updated_at": merge.updated_at,
        },
        "artists": artists,
        "proposal": proposal,
    }))).into_response()
}

#[derive(Deserialize)]
pub struct UpdateMergeBody {
    pub proposal: serde_json::Value,
}

pub async fn update_merge(
    State(state): State<S>,
    Path(id): Path<Uuid>,
    Json(body): Json<UpdateMergeBody>,
) -> impl IntoResponse {
    let notes = body.proposal.get("notes")
        .and_then(|v| v.as_str())
        .unwrap_or("")
        .to_owned();
    let proposal_json = match serde_json::to_string(&body.proposal) {
        Ok(s) => s,
        Err(e) => return error_response(StatusCode::BAD_REQUEST, &e.to_string()),
    };
    match db::update_merge_proposal(&state.pool, id, &proposal_json, &notes).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn approve_merge(State(state): State<S>, Path(id): Path<Uuid>) -> impl IntoResponse {
    match crate::merge::execute_merge(&state, id).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => {
            let msg = e.to_string();
            let _ = db::update_merge_status(&state.pool, id, "error", Some(&msg)).await;
            error_response(StatusCode::INTERNAL_SERVER_ERROR, &msg)
        }
    }
}

pub async fn reject_merge(State(state): State<S>, Path(id): Path<Uuid>) -> impl IntoResponse {
    match db::update_merge_status(&state.pool, id, "rejected", None).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn retry_merge(State(state): State<S>, Path(id): Path<Uuid>) -> impl IntoResponse {
    match db::update_merge_status(&state.pool, id, "pending", None).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

// --- Library search ---

#[derive(Deserialize)]
pub struct LibraryQuery {
    #[serde(default)]
    pub q: String,
    #[serde(default)]
    pub artist: String,
    #[serde(default)]
    pub album: String,
    #[serde(default = "default_lib_limit")]
    pub limit: i64,
    #[serde(default)]
    pub offset: i64,
}
fn default_lib_limit() -> i64 { 50 }

pub async fn library_tracks(State(state): State<S>, Query(q): Query<LibraryQuery>) -> impl IntoResponse {
    let (tracks, total) = tokio::join!(
        db::search_tracks(&state.pool, &q.q, &q.artist, &q.album, q.limit, q.offset),
        db::count_tracks(&state.pool, &q.q, &q.artist, &q.album),
    );
    match (tracks, total) {
        (Ok(rows), Ok(n)) => (StatusCode::OK, Json(serde_json::json!({"total": n, "items": rows}))).into_response(),
        (Err(e), _) | (_, Err(e)) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn library_albums(State(state): State<S>, Query(q): Query<LibraryQuery>) -> impl IntoResponse {
    let (albums, total) = tokio::join!(
        db::search_albums(&state.pool, &q.q, &q.artist, q.limit, q.offset),
        db::count_albums(&state.pool, &q.q, &q.artist),
    );
    match (albums, total) {
        (Ok(rows), Ok(n)) => (StatusCode::OK, Json(serde_json::json!({"total": n, "items": rows}))).into_response(),
        (Err(e), _) | (_, Err(e)) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn library_artists(State(state): State<S>, Query(q): Query<LibraryQuery>) -> impl IntoResponse {
    let (artists, total) = tokio::join!(
        db::search_artists_lib(&state.pool, &q.q, q.limit, q.offset),
        db::count_artists_lib(&state.pool, &q.q),
    );
    match (artists, total) {
        (Ok(rows), Ok(n)) => (StatusCode::OK, Json(serde_json::json!({"total": n, "items": rows}))).into_response(),
        (Err(e), _) | (_, Err(e)) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

// --- Track / Album detail & edit ---

pub async fn get_track(State(state): State<S>, Path(id): Path<i64>) -> impl IntoResponse {
    match db::get_track_full(&state.pool, id).await {
        Ok(Some(t)) => (StatusCode::OK, Json(serde_json::to_value(t).unwrap())).into_response(),
        Ok(None) => error_response(StatusCode::NOT_FOUND, "not found"),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn update_track(
    State(state): State<S>,
    Path(id): Path<i64>,
    Json(body): Json<db::TrackUpdateFields>,
) -> impl IntoResponse {
    match db::update_track_metadata(&state.pool, id, &body).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn get_album_full(State(state): State<S>, Path(id): Path<i64>) -> impl IntoResponse {
    match db::get_album_details(&state.pool, id).await {
        Ok(Some(a)) => (StatusCode::OK, Json(serde_json::to_value(a).unwrap())).into_response(),
        Ok(None) => error_response(StatusCode::NOT_FOUND, "not found"),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

#[derive(Deserialize)]
pub struct AlbumUpdateBody {
    pub name: String,
    pub year: Option<i32>,
    pub artist_id: i64,
}

pub async fn update_album_full(
    State(state): State<S>,
    Path(id): Path<i64>,
    Json(body): Json<AlbumUpdateBody>,
) -> impl IntoResponse {
    match db::update_album_full(&state.pool, id, &body.name, body.year, body.artist_id).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

#[derive(Deserialize)]
pub struct SetGenreBody { pub genre: String }

pub async fn set_album_tracks_genre(
    State(state): State<S>,
    Path(id): Path<i64>,
    Json(body): Json<SetGenreBody>,
) -> impl IntoResponse {
    match db::set_album_tracks_genre(&state.pool, id, &body.genre).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

#[derive(Deserialize)]
pub struct ReorderBody {
    pub orders: Vec<(i64, i32)>,
}

pub async fn reorder_album_tracks(
    State(state): State<S>,
    Path(_id): Path<i64>,
    Json(body): Json<ReorderBody>,
) -> impl IntoResponse {
    match db::reorder_tracks(&state.pool, &body.orders).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

/// Cover by artist+album name — used for queue items that may not have an album_id yet.
#[derive(Deserialize)]
pub struct CoverByNameQuery {
    #[serde(default)] pub artist: String,
    #[serde(default)] pub name: String,
}
pub async fn album_cover_by_name(State(state): State<S>, Query(q): Query<CoverByNameQuery>) -> impl IntoResponse {
    let album_id = match db::find_album_id(&state.pool, &q.artist, &q.name).await {
        Ok(Some(id)) => id,
        _ => return StatusCode::NOT_FOUND.into_response(),
    };
    album_cover_by_id(&state, album_id).await
}

pub async fn album_cover(State(state): State<S>, Path(id): Path<i64>) -> impl IntoResponse {
    album_cover_by_id(&state, id).await
}

async fn album_cover_by_id(state: &super::AppState, id: i64) -> axum::response::Response {
    // 1. Try album_images table
    if let Ok(Some((file_path, mime_type))) = db::get_album_cover(&state.pool, id).await {
        if let Ok(bytes) = tokio::fs::read(&file_path).await {
            return ([(axum::http::header::CONTENT_TYPE, mime_type)], bytes).into_response();
        }
    }

    // 2. Fallback: extract embedded cover from first track in album
    if let Ok(Some(track_path)) = db::get_album_first_track_path(&state.pool, id).await {
        let path = std::path::PathBuf::from(track_path);
        if path.exists() {
            let result = tokio::task::spawn_blocking(move || extract_embedded_cover(&path)).await;
            if let Ok(Some((bytes, mime))) = result {
                return ([(axum::http::header::CONTENT_TYPE, mime)], bytes).into_response();
            }
        }
    }

    StatusCode::NOT_FOUND.into_response()
}

fn extract_embedded_cover(path: &std::path::Path) -> Option<(Vec<u8>, String)> {
    use symphonia::core::{
        formats::FormatOptions,
        io::MediaSourceStream,
        meta::MetadataOptions,
        probe::Hint,
    };

    let file = std::fs::File::open(path).ok()?;
    let mss = MediaSourceStream::new(Box::new(file), Default::default());

    let mut hint = Hint::new();
    if let Some(ext) = path.extension().and_then(|e| e.to_str()) {
        hint.with_extension(ext);
    }

    let mut probed = symphonia::default::get_probe()
        .format(
            &hint,
            mss,
            &FormatOptions { enable_gapless: false, ..Default::default() },
            &MetadataOptions::default(),
        )
        .ok()?;

    if let Some(rev) = probed.metadata.get().as_ref().and_then(|m| m.current()) {
        if let Some(v) = rev.visuals().first() {
            return Some((v.data.to_vec(), v.media_type.clone()));
        }
    }
    if let Some(rev) = probed.format.metadata().current() {
        if let Some(v) = rev.visuals().first() {
            return Some((v.data.to_vec(), v.media_type.clone()));
        }
    }
    None
}

#[derive(Deserialize)]
pub struct AlbumSearchQuery {
    #[serde(default)]
    pub q: String,
    pub artist_id: Option<i64>,
}

pub async fn search_albums_for_artist(State(state): State<S>, Query(q): Query<AlbumSearchQuery>) -> impl IntoResponse {
    match db::search_albums_for_artist(&state.pool, &q.q, q.artist_id).await {
        Ok(items) => (StatusCode::OK, Json(serde_json::to_value(
            items.iter().map(|(id, name)| serde_json::json!({"id": id, "name": name})).collect::<Vec<_>>()
        ).unwrap())).into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

// --- Artist full admin form ---

pub async fn get_artist_full(State(state): State<S>, Path(id): Path<i64>) -> impl IntoResponse {
    let artist = match db::get_artist_by_id(&state.pool, id).await {
        Ok(Some(a)) => a,
        Ok(None) => return error_response(StatusCode::NOT_FOUND, "not found"),
        Err(e) => return error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    };
    let (albums, appearances) = tokio::join!(
        db::get_artist_albums(&state.pool, id),
        db::get_artist_appearances(&state.pool, id),
    );
    // For each album, load tracks
    let albums = match albums {
        Ok(a) => a,
        Err(e) => return error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    };
    let mut albums_with_tracks = Vec::new();
    for album in albums {
        let tracks = db::get_album_tracks_admin(&state.pool, album.id).await.unwrap_or_default();
        albums_with_tracks.push(serde_json::json!({
            "id": album.id, "name": album.name, "year": album.year,
            "release_type": album.release_type, "hidden": album.hidden,
            "track_count": album.track_count, "tracks": tracks,
        }));
    }
    (StatusCode::OK, Json(serde_json::json!({
        "artist": artist,
        "albums": albums_with_tracks,
        "appearances": appearances.unwrap_or_default(),
    }))).into_response()
}

#[derive(Deserialize)]
pub struct SetHiddenBody { pub hidden: bool }

pub async fn set_track_hidden(State(state): State<S>, Path(id): Path<i64>, Json(b): Json<SetHiddenBody>) -> impl IntoResponse {
    match db::set_track_hidden(&state.pool, id, b.hidden).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn set_album_hidden(State(state): State<S>, Path(id): Path<i64>, Json(b): Json<SetHiddenBody>) -> impl IntoResponse {
    match db::set_album_hidden(&state.pool, id, b.hidden).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn set_artist_hidden(State(state): State<S>, Path(id): Path<i64>, Json(b): Json<SetHiddenBody>) -> impl IntoResponse {
    match db::set_artist_hidden(&state.pool, id, b.hidden).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

#[derive(Deserialize)]
pub struct SetReleaseTypeBody { pub release_type: String }

pub async fn set_album_release_type(State(state): State<S>, Path(id): Path<i64>, Json(b): Json<SetReleaseTypeBody>) -> impl IntoResponse {
    let valid = ["album","single","ep","compilation","live"];
    if !valid.contains(&b.release_type.as_str()) {
        return error_response(StatusCode::BAD_REQUEST, "invalid release_type");
    }
    match db::set_album_release_type(&state.pool, id, &b.release_type).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

#[derive(Deserialize)]
pub struct RenameArtistBody { pub name: String }

pub async fn rename_artist_api(State(state): State<S>, Path(id): Path<i64>, Json(b): Json<RenameArtistBody>) -> impl IntoResponse {
    match db::rename_artist_name(&state.pool, id, &b.name).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

#[derive(Deserialize)]
pub struct AddAppearanceBody { pub track_id: i64 }

pub async fn add_appearance(State(state): State<S>, Path(artist_id): Path<i64>, Json(b): Json<AddAppearanceBody>) -> impl IntoResponse {
    match db::add_track_appearance(&state.pool, b.track_id, artist_id).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

pub async fn remove_appearance(State(state): State<S>, Path((artist_id, track_id)): Path<(i64, i64)>) -> impl IntoResponse {
    match db::remove_track_appearance(&state.pool, track_id, artist_id).await {
        Ok(()) => StatusCode::NO_CONTENT.into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

#[derive(Deserialize)]
pub struct SearchTracksQuery { #[serde(default)] pub q: String }

pub async fn search_tracks_feat(State(state): State<S>, Query(q): Query<SearchTracksQuery>) -> impl IntoResponse {
    match db::search_tracks_for_feat(&state.pool, &q.q).await {
        Ok(rows) => (StatusCode::OK, Json(serde_json::to_value(
            rows.iter().map(|(id, title, artist)| serde_json::json!({"id": id, "title": title, "artist_name": artist})).collect::<Vec<_>>()
        ).unwrap())).into_response(),
        Err(e) => error_response(StatusCode::INTERNAL_SERVER_ERROR, &e.to_string()),
    }
}

// --- Helpers ---

fn error_response(status: StatusCode, message: &str) -> axum::response::Response {
    (status, Json(serde_json::json!({"error": message}))).into_response()
}

fn sanitize_filename(name: &str) -> String {
    name.chars()
        .map(|c| match c {
            '/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|' => '_',
            _ => c,
        })
        .collect::<String>()
        .trim()
        .to_owned()
}