use std::borrow::Cow;

use crate::{
    error::{Error, ExtractionError},
    model::{paginator::Paginator, AlbumId, ChannelId, MusicAlbum, MusicPlaylist, TrackItem},
    serializer::MapResult,
    util::{self, TryRemove, DOT_SEPARATOR},
};

use super::{
    response::{
        self,
        music_item::{map_album_type, map_artist_id, map_artists, MusicListMapper},
    },
    ClientType, MapResponse, QBrowse, RustyPipeQuery,
};

impl RustyPipeQuery {
    /// Get a playlist from YouTube Music
    pub async fn music_playlist<S: AsRef<str>>(
        &self,
        playlist_id: S,
    ) -> Result<MusicPlaylist, Error> {
        let playlist_id = playlist_id.as_ref();
        let context = self.get_context(ClientType::DesktopMusic, true, None).await;
        let request_body = QBrowse {
            context,
            browse_id: &format!("VL{playlist_id}"),
        };

        self.execute_request::<response::MusicPlaylist, _, _>(
            ClientType::DesktopMusic,
            "music_playlist",
            playlist_id,
            "browse",
            &request_body,
        )
        .await
    }

    /// Get an album from YouTube Music
    pub async fn music_album<S: AsRef<str>>(&self, album_id: S) -> Result<MusicAlbum, Error> {
        let album_id = album_id.as_ref();
        let context = self.get_context(ClientType::DesktopMusic, true, None).await;
        let request_body = QBrowse {
            context,
            browse_id: album_id,
        };

        let mut album = self
            .execute_request::<response::MusicPlaylist, MusicAlbum, _>(
                ClientType::DesktopMusic,
                "music_album",
                album_id,
                "browse",
                &request_body,
            )
            .await?;

        // In rare cases, albums may have track numbers =0 (example: MPREb_RM0QfZ0eSKL)
        // They should be replaced with the track number derived from the previous track.
        let mut n_prev = 0;
        for track in &mut album.tracks {
            let tn = track.track_nr.unwrap_or_default();
            if tn == 0 {
                n_prev += 1;
                track.track_nr = Some(n_prev);
            } else {
                n_prev = tn;
            }
        }

        // YouTube Music is replacing album tracks with their respective music videos. To get the original
        // tracks, we have to fetch the album as a playlist and replace the offending track ids.
        if let Some(playlist_id) = &album.playlist_id {
            // Get a list of music videos in the album
            let to_replace = album
                .tracks
                .iter()
                .enumerate()
                .filter_map(|(i, track)| {
                    if track.is_video {
                        Some((i, track.name.clone()))
                    } else {
                        None
                    }
                })
                .collect::<Vec<_>>();

            if !to_replace.is_empty() {
                let mut playlist = self.music_playlist(playlist_id).await?;
                playlist
                    .tracks
                    .extend_limit(&self, album.tracks.len())
                    .await?;

                for (i, title) in to_replace {
                    let found_track = playlist.tracks.items.iter().find_map(|track| {
                        if track.name == title && !track.is_video {
                            Some((track.id.clone(), track.duration))
                        } else {
                            None
                        }
                    });
                    if let Some((track_id, duration)) = found_track {
                        album.tracks[i].id = track_id;
                        if let Some(duration) = duration {
                            album.tracks[i].duration = Some(duration);
                        }
                        album.tracks[i].is_video = false;
                    }
                }
            }
        }
        Ok(album)
    }
}

impl MapResponse<MusicPlaylist> for response::MusicPlaylist {
    fn map_response(
        self,
        id: &str,
        lang: crate::param::Language,
        _deobf: Option<&crate::deobfuscate::DeobfData>,
        _vdata: Option<&str>,
    ) -> Result<MapResult<MusicPlaylist>, ExtractionError> {
        // dbg!(&self);

        let music_contents = self
            .contents
            .single_column_browse_results_renderer
            .contents
            .into_iter()
            .next()
            .ok_or(ExtractionError::InvalidData(Cow::Borrowed("no content")))?
            .tab_renderer
            .content
            .section_list_renderer;
        let shelf = music_contents
            .contents
            .into_iter()
            .find_map(|section| match section {
                response::music_item::ItemSection::MusicShelfRenderer(shelf) => Some(shelf),
                _ => None,
            })
            .ok_or(ExtractionError::InvalidData(Cow::Borrowed(
                "no sectionListRenderer content",
            )))?;

        if let Some(playlist_id) = shelf.playlist_id {
            if playlist_id != id {
                return Err(ExtractionError::WrongResult(format!(
                    "got wrong playlist id {playlist_id}, expected {id}"
                )));
            }
        }

        let mut mapper = MusicListMapper::new(lang);
        mapper.map_response(shelf.contents);
        mapper.check_unknown()?;
        let map_res = mapper.conv_items();

        let ctoken = shelf
            .continuations
            .into_iter()
            .next()
            .map(|cont| cont.next_continuation_data.continuation);

        let track_count = if ctoken.is_some() {
            self.header.as_ref().and_then(|h| {
                let parts = h
                    .music_detail_header_renderer
                    .second_subtitle
                    .split(|p| p == DOT_SEPARATOR)
                    .collect::<Vec<_>>();
                parts
                    .get(usize::from(parts.len() > 2))
                    .and_then(|txt| util::parse_numeric::<u64>(&txt[0]).ok())
            })
        } else {
            Some(map_res.c.len() as u64)
        };

        let related_ctoken = music_contents
            .continuations
            .into_iter()
            .next()
            .map(|c| c.next_continuation_data.continuation);

        let (from_ytm, channel, name, thumbnail, description) = match self.header {
            Some(header) => {
                let h = header.music_detail_header_renderer;

                let from_ytm = h.subtitle.0.iter().any(util::is_ytm);
                let channel = h
                    .subtitle
                    .0
                    .into_iter()
                    .find_map(|c| ChannelId::try_from(c).ok());

                (
                    from_ytm,
                    channel,
                    h.title,
                    h.thumbnail.into(),
                    h.description,
                )
            }
            None => {
                // Album playlists fetched via the playlist method dont include a header
                let (album, cover) = map_res
                    .c
                    .first()
                    .and_then(|t: &TrackItem| {
                        t.album.as_ref().map(|a| (a.clone(), t.cover.clone()))
                    })
                    .ok_or(ExtractionError::InvalidData(Cow::Borrowed(
                        "playlist without header or album items",
                    )))?;

                if !map_res.c.iter().all(|t| {
                    t.album
                        .as_ref()
                        .map(|a| a.id == album.id)
                        .unwrap_or_default()
                }) {
                    return Err(ExtractionError::InvalidData(Cow::Borrowed(
                        "album playlist containing items from different albums",
                    )));
                }

                (true, None, album.name, cover, None)
            }
        };

        Ok(MapResult {
            c: MusicPlaylist {
                id: id.to_owned(),
                name,
                thumbnail,
                channel,
                description,
                track_count,
                from_ytm,
                tracks: Paginator::new_ext(
                    track_count,
                    map_res.c,
                    ctoken,
                    None,
                    crate::model::paginator::ContinuationEndpoint::MusicBrowse,
                ),
                related_playlists: Paginator::new_ext(
                    None,
                    Vec::new(),
                    related_ctoken,
                    None,
                    crate::model::paginator::ContinuationEndpoint::MusicBrowse,
                ),
            },
            warnings: map_res.warnings,
        })
    }
}

impl MapResponse<MusicAlbum> for response::MusicPlaylist {
    fn map_response(
        self,
        id: &str,
        lang: crate::param::Language,
        _deobf: Option<&crate::deobfuscate::DeobfData>,
        _vdata: Option<&str>,
    ) -> Result<MapResult<MusicAlbum>, ExtractionError> {
        // dbg!(&self);

        let header = self
            .header
            .ok_or(ExtractionError::InvalidData(Cow::Borrowed("no header")))?
            .music_detail_header_renderer;

        let sections = self
            .contents
            .single_column_browse_results_renderer
            .contents
            .into_iter()
            .next()
            .ok_or(ExtractionError::InvalidData(Cow::Borrowed("no content")))?
            .tab_renderer
            .content
            .section_list_renderer
            .contents;

        let mut shelf = None;
        let mut album_variants = None;
        for section in sections {
            match section {
                response::music_item::ItemSection::MusicShelfRenderer(sh) => shelf = Some(sh),
                response::music_item::ItemSection::MusicCarouselShelfRenderer(sh) => {
                    album_variants = Some(sh.contents);
                }
                _ => (),
            }
        }
        let shelf = shelf.ok_or(ExtractionError::InvalidData(Cow::Borrowed(
            "no sectionListRenderer content",
        )))?;

        let mut subtitle_split = header.subtitle.split(util::DOT_SEPARATOR);

        let (year_txt, artists_p) = match subtitle_split.len() {
            3.. => {
                let year_txt = subtitle_split
                    .swap_remove(2)
                    .0
                    .get(0)
                    .map(|c| c.as_str().to_owned());
                (year_txt, subtitle_split.try_swap_remove(1))
            }
            2 => {
                // The second part may either be the year or the artist
                let p2 = subtitle_split.swap_remove(1);
                let is_year =
                    p2.0.len() == 1 && p2.0[0].as_str().chars().all(|c| c.is_ascii_digit());
                if is_year {
                    (Some(p2.0[0].as_str().to_owned()), None)
                } else {
                    (None, Some(p2))
                }
            }
            _ => (None, None),
        };

        let (artists, by_va) = map_artists(artists_p);
        let album_type_txt = subtitle_split
            .into_iter()
            .next()
            .map(|part| part.to_string())
            .unwrap_or_default();

        let album_type = map_album_type(album_type_txt.as_str(), lang);
        let year = year_txt.and_then(|txt| util::parse_numeric(&txt).ok());

        let (artist_id, playlist_id) = header
            .menu
            .map(|menu| {
                (
                    map_artist_id(menu.menu_renderer.items),
                    menu.menu_renderer
                        .top_level_buttons
                        .into_iter()
                        .next()
                        .map(|btn| {
                            btn.button_renderer
                                .navigation_endpoint
                                .watch_playlist_endpoint
                                .playlist_id
                        }),
                )
            })
            .unwrap_or_default();
        let artist_id = artist_id.or_else(|| artists.first().and_then(|a| a.id.clone()));

        let mut mapper = MusicListMapper::with_album(
            lang,
            artists.clone(),
            by_va,
            AlbumId {
                id: id.to_owned(),
                name: header.title.clone(),
            },
        );
        mapper.map_response(shelf.contents);
        let tracks_res = mapper.conv_items();
        let mut warnings = tracks_res.warnings;

        let mut variants_mapper = MusicListMapper::new(lang);
        if let Some(res) = album_variants {
            variants_mapper.map_response(res);
        }
        let mut variants_res = variants_mapper.conv_items();
        warnings.append(&mut variants_res.warnings);

        Ok(MapResult {
            c: MusicAlbum {
                id: id.to_owned(),
                playlist_id,
                name: header.title,
                cover: header.thumbnail.into(),
                artists,
                artist_id,
                description: header.description,
                album_type,
                year,
                by_va,
                tracks: tracks_res.c,
                variants: variants_res.c,
            },
            warnings,
        })
    }
}

#[cfg(test)]
mod tests {
    use std::{fs::File, io::BufReader};

    use path_macro::path;
    use rstest::rstest;

    use super::*;
    use crate::{model, param::Language, util::tests::TESTFILES};

    #[rstest]
    #[case::short("short", "RDCLAK5uy_kFQXdnqMaQCVx2wpUM4ZfbsGCDibZtkJk")]
    #[case::long("long", "PL5dDx681T4bR7ZF1IuWzOv1omlRbE7PiJ")]
    #[case::nomusic("nomusic", "PL1J-6JOckZtE_P9Xx8D3b2O6w0idhuKBe")]
    fn map_music_playlist(#[case] name: &str, #[case] id: &str) {
        let json_path = path!(*TESTFILES / "music_playlist" / format!("playlist_{name}.json"));
        let json_file = File::open(json_path).unwrap();

        let playlist: response::MusicPlaylist =
            serde_json::from_reader(BufReader::new(json_file)).unwrap();
        let map_res: MapResult<model::MusicPlaylist> =
            playlist.map_response(id, Language::En, None, None).unwrap();

        assert!(
            map_res.warnings.is_empty(),
            "deserialization/mapping warnings: {:?}",
            map_res.warnings
        );
        insta::assert_ron_snapshot!(format!("map_music_playlist_{name}"), map_res.c, {
            ".last_update" => "[date]"
        });
    }

    #[rstest]
    #[case::one_artist("one_artist", "MPREb_nlBWQROfvjo")]
    #[case::various_artists("various_artists", "MPREb_8QkDeEIawvX")]
    #[case::single("single", "MPREb_bHfHGoy7vuv")]
    #[case::description("description", "MPREb_PiyfuVl6aYd")]
    #[case::unavailable("unavailable", "MPREb_AzuWg8qAVVl")]
    fn map_music_album(#[case] name: &str, #[case] id: &str) {
        let json_path = path!(*TESTFILES / "music_playlist" / format!("album_{name}.json"));
        let json_file = File::open(json_path).unwrap();

        let playlist: response::MusicPlaylist =
            serde_json::from_reader(BufReader::new(json_file)).unwrap();
        let map_res: MapResult<model::MusicAlbum> =
            playlist.map_response(id, Language::En, None, None).unwrap();

        assert!(
            map_res.warnings.is_empty(),
            "deserialization/mapping warnings: {:?}",
            map_res.warnings
        );
        insta::assert_ron_snapshot!(format!("map_music_album_{name}"), map_res.c);
    }
}