//! The public creator profile, described.
//!
//! `/u/{username}`: who the creator is, what they have published, and the four
//! ways to keep up with them. It replaces `templates/pages/user.html` and
//! `UserTemplate`.
//!
//! The second of the three pages that wrote `<link rel="alternate">` by hand,
//! after [`super::project_blog`]. The screen says it has a feed and
//! [`quasi_router::FeedKind::media_type`] spells it.
//!
//! # Why the route stays an axum handler
//!
//! [`super::project_blog`]'s reason. The handler resolves a username, refuses a
//! sandbox account, loads projects, links, collections and follow state, and
//! records a page view unless the caller is a crawler. None of that needs a
//! described route, and `super::Viewer` carries no session. What is described
//! is the document.
//!
//! # The creator's theme
//!
//! `user.html` injected `<style id="creator-theme">` in its `{% block head %}`,
//! unlayered so it outranks every named layer.
//! [`quasi_router::Document::styled`] is the member for exactly that -- a sheet
//! that is data rather than build output -- and `quasi-webview` writes it last
//! in the head and outside the layer statement, which is the property the
//! hand-written block existed to hold. Nothing keyed off the element's id.
//!
//! # What stayed markup
//!
//! The JSON-LD block. It is head markup that is neither
//! [`quasi_router::Discovery`] nor [`quasi_router::Document`], and it goes in
//! through [`quasi_webview::Shell::with_head`], the way `auth_pages` puts the
//! CSRF meta there. Growing `Discovery` a structured-data member is a
//! vocabulary change for one tag on three pages, and the tag is already built
//! from fields the screen holds.

use makeover_layout as layout;
use quasi_router::screen::Row;
use quasi_router::{
    Act, Action, Document, Feed, FeedKind, Node, RegionKind, Screen as Described, Slot,
};
use quasi_webview::Webview;

use crate::types::{Collection, CustomLink, Project, User};

/// The page's own region, and what the skip link points at.
pub const PAGE_REGION: &str = "user-profile";

/// How wide it runs. The template wrote this on the body.
const MEASURE: layout::Measure = layout::Measure::Wide;

/// Where a creator's feed answers.
#[must_use]
pub fn feed_path(username: &str) -> String {
    format!("/u/{username}/rss")
}

/// Everything the screen is about.
///
/// A struct rather than sixteen arguments, which is what `UserTemplate`
/// carried: the page is a lot of facts about one creator, and a positional list
/// of them is a list somebody transposes.
pub struct Profile<'a> {
    /// The creator.
    pub user: &'a User,
    /// Their id, which is what the follow route takes.
    pub user_id: &'a str,
    /// The site's own base address, for the absolute URLs a crawler and a share
    /// sheet read.
    pub host_url: &'a str,
    /// Their off-site links.
    pub custom_links: &'a [CustomLink],
    /// Their public projects.
    pub projects: &'a [Project],
    /// Their public collections.
    pub collections: &'a [Collection],
    /// How many people follow them.
    pub follower_count: i64,
    /// Whether the viewer does.
    pub is_following: bool,
    /// Whether the viewer is the creator.
    pub is_own_profile: bool,
    /// Whether there is a session at all.
    pub signed_in: bool,
    /// Whether the creator has voluntarily paused.
    pub paused: bool,
    /// Whether they take tips.
    pub tips_enabled: bool,
}

impl Profile<'_> {
    /// The address this page answers at.
    fn canonical(&self) -> String {
        format!("{}/u/{}", self.host_url, self.user.username)
    }

    /// The sentence a link preview shows.
    ///
    /// The template's `og:description`, which fell back to a fixed line when
    /// the creator had written no bio.
    fn summary(&self) -> String {
        self.user
            .bio
            .as_deref()
            .filter(|bio| !bio.trim().is_empty())
            .map_or_else(|| "Creator on Makenotwork".to_owned(), str::to_owned)
    }

    /// The picture a link preview shows: their avatar, or the site's card.
    fn image(&self) -> String {
        self.user
            .avatar_url
            .clone()
            .unwrap_or_else(|| format!("{}/static/images/og-card.png", self.host_url))
    }

    /// The structured data the template opened a `ProfilePage` block with.
    ///
    /// Built from the same three facts the screen already carries, and escaped
    /// through the same `json_escape` the template called: this is a JSON
    /// document inside a `<script>`, so HTML escaping would corrupt it and JSON
    /// escaping is what it needs.
    fn structured_data(&self) -> String {
        let mut json = format!(
            "{{\"@context\":\"https://schema.org\",\"@type\":\"ProfilePage\",\
             \"mainEntity\":{{\"@type\":\"Person\",\"name\":\"{}\",\"url\":\"{}\"",
            self.user.display_name_json(),
            crate::types::json_escape(&self.canonical()),
        );
        if self.user.bio.is_some() {
            use std::fmt::Write as _;
            let _ = write!(json, ",\"description\":\"{}\"", self.user.bio_json());
        }
        json.push_str("}}");
        format!("<script type=\"application/ld+json\">{json}</script>")
    }
}

/// The whole document.
#[must_use]
pub fn screen(profile: &Profile<'_>, theme_css: &str) -> Described {
    let user = profile.user;
    let name = user.display_name_or_username();
    let feed = feed_path(&user.username);

    let mut page = Slot::new(PAGE_REGION, RegionKind::Pane);

    // A creator on a break, said before anything they published: a reader
    // about to buy is the one who needs it.
    if profile.paused {
        page = page.with(Node::banner(
            layout::Tone::Info,
            "This creator is currently on break. Existing purchases remain accessible.",
        ));
    }

    page = page
        .with(Node::page(name.to_owned()))
        .with(Node::text(user.username.clone()));

    if let Some(bio) = user.bio.as_deref().filter(|bio| !bio.trim().is_empty()) {
        page = page.with(Node::text(bio.to_owned()));
    }

    if profile.is_own_profile {
        page = page.with(Node::act(
            "Edit Profile",
            Action::get("/dashboard?tab=settings").navigating(),
        ));
    }

    // Following is a write, so it needs a session, and a creator does not
    // follow themselves. Both were the template's conditions.
    if profile.signed_in && !profile.is_own_profile {
        page = page.with(super::follow::control(
            "user",
            profile.user_id,
            profile.is_following,
            profile.follower_count,
        ));
    } else if let Some(count) = super::follow::count_only(profile.follower_count) {
        page = page.with(count);
    }

    if profile.tips_enabled {
        page = page.with(super::tip::control(&super::tip::Offer {
            creator_id: profile.user_id,
            project_id: None,
            signed_in: profile.signed_in,
        }));
    }

    page = page
        .with(Node::act(
            "RSS Feed",
            Action::get(feed.clone()).navigating(),
        ))
        // Already sayable: `Act::copies` is "the value this press puts on the
        // clipboard", which is the whole of what `data-copy-link` meant. The
        // value is absolute, because a relative path on a clipboard is not an
        // address anybody can paste anywhere.
        .with(Node::Act(
            Act::new("Copy link", Action::local()).copying(profile.canonical()),
        ));

    if !profile.custom_links.is_empty() {
        page = page.with(Node::list(profile.custom_links.iter().map(|link| {
            Row::new(link.title.clone())
                .secondary(link.description.clone())
                // Somewhere else on the web, and the reader is expected to come
                // back: `External` rather than `Leaving`. The template said the
                // same thing with `target="_blank" rel="ugc nofollow noopener"`.
                .activate(Action::external(link.url.clone()))
        })));
    }

    if !profile.projects.is_empty() {
        page = page
            .with(Node::section("Projects"))
            .with(Node::list(profile.projects.iter().map(|project| {
                Row::new(project.title.clone())
                    .meta(format!(
                        "{} - {} items",
                        project.project_type, project.item_count
                    ))
                    .activate(Action::get(format!("/p/{}", project.slug)).navigating())
            })));
    }

    if !profile.collections.is_empty() {
        page = page.with(Node::section("Collections")).with(Node::list(
            profile.collections.iter().map(|collection| {
                Row::new(collection.title.clone())
                    .meta(format!("{} items", collection.item_count))
                    .activate(
                        Action::get(format!("/c/{}/{}", user.username, collection.slug))
                            .navigating(),
                    )
            }),
        ));
    }

    // The footer attribution. Content rather than decoration, for the reason
    // `project_blog` keeps its: it is where a reader on a creator's page finds
    // out whose platform they are on.
    page = page.with(Node::Link {
        text: "Powered by Makenot.work".to_owned(),
        action: Action::get("/").navigating(),
    });

    Described::single(format!("{name} - Makenotwork"))
        .measured(MEASURE)
        .documented(
            Document::default()
                .classed(crate::shell::body_class(MEASURE, &["user-page"]))
                // Tier 0: the creator's own primitive-layer override, written
                // last in the head and unlayered, which is where the
                // hand-written block put it.
                .styled(theme_css.to_owned()),
        )
        .summarised(profile.summary())
        .illustrated(profile.image())
        .canonical_at(profile.canonical())
        .about(quasi_router::SocialKind::Profile)
        .syndicating(Feed::new(FeedKind::Rss, format!("{name} - RSS Feed"), feed))
        .with(page)
}

/// The document this screen is drawn in.
#[must_use]
pub fn renderer(
    user: Option<&crate::auth::SessionUser>,
    csrf: Option<&str>,
    structured_data: &str,
) -> Webview {
    let csrf = csrf.unwrap_or_default();
    Webview::new().with_shell(
        crate::shell::described()
            .sending("X-CSRF-Token", csrf)
            .with_body_last(crate::shell::body_last())
            .with_body_first(format!(
                "{}{}",
                crate::shell::skip_link(PAGE_REGION),
                crate::shell::site_header(user)
            ))
            .with_head(format!(
                "<meta name=\"csrf-token\" content=\"{}\">{structured_data}",
                crate::helpers::escape_html(csrf)
            )),
    )
}

/// Render it.
#[must_use]
pub fn document(
    viewer: Option<&crate::auth::SessionUser>,
    csrf: Option<&str>,
    profile: &Profile<'_>,
    theme_css: &str,
) -> String {
    use quasi_axum::Serves as _;

    let screen = screen(profile, theme_css);
    renderer(viewer, csrf, &profile.structured_data()).screen(&screen)
}

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

    fn creator() -> User {
        User {
            username: "maxj".to_owned(),
            email: "max@example.com".to_owned(),
            display_name: Some("Max Johnson".to_owned()),
            bio: Some("Writes things".to_owned()),
            avatar_initials: "MJ".to_owned(),
            avatar_url: None,
            stripe_connected: false,
            stripe_account_id: None,
            stripe_onboarding_complete: false,
            stripe_payouts_enabled: false,
            stripe_charges_enabled: false,
            stripe_tax_enabled: false,
            tips_enabled: false,
        }
    }

    fn profile(user: &User) -> Profile<'_> {
        Profile {
            user,
            user_id: "u1",
            host_url: "https://makenot.work",
            custom_links: &[],
            projects: &[],
            collections: &[],
            follower_count: 0,
            is_following: false,
            is_own_profile: false,
            signed_in: false,
            paused: false,
            tips_enabled: false,
        }
    }

    fn html(profile: &Profile<'_>) -> String {
        document(None, Some("t"), profile, ":root{--x:1}")
    }

    /// The tag the template wrote by hand, said by the screen instead, and the
    /// media type off `FeedKind` rather than out of a template.
    #[test]
    fn the_feed_is_declared_once_and_spelled_by_the_vocabulary() {
        let user = creator();
        let screen = screen(&profile(&user), "");
        let feed = screen.discovery.feed.as_ref().expect("declared");
        assert_eq!(feed.href, "/u/maxj/rss");
        assert_eq!(feed.title, "Max Johnson - RSS Feed");

        let rendered = html(&profile(&user));
        assert!(
            rendered.contains(
                "<link rel=\"alternate\" type=\"application/rss+xml\" \
                 title=\"Max Johnson - RSS Feed\" href=\"/u/maxj/rss\">"
            ),
            "{rendered}"
        );
        assert_eq!(
            rendered.matches("rel=\"alternate\"").count(),
            1,
            "{rendered}"
        );
    }

    /// A reader clicks a link and a reader's app finds a tag. The template
    /// offered both and so does this.
    #[test]
    fn the_feed_is_offered_to_a_reader_as_well_as_to_their_app() {
        let user = creator();
        assert!(html(&profile(&user)).contains(">RSS Feed<"));
    }

    /// The creator's Tier 0 sheet lands after every stylesheet the shell
    /// carries, which is the property the unlayered `<style>` block held. A
    /// rule that landed before them would be overridden by the thing it exists
    /// to override.
    #[test]
    fn the_creator_theme_outranks_the_site_stylesheets() {
        let user = creator();
        let rendered = document(None, Some("t"), &profile(&user), ":root{--accent:red}");
        let theme = rendered.find(":root{--accent:red}").expect("written");
        let last_sheet = rendered.rfind("/static/style.css").expect("linked");
        assert!(theme > last_sheet, "the theme landed before style.css");
        // And outside the layer statement, which is what makes it win without
        // naming a layer.
        assert!(
            rendered.contains("<style>:root{--accent:red}</style>"),
            "{rendered}"
        );
    }

    /// The `ProfilePage` block the template opened, built from the same facts
    /// and escaped for JSON rather than for HTML.
    #[test]
    fn the_page_still_describes_itself_to_a_crawler() {
        let user = creator();
        let rendered = html(&profile(&user));
        assert!(rendered.contains("application/ld+json"), "{rendered}");
        assert!(rendered.contains("\"@type\":\"ProfilePage\""), "{rendered}");
        assert!(rendered.contains("\"name\":\"Max Johnson\""), "{rendered}");
        assert!(
            rendered.contains("\"url\":\"https://makenot.work/u/maxj\""),
            "{rendered}"
        );
    }

    /// Following is a write, so a signed-out reader gets the count and not the
    /// control, and a creator does not follow themselves.
    #[test]
    fn only_a_reader_who_could_follow_is_offered_the_control() {
        let user = creator();

        let mut signed_out = profile(&user);
        signed_out.follower_count = 4;
        let rendered = html(&signed_out);
        assert!(!rendered.contains("/api/follow/user/u1"), "{rendered}");
        assert!(rendered.contains("4 followers"), "{rendered}");

        let mut own = profile(&user);
        own.signed_in = true;
        own.is_own_profile = true;
        let rendered = html(&own);
        assert!(!rendered.contains("/api/follow/user/u1"), "{rendered}");
        assert!(rendered.contains("Edit Profile"), "{rendered}");

        let mut other = profile(&user);
        other.signed_in = true;
        let rendered = html(&other);
        assert!(rendered.contains("/api/follow/user/u1"), "{rendered}");
    }

    /// A creator with no followers is not told so on their own page.
    #[test]
    fn a_profile_with_no_followers_says_nothing_about_it() {
        let user = creator();
        assert!(!html(&profile(&user)).contains("followers"));
    }

    /// `Act::copies` is what `data-copy-link` meant, and the value is absolute:
    /// a relative path on a clipboard is not an address anybody can paste.
    #[test]
    fn the_share_control_copies_the_whole_address() {
        let user = creator();
        let rendered = html(&profile(&user));
        assert!(
            rendered.contains("data-copies=\"https://makenot.work/u/maxj\""),
            "{rendered}"
        );
    }

    /// A creator's off-site links leave the app and are expected to be come
    /// back from, which is what the template's `target="_blank"` said.
    #[test]
    fn a_custom_link_opens_away_from_the_page() {
        let user = creator();
        let links = vec![CustomLink {
            url: "https://example.com".to_owned(),
            title: "My shop".to_owned(),
            description: "Elsewhere".to_owned(),
        }];
        let mut with_links = profile(&user);
        with_links.custom_links = &links;
        let rendered = html(&with_links);
        assert!(rendered.contains("https://example.com"), "{rendered}");
        assert!(rendered.contains("target=\"_blank\""), "{rendered}");
        assert!(rendered.contains("noopener"), "{rendered}");
    }

    /// Every project and every collection keeps its row and its address.
    #[test]
    fn the_published_work_keeps_its_rows_and_its_addresses() {
        let user = creator();
        let projects = vec![Project {
            id: "p1".to_owned(),
            slug: "blue-hour".to_owned(),
            title: "Blue Hour".to_owned(),
            description: String::new(),
            item_count: 3,
            project_type: "Music".to_owned(),
            cover_image_url: None,
        }];
        let collections = vec![Collection {
            id: "c1".to_owned(),
            slug: "favourites".to_owned(),
            title: "Favourites".to_owned(),
            description: None,
            is_public: true,
            item_count: 2,
            created_at: String::new(),
        }];
        let mut full = profile(&user);
        full.projects = &projects;
        full.collections = &collections;

        let rendered = html(&full);
        assert!(rendered.contains("Blue Hour"), "{rendered}");
        assert!(rendered.contains("/p/blue-hour"), "{rendered}");
        assert!(rendered.contains("3 items"), "{rendered}");
        assert!(rendered.contains("Favourites"), "{rendered}");
        assert!(rendered.contains("/c/maxj/favourites"), "{rendered}");
    }

    /// A creator on a break says so above their work, which is where the
    /// template put it: a reader about to buy is the one who needs it.
    #[test]
    fn a_paused_creator_says_so_before_anything_they_published() {
        let user = creator();
        let mut paused = profile(&user);
        paused.paused = true;
        let rendered = html(&paused);
        let notice = rendered.find("currently on break").expect("said");
        let name = rendered.rfind("Max Johnson").expect("drawn");
        assert!(notice < name, "the notice landed under the work");
    }

    /// A creator with no bio still gets a preview sentence, which is what the
    /// template's `{% else %}` wrote.
    #[test]
    fn a_creator_with_no_bio_still_previews() {
        let mut user = creator();
        user.bio = None;
        let rendered = html(&profile(&user));
        assert!(
            rendered.contains("content=\"Creator on Makenotwork\""),
            "{rendered}"
        );
    }

    /// `736f45a5`: none of the four spellings.
    #[test]
    fn the_page_spells_no_spinner() {
        let user = creator();
        let rendered = html(&profile(&user));
        for spelling in ["htmx-indicator", "spinner", "loading-text", "loading-state"] {
            assert!(!rendered.contains(spelling), "{spelling} survives");
        }
    }
}