use serde::{Deserialize, Serialize};

use super::config::Config;

use std::time::Duration;

#[derive(Clone)]
pub struct JellyfinClient {
    base_url: String,
    client: reqwest::blocking::Client,
    token: String,
    device_id: String,
}

/// Human-readable device label shown in Jellyfin's dashboard. Cosmetic only —
/// DeviceId is what the server keys sessions on.
fn device_name() -> String {
    if let Ok(h) = std::fs::read_to_string("/etc/hostname") {
        let h = h.trim();
        if !h.is_empty() {
            return h.to_string();
        }
    }

    std::env::var("HOSTNAME").unwrap_or_else(|_| "cjtui".to_string())
}

pub struct LoginResult {
    pub access_token: String,
    pub user_id: Option<String>,
}

#[derive(Serialize)]
struct AuthenticateUserByName<'a> {
    #[serde(rename = "Username")]
    username: &'a str,
    #[serde(rename = "Pw")]
    pw: &'a str,
}

#[derive(Serialize)]
struct PlaybackStartInfo<'a> {
    #[serde(rename = "ItemId")]
    item_id: &'a str,

    #[serde(rename = "PositionTicks", skip_serializing_if = "Option::is_none")]
    position_ticks: Option<i64>,

    #[serde(rename = "CanSeek")]
    can_seek: bool,

    #[serde(rename = "IsPaused")]
    is_paused: bool,

    #[serde(rename = "IsMuted")]
    is_muted: bool,

    // Optional but harmless to include; some servers like seeing it present.
    #[serde(rename = "MediaSourceId", skip_serializing_if = "Option::is_none")]
    media_source_id: Option<&'a str>,
}

#[derive(Serialize)]
struct PlaybackProgressInfo<'a> {
    #[serde(rename = "ItemId")]
    item_id: &'a str,

    #[serde(rename = "PositionTicks", skip_serializing_if = "Option::is_none")]
    position_ticks: Option<i64>,

    #[serde(rename = "CanSeek")]
    can_seek: bool,

    #[serde(rename = "IsPaused")]
    is_paused: bool,

    #[serde(rename = "IsMuted")]
    is_muted: bool,

    #[serde(rename = "MediaSourceId", skip_serializing_if = "Option::is_none")]
    media_source_id: Option<&'a str>,
}

#[derive(Serialize)]
struct PlaybackStopInfo<'a> {
    #[serde(rename = "ItemId")]
    item_id: &'a str,

    #[serde(rename = "PositionTicks", skip_serializing_if = "Option::is_none")]
    position_ticks: Option<i64>,

    #[serde(rename = "MediaSourceId", skip_serializing_if = "Option::is_none")]
    media_source_id: Option<&'a str>,

    #[serde(rename = "Failed")]
    failed: bool,
}


#[derive(Deserialize)]
struct AuthenticationResult {
    #[serde(rename = "AccessToken")]
    access_token: Option<String>,
    #[serde(rename = "User")]
    user: Option<UserDto>,
}

#[derive(Deserialize)]
struct UserDto {
    #[serde(rename = "Id")]
    id: Option<String>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct ViewsResponse {
    #[serde(rename = "Items", default)]
    pub items: Vec<JfItem>,
}

#[derive(Deserialize)]
struct PlaylistItemsResponse {
    #[serde(rename = "Items", default)]
    items: Vec<JfItem>,
    #[serde(rename = "TotalRecordCount")]
    total_record_count: Option<usize>,
}


impl JellyfinClient {
    pub fn from_config(cfg: &Config) -> Result<Self, String> {
        let token = cfg
            .access_token
            .clone()
            .ok_or_else(|| "missing access_token (need login)".to_string())?;

        Ok(Self {
            base_url: cfg.base_url.trim_end_matches('/').to_string(),
            client: reqwest::blocking::Client::new(),
            token,
            device_id: cfg.device_id.clone().unwrap_or_default(),
        })
    }

    pub fn unauthenticated(base_url: &str, device_id: &str) -> Self {
        Self {
            base_url: base_url.trim_end_matches('/').to_string(),
            client: reqwest::blocking::Client::new(),
            token: String::new(), // unused for login
            device_id: device_id.to_string(),
        }
    }

    pub fn login_by_name(&self, username: &str, password: &str) -> Result<LoginResult, String> {
        let url = format!("{}/Users/AuthenticateByName", self.base_url);

        let auth_header = format!(
            "MediaBrowser Client=\"cjtui\", Device=\"{}\", DeviceId=\"{}\", Version=\"{}\"",
            device_name(),
            self.device_id,
            env!("CARGO_PKG_VERSION"),
        );

        let body = AuthenticateUserByName { username, pw: password };

        let resp = self
            .client
            .post(url)
            .header("X-Emby-Authorization", auth_header)
            .json(&body)
            .send()
            .map_err(|e| format!("request failed: {e}"))?;

        if !resp.status().is_success() {
            let status = resp.status();
            let text = resp.text().unwrap_or_default();
            return Err(format!("login failed: {status} {text}"));
        }

        let parsed: AuthenticationResult = resp
            .json()
            .map_err(|e| format!("bad response json: {e}"))?;

        let token = parsed
            .access_token
            .ok_or_else(|| "missing AccessToken in response".to_string())?;

        let user_id = parsed.user.and_then(|u| u.id);

        Ok(LoginResult {
            access_token: token,
            user_id,
        })
    }

    pub fn ping_base_url(base_url: &str) -> bool {
        // Fast, unauthenticated check. Latch result at startup.
        // We try a couple endpoints because Jellyfin setups vary.
        let base = base_url.trim_end_matches('/');

        let client = match reqwest::blocking::Client::builder()
            .timeout(Duration::from_millis(900))
            .build()
        {
            Ok(c) => c,
            Err(_) => return false,
        };

        let candidates = [
            format!("{base}/System/Ping"),
            format!("{base}/System/Info/Public"),
        ];

        for url in candidates {
            if let Ok(resp) = client.get(url).send() {
                if resp.status().is_success() {
                    return true;
                }
            }
        }

        false
    }

    pub fn mark_played(&self, user_id: &str, item_id: &str) -> Result<(), String> {
        let base = self.base_url.trim_end_matches('/');
        let url = format!("{base}/Users/{user_id}/PlayedItems/{item_id}");

        let resp = self
            .client
            .post(url)
            .header("X-Emby-Token", &self.token)
            .send()
            .map_err(|e| format!("mark_played request failed: {e}"))?;

        if !resp.status().is_success() {
            return Err(format!("mark_played failed: HTTP {}", resp.status()));
        }

        Ok(())
    }

    pub fn mark_unplayed(&self, user_id: &str, item_id: &str) -> Result<(), String> {
        let base = self.base_url.trim_end_matches('/');
        let url = format!("{base}/Users/{user_id}/PlayedItems/{item_id}");

        let resp = self
            .client
            .delete(url)
            .header("X-Emby-Token", &self.token)
            .send()
            .map_err(|e| format!("mark_unplayed request failed: {e}"))?;

        if !resp.status().is_success() {
            return Err(format!("mark_unplayed failed: HTTP {}", resp.status()));
        }

        Ok(())
    }

    pub fn report_playback_start(&self, item_id: &str, position_ticks: Option<i64>) -> Result<(), String> {
    let base = self.base_url.trim_end_matches('/');
    let url = format!("{base}/Sessions/Playing");

    let body = PlaybackStartInfo {
        item_id,
        position_ticks,
        can_seek: true,
        is_paused: false,
        is_muted: false,
        media_source_id: Some(item_id),
    };

    let resp = self
        .client
        .post(url)
        .header("X-Emby-Token", &self.token)
        .json(&body)
        .send()
        .map_err(|e| format!("report_playback_start request failed: {e}"))?;

    if !resp.status().is_success() {
        return Err(format!("report_playback_start HTTP {}", resp.status()));
    }

    Ok(())
}

    pub fn report_playback_progress(&self, item_id: &str, position_ticks: Option<i64>, is_paused: bool) -> Result<(), String> {
        let base = self.base_url.trim_end_matches('/');
        let url = format!("{base}/Sessions/Playing/Progress");

        let body = PlaybackProgressInfo {
            item_id,
            position_ticks,
            can_seek: true,
            is_paused,
            is_muted: false,
            media_source_id: Some(item_id),
        };

        let resp = self
            .client
            .post(url)
            .header("X-Emby-Token", &self.token)
            .json(&body)
            .send()
            .map_err(|e| format!("report_playback_progress request failed: {e}"))?;

        if !resp.status().is_success() {
            return Err(format!("report_playback_progress HTTP {}", resp.status()));
        }

        Ok(())
    }

    pub fn report_playback_stopped(&self, item_id: &str, position_ticks: Option<i64>, failed: bool) -> Result<(), String> {
        let base = self.base_url.trim_end_matches('/');
        let url = format!("{base}/Sessions/Playing/Stopped");

        let body = PlaybackStopInfo {
            item_id,
            position_ticks,
            media_source_id: Some(item_id),
            failed,
        };

        let resp = self
            .client
            .post(url)
            .header("X-Emby-Token", &self.token)
            .json(&body)
            .send()
            .map_err(|e| format!("report_playback_stopped request failed: {e}"))?;

        if !resp.status().is_success() {
            return Err(format!("report_playback_stopped HTTP {}", resp.status()));
        }

        Ok(())
    }

    pub fn list_views(&self, user_id: &str) -> Result<Vec<JfItem>, String> {
        let url = format!("{}/Users/{}/Views", self.base_url, user_id);

        let resp = self
            .client
            .get(url)
            .header("X-Emby-Authorization", self.auth_header_value())
            .send()
            .map_err(|e| format!("Views request failed: {e}"))?;

        if !resp.status().is_success() {
            let status = resp.status();
            let text = resp.text().unwrap_or_default();
            return Err(format!("Views failed: {status} {text}"));
        }

        let parsed: ViewsResponse = resp
            .json()
            .map_err(|e| format!("Views parse failed: {e}"))?;

        Ok(parsed.items)
    }

    fn auth_header_value(&self) -> String {
        // Identify as a client and include the token. DeviceId is per-install so
        // that two machines on the same account hold independent sessions.
        format!(
            "MediaBrowser Client=\"cjtui\", Device=\"{}\", DeviceId=\"{}\", Version=\"{}\", Token=\"{}\"",
            device_name(),
            self.device_id,
            env!("CARGO_PKG_VERSION"),
            self.token
        )
    }

    pub fn list_items(
        &self,
        user_id: &str,
        query: LibraryQuery,
        start_index: usize,
        limit: usize,
    ) -> Result<PagedItems, String> {
        let url = format!("{}/Users/{}/Items", self.base_url, user_id);

        let default_sort_by = if let Some(types) = query.include_item_types.as_deref() {
            if types.contains("Episode") {
                "ParentIndexNumber,IndexNumber,SortName".to_string()
            } else {
                "SortName".to_string()
            }
        } else {
            "SortName".to_string()
        };

        let sort_by = query.sort_by.clone().unwrap_or(default_sort_by);
        let sort_order = query
            .sort_order
            .clone()
            .unwrap_or_else(|| "Ascending".to_string());

        let recursive = if query.recursive { "true" } else { "false" };

        let mut req = self
            .client
            .get(url)
            .header("X-Emby-Authorization", self.auth_header_value())
            .query(&[
                ("Recursive", recursive),
                ("StartIndex", &start_index.to_string()),
                ("Limit", &limit.to_string()),
                ("Fields", "PrimaryImageAspectRatio,SortName,ProductionYear,IndexNumber,ParentIndexNumber,RunTimeTicks,Genres,Studios,Overview,SeriesName,Album,AlbumArtist,Artists,UserData,ChildCount,RecursiveItemCount"),
                ("SortBy", &sort_by),
                ("SortOrder", &sort_order),
            ]);

        if let Some(types) = query.include_item_types.as_deref() {
            // Jellyfin expects IncludeItemTypes as repeated query params, not CSV
            for t in types.split(',').map(|s| s.trim()).filter(|s| !s.is_empty()) {
                req = req.query(&[("IncludeItemTypes", t)]);
            }
        }
        if let Some(parent) = query.parent_id.as_deref() {
            req = req.query(&[("ParentId", parent)]);
        }
        if let Some(term) = query.search_term.as_deref() {
            req = req.query(&[("SearchTerm", term)]);
        }
        if let Some(filters) = query.filters.as_deref() {
            req = req.query(&[("Filters", filters)]);
        }

        let resp = req.send().map_err(|e| format!("request failed: {e}"))?;

        if !resp.status().is_success() {
            let status = resp.status();
            let text = resp.text().unwrap_or_default();
            return Err(format!("list_items failed: {status} {text}"));
        }

        let parsed: ItemsResponse = resp
            .json()
            .map_err(|e| format!("bad response json: {e}"))?;

        Ok(PagedItems {
            items: parsed.items,
            total: parsed.total_record_count.unwrap_or(0),
        })
    }

/// Returns true if there exists at least one resumable Episode under the given parent (Series or Season).
/// This is used to mark Series/Season rows as "in progress" even when Jellyfin doesn't populate
/// PlayedPercentage on those container types.
pub fn has_resumable_under(
    &self,
    user_id: &str,
    parent_id: &str,
) -> Result<bool, String> {
    // Series -> Season -> Episode, so this MUST be recursive for Series.
    // Recursive=true is also fine for Season.
    let mut q = LibraryQuery::all()
        .with_parent(parent_id.to_string())
        .with_item_types("Episode")
        .with_filters("IsResumable");

    q.recursive = true;

    let page = self.list_items(user_id, q, 0, 1)?;
    Ok(page.total > 0)
}

pub fn playlist_items(
        &self,
        user_id: &str,
        playlist_id: &str,
        start_index: usize,
        limit: usize,
    ) -> Result<PagedItems, String> {
        let url = format!("{}/Playlists/{}/Items", self.base_url, playlist_id);

        let resp = self
            .client
            .get(url)
            .header("X-Emby-Authorization", self.auth_header_value())
            .query(&[
                ("UserId", user_id),
                ("StartIndex", &start_index.to_string()),
                ("Limit", &limit.to_string()),
                ("Fields", "PrimaryImageAspectRatio,SortName,ProductionYear,IndexNumber,ParentIndexNumber,RunTimeTicks,Genres,Studios,Overview,SeriesName,Album,AlbumArtist,Artists,UserData,ChildCount,RecursiveItemCount"),
            ])
            .send()
            .map_err(|e| format!("request failed: {e}"))?;

        if !resp.status().is_success() {
            let status = resp.status();
            let text = resp.text().unwrap_or_default();
            return Err(format!("playlist_items failed: {status} {text}"));
        }

        let parsed: PlaylistItemsResponse = resp
            .json()
            .map_err(|e| format!("bad response json: {e}"))?;

        Ok(PagedItems {
            items: parsed.items,
            total: parsed.total_record_count.unwrap_or(0),
        })
    }
}

/// What kind of library list we want.
#[derive(Clone)]
pub struct LibraryQuery {
    pub include_item_types: Option<String>, // e.g. Some("Movie".into())
    pub parent_id: Option<String>,          // e.g. Some(series_id)
    pub search_term: Option<String>,        // e.g. Some("matrix".into())
    pub recursive: bool,                    // true for big lists, false for drilldown
    pub filters: Option<String>,            // e.g. Some("IsResumable".into())

    // optional overrides
    pub sort_by: Option<String>,            // e.g. Some("DateCreated".into())
    pub sort_order: Option<String>,         // "Ascending" or "Descending"
}


impl LibraryQuery {
    pub fn movies() -> Self {
        Self {
            include_item_types: Some("Movie".into()),
            parent_id: None,
            search_term: None,
            recursive: true,
            filters: None,
            sort_by: None,
            sort_order: None,
        }
    }
    pub fn shows() -> Self {
        Self {
            include_item_types: Some("Series".into()),
            parent_id: None,
            search_term: None,
            recursive: true,
            filters: None,
            sort_by: None,
            sort_order: None,
        }
    }
    pub fn music() -> Self {
        Self {
            include_item_types: Some("Audio".into()),
            parent_id: None,
            search_term: None,
            recursive: true,
            filters: None,
            sort_by: None,
            sort_order: None,
        }
    }

    // true "All" (no filter)
    pub fn all() -> Self {
        Self {
            include_item_types: None,
            parent_id: None,
            search_term: None,
            recursive: true,
            filters: None,
            sort_by: None,
            sort_order: None,
        }
    }

    pub fn with_parent(mut self, parent_id: impl Into<String>) -> Self {
        self.parent_id = Some(parent_id.into());
        self.recursive = false; // drilldown is usually direct children
        self
    }

    pub fn with_search(mut self, term: impl Into<String>) -> Self {
        self.search_term = Some(term.into());
        self
    }

    pub fn with_item_types(mut self, types: impl Into<String>) -> Self {
        self.include_item_types = Some(types.into());
        self
    }

    pub fn with_filters(mut self, filters: impl Into<String>) -> Self {
        self.filters = Some(filters.into());
        self
    }

    pub fn with_sort_by(mut self, sort_by: impl Into<String>) -> Self {
        self.sort_by = Some(sort_by.into());
        self
    }

    pub fn with_sort_order(mut self, sort_order: impl Into<String>) -> Self {
        self.sort_order = Some(sort_order.into());
        self
    }
}


pub struct PagedItems {
    pub items: Vec<JfItem>,
    pub total: usize,
}

#[derive(Debug, Clone, Deserialize)]
pub struct JfStudio {
    #[serde(rename = "Name")]
    pub name: String,
}

#[derive(Deserialize, Clone, Debug, Default)]
pub struct JfUserData {
    #[serde(rename = "Played")]
    pub played: Option<bool>,

    #[serde(rename = "PlayedPercentage")]
    pub played_percentage: Option<f64>,

    #[serde(rename = "PlaybackPositionTicks")]
    pub playback_position_ticks: Option<i64>,

    #[serde(rename = "UnplayedItemCount")]
    pub unplayed_item_count: Option<i32>,
}


#[derive(Debug, Clone, Deserialize)]
pub struct JfItem {
    #[serde(rename = "Id")]
    pub id: String,
    #[serde(rename = "Name")]
    pub name: String,
    #[serde(rename = "Type")]
    pub item_type: Option<String>,
    #[serde(rename = "ProductionYear")]
    pub production_year: Option<i32>,

    #[serde(rename = "ChildCount")]
    pub child_count: Option<i64>,
    #[serde(rename = "RecursiveItemCount")]
    pub recursive_item_count: Option<i64>,

    #[serde(rename = "IndexNumber")]
    pub index_number: Option<i32>,
    #[serde(rename = "ParentIndexNumber")]
    pub parent_index_number: Option<i32>,

    // ✅ add these
    #[serde(rename = "RunTimeTicks")]
    pub run_time_ticks: Option<i64>,

    #[serde(rename = "Genres", default)]
    pub genres: Vec<String>,

    #[serde(rename = "Studios", default)]
    pub studios: Vec<JfStudio>,

    #[serde(rename = "Overview")]
    pub overview: Option<String>,

    #[serde(rename = "SeriesName")]
    pub series_name: Option<String>,

    #[serde(rename = "Album")]
    pub album: Option<String>,

    #[serde(rename = "AlbumArtist")]
    pub album_artist: Option<String>,

    #[serde(rename = "Artists", default)]
    pub artists: Vec<String>,

    #[serde(rename = "UserData")]
    pub user_data: Option<JfUserData>,
}

#[derive(Deserialize)]
struct ItemsResponse {
    #[serde(rename = "Items")]
    items: Vec<JfItem>,
    #[serde(rename = "TotalRecordCount")]
    total_record_count: Option<usize>,
}

#[derive(Debug, Clone, Deserialize)]
pub struct StudioDto {
    #[serde(rename = "Name")]
    pub name: Option<String>,
}