use calibre_db::data::{author::Author as DbAuthor, series::Series};
use serde::Serialize;
use time::OffsetDateTime;

use crate::data::book::Book;

use super::{
    author::Author, content::Content, link::Link, media_type::MediaType, relation::Relation,
};

#[derive(Debug, Serialize)]
#[serde(rename = "entry")]
pub struct Entry {
    pub title: String,
    pub id: String,
    #[serde(with = "time::serde::rfc3339")]
    pub updated: OffsetDateTime,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content: Option<Content>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub author: Option<Author>,
    #[serde(rename = "link")]
    pub links: Vec<Link>,
}

impl From<Book> for Entry {
    fn from(value: Book) -> Self {
        let author = Author {
            name: value.clone().author.name,
            uri: format!("/opds/authors/{}", value.author.id),
            email: None,
        };
        let mut links = vec![Link {
            href: format!("/cover/{}", value.id),
            media_type: MediaType::Jpeg,
            rel: Relation::Image,
            title: None,
            count: None,
        }];
        let mut format_links: Vec<Link> = value
            .formats
            .iter()
            .map(|(key, val)| Link::from((&value, (key, val.as_str()))))
            .collect();
        links.append(&mut format_links);

        let content = value.description.map(|desc| Content {
            media_type: MediaType::Html,
            content: desc,
        });

        Self {
            title: value.title.clone(),
            id: format!("urn:uuid:{}", value.uuid),
            updated: value.last_modified,
            content,
            author: Some(author),
            links,
        }
    }
}

impl From<DbAuthor> for Entry {
    fn from(value: DbAuthor) -> Self {
        let links = vec![Link {
            href: format!("/opds/authors/{}", value.id),
            media_type: MediaType::Acquisition,
            rel: Relation::Subsection,
            title: None,
            count: None,
        }];

        Self {
            title: value.name.clone(),
            id: format!("rusty:authors:{}", value.id),
            updated: OffsetDateTime::now_utc(),
            content: None,
            author: None,
            links,
        }
    }
}

impl From<Series> for Entry {
    fn from(value: Series) -> Self {
        let links = vec![Link {
            href: format!("/opds/series/{}", value.id),
            media_type: MediaType::Acquisition,
            rel: Relation::Subsection,
            title: None,
            count: None,
        }];

        Self {
            title: value.name.clone(),
            id: format!("rusty:series:{}", value.id),
            updated: OffsetDateTime::now_utc(),
            content: None,
            author: None,
            links,
        }
    }
}

#[cfg(test)]
mod tests {
    use quick_xml::se::to_string;
    use time::macros::datetime;

    use crate::opds::{content::Content, media_type::MediaType, relation::Relation};

    use super::*;

    fn init() -> Entry {
        Entry {
            title: "Authors".to_string(),
            id: "rust:authors".to_string(),
            updated: datetime!(2024-05-06 19:14:54 UTC),
            content: Some(Content {
                media_type: MediaType::Text,
                content: "All authors".to_string(),
            }),
            author: None,
            links: vec![
                Link {
                    href: "/opds".to_string(),
                    media_type: MediaType::Text,
                    rel: Relation::Start,
                    title: None,
                    count: None,
                },
                Link {
                    href: "/opds".to_string(),
                    media_type: MediaType::Text,
                    rel: Relation::Start,
                    title: None,
                    count: None,
                },
            ],
        }
    }

    #[test]
    fn serialize() {
        let entry = init();
        let xml = to_string(&entry).unwrap();
        assert_eq!(
            xml,
            r#"<entry><title>Authors</title><id>rust:authors</id><updated>2024-05-06T19:14:54Z</updated><content type="text">All authors</content><link href="/opds" type="text" rel="start"/><link href="/opds" type="text" rel="start"/></entry>"#
        );
    }
}