//! Local MusicBrainz database fetcher.
//!
//! Implements [`MetadataFetcher`] backed by a local SQLite database (populated
//! via [`crate::mb_import`]). All queries are instant local lookups — no rate
//! limiting needed.

use std::sync::Mutex;

use rusqlite::Connection;

use crate::error::{DataError, DataResult};
use crate::traits::MetadataFetcher;
use crate::types::{
    ArtistInfo, ArtistSearchResult, ArtistUrl, DiscographyEntry, RecordingDetails, RecordingMatch,
    ReleaseGroupEntry, ReleaseMatch, ReleaseRef, ReleaseTrack,
};

/// Statistics about the local MusicBrainz database.
#[derive(Debug, Clone, Default, serde::Serialize)]
pub struct LocalMbStats {
    pub artists: u64,
    pub release_groups: u64,
    pub releases: u64,
    pub recordings: u64,
    pub tracks: u64,
    pub last_import_date: Option<String>,
}

/// A [`MetadataFetcher`] backed by a local SQLite database.
pub struct LocalMusicBrainzFetcher {
    conn: Mutex<Connection>,
}

impl LocalMusicBrainzFetcher {
    /// Open (or create) a local MusicBrainz SQLite database.
    pub fn new(db_path: &str) -> Result<Self, Box<dyn std::error::Error>> {
        let conn = Connection::open(db_path)?;
        conn.execute_batch("PRAGMA journal_mode = WAL; PRAGMA cache_size = -16000;")?;
        Ok(Self {
            conn: Mutex::new(conn),
        })
    }

    /// Check whether the database has been populated with data.
    pub fn is_available(&self) -> bool {
        let conn = self.conn.lock().unwrap();
        // Check if the mb_artists table exists and has at least one row.
        // Use EXISTS (SELECT 1 ...) instead of COUNT(*) to avoid scanning the entire table.
        conn.query_row(
            "SELECT EXISTS(SELECT 1 FROM sqlite_master WHERE type='table' AND name='mb_artists')",
            [],
            |row| row.get::<_, bool>(0),
        )
        .unwrap_or(false)
            && conn
                .query_row(
                    "SELECT EXISTS(SELECT 1 FROM mb_artists LIMIT 1)",
                    [],
                    |row| row.get::<_, bool>(0),
                )
                .unwrap_or(false)
    }

    /// Get statistics about the imported data.
    pub fn stats(&self) -> LocalMbStats {
        let conn = self.conn.lock().unwrap();
        let get_meta = |key: &str| -> Option<String> {
            conn.query_row(
                "SELECT value FROM mb_import_meta WHERE key = ?1",
                rusqlite::params![key],
                |row| row.get(0),
            )
            .ok()
        };

        LocalMbStats {
            artists: get_meta("artist_count")
                .and_then(|s| s.parse().ok())
                .unwrap_or(0),
            release_groups: get_meta("release_group_count")
                .and_then(|s| s.parse().ok())
                .unwrap_or(0),
            releases: get_meta("release_count")
                .and_then(|s| s.parse().ok())
                .unwrap_or(0),
            recordings: get_meta("recording_count")
                .and_then(|s| s.parse().ok())
                .unwrap_or(0),
            tracks: get_meta("track_count")
                .and_then(|s| s.parse().ok())
                .unwrap_or(0),
            last_import_date: get_meta("last_import_date"),
        }
    }

    /// Look up an artist by MBID (returns name and disambiguation).
    pub fn get_artist_by_mbid_sync(&self, mbid: &str) -> DataResult<(String, Option<String>)> {
        let conn = self.conn.lock().unwrap();
        let result = conn.query_row(
            "SELECT name, disambiguation FROM mb_artists WHERE mbid = ?1",
            rusqlite::params![mbid],
            |row| {
                let name: String = row.get(0)?;
                let disambiguation: Option<String> = row.get(1)?;
                Ok((name, disambiguation.filter(|s| !s.is_empty())))
            },
        );
        match result {
            Ok(r) => Ok(r),
            Err(rusqlite::Error::QueryReturnedNoRows) => {
                Err(DataError::Other(format!("artist {mbid} not found locally")))
            }
            Err(e) => Err(DataError::Other(e.to_string())),
        }
    }

    /// Look up detailed artist info by MBID, including URLs.
    pub fn get_artist_info_sync(&self, mbid: &str) -> DataResult<ArtistInfo> {
        let conn = self.conn.lock().unwrap();
        let artist = conn.query_row(
            "SELECT name, disambiguation, country, artist_type, begin_year FROM mb_artists WHERE mbid = ?1",
            rusqlite::params![mbid],
            |row| {
                Ok((
                    row.get::<_, String>(0)?,
                    row.get::<_, Option<String>>(1)?,
                    row.get::<_, Option<String>>(2)?,
                    row.get::<_, Option<String>>(3)?,
                    row.get::<_, Option<i32>>(4)?,
                ))
            },
        );

        let (name, disambiguation, country, artist_type, begin_year) = match artist {
            Ok(a) => a,
            Err(rusqlite::Error::QueryReturnedNoRows) => {
                return Err(DataError::Other(format!("artist {mbid} not found locally")));
            }
            Err(e) => return Err(DataError::Other(e.to_string())),
        };

        // Fetch URLs
        let mut url_stmt = conn
            .prepare("SELECT url, link_type FROM mb_artist_urls WHERE artist_mbid = ?1")
            .map_err(|e| DataError::Other(e.to_string()))?;
        let urls: Vec<ArtistUrl> = url_stmt
            .query_map(rusqlite::params![mbid], |row| {
                Ok(ArtistUrl {
                    url: row.get(0)?,
                    link_type: row.get(1)?,
                })
            })
            .map_err(|e| DataError::Other(e.to_string()))?
            .filter_map(|r| r.ok())
            .collect();

        Ok(ArtistInfo {
            name,
            mbid: Some(mbid.to_string()),
            disambiguation: disambiguation.filter(|s| !s.is_empty()),
            country: country.filter(|s| !s.is_empty()),
            artist_type,
            begin_year: begin_year.map(|y| y.to_string()),
            urls,
        })
    }
}

impl MetadataFetcher for LocalMusicBrainzFetcher {
    async fn search_recording(&self, artist: &str, title: &str) -> DataResult<Vec<RecordingMatch>> {
        let conn = self.conn.lock().unwrap();

        let query = if artist.is_empty() {
            let pattern = format!("%{title}%");
            let mut stmt = conn
                .prepare(
                    "SELECT r.mbid, r.title, r.artist_mbid, a.name
                     FROM mb_recordings r
                     LEFT JOIN mb_artists a ON r.artist_mbid = a.mbid
                     WHERE r.title LIKE ?1 COLLATE NOCASE
                     LIMIT 10",
                )
                .map_err(|e| DataError::Other(e.to_string()))?;
            stmt.query_map(rusqlite::params![pattern], |row| {
                Ok(RecordingMatch {
                    mbid: row.get(0)?,
                    title: row.get(1)?,
                    artist_mbid: row.get(2)?,
                    artist: row
                        .get::<_, Option<String>>(3)?
                        .unwrap_or_else(|| "Unknown Artist".into()),
                    releases: vec![],
                    score: 100,
                })
            })
            .map_err(|e| DataError::Other(e.to_string()))?
            .filter_map(|r| r.ok())
            .collect()
        } else {
            let artist_pattern = format!("%{artist}%");
            let title_pattern = format!("%{title}%");
            let mut stmt = conn
                .prepare(
                    "SELECT r.mbid, r.title, r.artist_mbid, a.name
                     FROM mb_recordings r
                     LEFT JOIN mb_artists a ON r.artist_mbid = a.mbid
                     WHERE r.title LIKE ?1 COLLATE NOCASE
                       AND a.name LIKE ?2 COLLATE NOCASE
                     LIMIT 10",
                )
                .map_err(|e| DataError::Other(e.to_string()))?;
            stmt.query_map(rusqlite::params![title_pattern, artist_pattern], |row| {
                Ok(RecordingMatch {
                    mbid: row.get(0)?,
                    title: row.get(1)?,
                    artist_mbid: row.get(2)?,
                    artist: row
                        .get::<_, Option<String>>(3)?
                        .unwrap_or_else(|| "Unknown Artist".into()),
                    releases: vec![],
                    score: 100,
                })
            })
            .map_err(|e| DataError::Other(e.to_string()))?
            .filter_map(|r| r.ok())
            .collect()
        };

        Ok(query)
    }

    async fn search_release(&self, artist: &str, album: &str) -> DataResult<Vec<ReleaseMatch>> {
        let conn = self.conn.lock().unwrap();

        let results = if artist.is_empty() {
            let pattern = format!("%{album}%");
            let mut stmt = conn
                .prepare(
                    "SELECT r.mbid, r.title, r.artist_mbid, a.name, r.date
                     FROM mb_releases r
                     LEFT JOIN mb_artists a ON r.artist_mbid = a.mbid
                     WHERE r.title LIKE ?1 COLLATE NOCASE
                     LIMIT 10",
                )
                .map_err(|e| DataError::Other(e.to_string()))?;
            stmt.query_map(rusqlite::params![pattern], |row| {
                Ok(ReleaseMatch {
                    mbid: row.get(0)?,
                    title: row.get(1)?,
                    artist_mbid: row.get(2)?,
                    artist: row
                        .get::<_, Option<String>>(3)?
                        .unwrap_or_else(|| "Unknown Artist".into()),
                    date: row.get(4)?,
                    track_count: None,
                    score: 100,
                })
            })
            .map_err(|e| DataError::Other(e.to_string()))?
            .filter_map(|r| r.ok())
            .collect()
        } else {
            let artist_pattern = format!("%{artist}%");
            let album_pattern = format!("%{album}%");
            let mut stmt = conn
                .prepare(
                    "SELECT r.mbid, r.title, r.artist_mbid, a.name, r.date
                     FROM mb_releases r
                     LEFT JOIN mb_artists a ON r.artist_mbid = a.mbid
                     WHERE r.title LIKE ?1 COLLATE NOCASE
                       AND a.name LIKE ?2 COLLATE NOCASE
                     LIMIT 10",
                )
                .map_err(|e| DataError::Other(e.to_string()))?;
            stmt.query_map(rusqlite::params![album_pattern, artist_pattern], |row| {
                Ok(ReleaseMatch {
                    mbid: row.get(0)?,
                    title: row.get(1)?,
                    artist_mbid: row.get(2)?,
                    artist: row
                        .get::<_, Option<String>>(3)?
                        .unwrap_or_else(|| "Unknown Artist".into()),
                    date: row.get(4)?,
                    track_count: None,
                    score: 100,
                })
            })
            .map_err(|e| DataError::Other(e.to_string()))?
            .filter_map(|r| r.ok())
            .collect()
        };

        Ok(results)
    }

    async fn get_recording(&self, mbid: &str) -> DataResult<RecordingDetails> {
        let conn = self.conn.lock().unwrap();

        let recording = conn.query_row(
            "SELECT r.mbid, r.title, r.artist_mbid, r.duration_ms, a.name
             FROM mb_recordings r
             LEFT JOIN mb_artists a ON r.artist_mbid = a.mbid
             WHERE r.mbid = ?1",
            rusqlite::params![mbid],
            |row| {
                Ok(RecordingDetails {
                    mbid: row.get(0)?,
                    title: row.get(1)?,
                    artist_mbid: row.get(2)?,
                    duration_ms: row.get(3)?,
                    artist: row
                        .get::<_, Option<String>>(4)?
                        .unwrap_or_else(|| "Unknown Artist".into()),
                    releases: vec![],
                    genres: vec![],
                })
            },
        );

        match recording {
            Ok(mut r) => {
                // Fetch releases that contain this recording
                let mut stmt = conn
                    .prepare(
                        "SELECT DISTINCT rel.mbid, rel.title, rel.date
                         FROM mb_tracks t
                         JOIN mb_releases rel ON t.release_mbid = rel.mbid
                         WHERE t.recording_mbid = ?1
                         LIMIT 10",
                    )
                    .map_err(|e| DataError::Other(e.to_string()))?;
                r.releases = stmt
                    .query_map(rusqlite::params![mbid], |row| {
                        Ok(ReleaseRef {
                            mbid: row.get(0)?,
                            title: row.get(1)?,
                            date: row.get(2)?,
                            track_number: None,
                        })
                    })
                    .map_err(|e| DataError::Other(e.to_string()))?
                    .filter_map(|r| r.ok())
                    .collect();
                Ok(r)
            }
            Err(rusqlite::Error::QueryReturnedNoRows) => {
                // Not in standalone recordings — try finding via tracks-on-releases
                let track_recording = conn.query_row(
                    "SELECT t.recording_mbid, t.title, rel.artist_mbid, a.name, t.duration_ms
                     FROM mb_tracks t
                     JOIN mb_releases rel ON t.release_mbid = rel.mbid
                     LEFT JOIN mb_artists a ON rel.artist_mbid = a.mbid
                     WHERE t.recording_mbid = ?1
                     LIMIT 1",
                    rusqlite::params![mbid],
                    |row| {
                        let duration: Option<i64> = row.get(4)?;
                        Ok(RecordingDetails {
                            mbid: row.get(0)?,
                            title: row.get(1)?,
                            artist_mbid: row.get(2)?,
                            duration_ms: duration.map(|d| d as u64),
                            artist: row
                                .get::<_, Option<String>>(3)?
                                .unwrap_or_else(|| "Unknown Artist".into()),
                            releases: vec![],
                            genres: vec![],
                        })
                    },
                );

                match track_recording {
                    Ok(mut r) => {
                        // Fetch all releases containing this recording
                        let mut stmt = conn
                            .prepare(
                                "SELECT DISTINCT rel.mbid, rel.title, rel.date
                                 FROM mb_tracks t
                                 JOIN mb_releases rel ON t.release_mbid = rel.mbid
                                 WHERE t.recording_mbid = ?1
                                 LIMIT 10",
                            )
                            .map_err(|e| DataError::Other(e.to_string()))?;
                        r.releases = stmt
                            .query_map(rusqlite::params![mbid], |row| {
                                Ok(ReleaseRef {
                                    mbid: row.get(0)?,
                                    title: row.get(1)?,
                                    date: row.get(2)?,
                                    track_number: None,
                                })
                            })
                            .map_err(|e| DataError::Other(e.to_string()))?
                            .filter_map(|r| r.ok())
                            .collect();
                        Ok(r)
                    }
                    Err(_) => Err(DataError::Other(format!(
                        "recording {mbid} not found locally"
                    ))),
                }
            }
            Err(e) => Err(DataError::Other(e.to_string())),
        }
    }

    async fn search_artist(&self, query: &str, limit: u32) -> DataResult<Vec<ArtistSearchResult>> {
        let conn = self.conn.lock().unwrap();
        let pattern = format!("%{query}%");
        let mut stmt = conn
            .prepare(
                "SELECT mbid, name, disambiguation, country, artist_type
                 FROM mb_artists
                 WHERE name LIKE ?1 COLLATE NOCASE
                 LIMIT ?2",
            )
            .map_err(|e| DataError::Other(e.to_string()))?;

        let results: Vec<ArtistSearchResult> = stmt
            .query_map(rusqlite::params![pattern, limit], |row| {
                Ok(ArtistSearchResult {
                    mbid: row.get(0)?,
                    name: row.get(1)?,
                    disambiguation: row.get::<_, Option<String>>(2)?.filter(|s| !s.is_empty()),
                    country: row.get(3)?,
                    artist_type: row.get(4)?,
                    score: 100,
                })
            })
            .map_err(|e| DataError::Other(e.to_string()))?
            .filter_map(|r| r.ok())
            .collect();

        Ok(results)
    }

    async fn get_artist_releases(
        &self,
        artist_mbid: &str,
        limit: u32,
    ) -> DataResult<Vec<DiscographyEntry>> {
        let conn = self.conn.lock().unwrap();
        let mut stmt = conn
            .prepare(
                "SELECT mbid, title, date, status
                 FROM mb_releases
                 WHERE artist_mbid = ?1
                 LIMIT ?2",
            )
            .map_err(|e| DataError::Other(e.to_string()))?;

        let results: Vec<DiscographyEntry> = stmt
            .query_map(rusqlite::params![artist_mbid, limit], |row| {
                Ok(DiscographyEntry {
                    mbid: row.get(0)?,
                    title: row.get(1)?,
                    date: row.get(2)?,
                    release_type: row.get(3)?,
                    track_count: None,
                })
            })
            .map_err(|e| DataError::Other(e.to_string()))?
            .filter_map(|r| r.ok())
            .collect();

        Ok(results)
    }

    async fn get_release_tracks(&self, release_mbid: &str) -> DataResult<Vec<ReleaseTrack>> {
        let conn = self.conn.lock().unwrap();
        let mut stmt = conn
            .prepare(
                "SELECT recording_mbid, title, track_number, disc_number, duration_ms
                 FROM mb_tracks
                 WHERE release_mbid = ?1
                 ORDER BY disc_number, track_number",
            )
            .map_err(|e| DataError::Other(e.to_string()))?;

        let tracks: Vec<ReleaseTrack> = stmt
            .query_map(rusqlite::params![release_mbid], |row| {
                Ok(ReleaseTrack {
                    recording_mbid: row.get(0)?,
                    title: row.get(1)?,
                    track_number: row.get(2)?,
                    disc_number: row.get(3)?,
                    duration_ms: row.get(4)?,
                })
            })
            .map_err(|e| DataError::Other(e.to_string()))?
            .filter_map(|r| r.ok())
            .collect();

        if tracks.is_empty() {
            Err(DataError::Other(format!(
                "no tracks found for release {release_mbid}"
            )))
        } else {
            Ok(tracks)
        }
    }

    async fn get_artist_release_groups(
        &self,
        artist_mbid: &str,
    ) -> DataResult<Vec<ReleaseGroupEntry>> {
        let conn = self.conn.lock().unwrap();
        let mut stmt = conn
            .prepare(
                "SELECT rg.mbid, rg.title, rg.primary_type, rg.secondary_types, rg.first_release_date,
                        (SELECT r.mbid FROM mb_releases r WHERE r.release_group_mbid = rg.mbid LIMIT 1) as first_release_mbid
                 FROM mb_release_groups rg
                 WHERE rg.artist_mbid = ?1
                 ORDER BY rg.first_release_date",
            )
            .map_err(|e| DataError::Other(e.to_string()))?;

        let results: Vec<ReleaseGroupEntry> = stmt
            .query_map(rusqlite::params![artist_mbid], |row| {
                let secondary_types_json: Option<String> = row.get(3)?;
                let secondary_types: Vec<String> = secondary_types_json
                    .and_then(|s| serde_json::from_str(&s).ok())
                    .unwrap_or_default();

                Ok(ReleaseGroupEntry {
                    mbid: row.get(0)?,
                    title: row.get(1)?,
                    primary_type: row.get(2)?,
                    secondary_types,
                    first_release_date: row.get(4)?,
                    first_release_mbid: row.get(5)?,
                    featured: false, // Local DB only stores primary-credit releases
                })
            })
            .map_err(|e| DataError::Other(e.to_string()))?
            .filter_map(|r| r.ok())
            .collect();

        Ok(results)
    }

    async fn resolve_release_from_group(&self, release_group_mbid: &str) -> DataResult<String> {
        let conn = self.conn.lock().unwrap();
        let result = conn.query_row(
            "SELECT mbid FROM mb_releases WHERE release_group_mbid = ?1 LIMIT 1",
            rusqlite::params![release_group_mbid],
            |row| row.get::<_, String>(0),
        );

        match result {
            Ok(mbid) => Ok(mbid),
            Err(rusqlite::Error::QueryReturnedNoRows) => Err(DataError::Other(format!(
                "no releases for release-group {release_group_mbid}"
            ))),
            Err(e) => Err(DataError::Other(e.to_string())),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::mb_import;

    fn setup_test_db() -> Connection {
        let conn = Connection::open_in_memory().unwrap();
        mb_import::create_schema(&conn).unwrap();

        // Insert test data
        conn.execute(
            "INSERT INTO mb_artists (mbid, name, sort_name, disambiguation, artist_type, country, begin_year) VALUES ('a-1', 'Test Artist', 'Artist, Test', 'test', 'Person', 'US', 1990)",
            [],
        ).unwrap();

        conn.execute(
            "INSERT INTO mb_artist_urls (artist_mbid, url, link_type) VALUES ('a-1', 'https://en.wikipedia.org/wiki/Test', 'wikipedia')",
            [],
        ).unwrap();

        conn.execute(
            "INSERT INTO mb_release_groups (mbid, title, artist_mbid, primary_type, secondary_types, first_release_date) VALUES ('rg-1', 'Test Album', 'a-1', 'Album', NULL, '2020-01-15')",
            [],
        ).unwrap();

        conn.execute(
            "INSERT INTO mb_releases (mbid, title, release_group_mbid, artist_mbid, date, country, status) VALUES ('r-1', 'Test Album', 'rg-1', 'a-1', '2020-01-15', 'US', 'Official')",
            [],
        ).unwrap();

        conn.execute(
            "INSERT INTO mb_tracks (release_mbid, recording_mbid, title, track_number, disc_number, duration_ms, position) VALUES ('r-1', 'rec-1', 'Track One', 1, 1, 240000, 1)",
            [],
        ).unwrap();

        conn.execute(
            "INSERT INTO mb_recordings (mbid, title, artist_mbid, duration_ms) VALUES ('rec-1', 'Track One', 'a-1', 240000)",
            [],
        ).unwrap();

        // Insert import metadata
        conn.execute(
            "INSERT INTO mb_import_meta (key, value) VALUES ('artist_count', '1')",
            [],
        )
        .unwrap();

        conn
    }

    #[test]
    fn test_get_artist_info_sync() {
        let conn = setup_test_db();
        // We can't easily test the struct directly since it wraps a Mutex<Connection>,
        // but we can test the SQL works
        let (name, disambig): (String, Option<String>) = conn
            .query_row(
                "SELECT name, disambiguation FROM mb_artists WHERE mbid = 'a-1'",
                [],
                |row| Ok((row.get(0)?, row.get(1)?)),
            )
            .unwrap();
        assert_eq!(name, "Test Artist");
        assert_eq!(disambig, Some("test".to_string()));
    }

    #[test]
    fn test_resolve_release_from_group() {
        let conn = setup_test_db();
        let mbid: String = conn
            .query_row(
                "SELECT mbid FROM mb_releases WHERE release_group_mbid = 'rg-1' LIMIT 1",
                [],
                |row| row.get(0),
            )
            .unwrap();
        assert_eq!(mbid, "r-1");
    }
}