//! 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_declare::declare;
use quasi_router::{Document, Feed, FeedKind};
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)
    }

    /// Whether the creator has written anything about themselves.
    ///
    /// A predicate rather than an `Option` the description reaches into, which
    /// is the call `super::embeds::ItemView::has_cover` records: the form has
    /// no binding pattern, and whitespace is not a bio.
    fn has_bio(&self) -> bool {
        !self.bio().trim().is_empty()
    }

    /// What they wrote, or nothing. R9: the paragraph is built whether or not
    /// [`Self::has_bio`] places it.
    fn bio(&self) -> &str {
        self.user.bio.as_deref().unwrap_or_default()
    }

    /// Whether this reader is offered the follow control.
    ///
    /// Following is a write, so it needs a session, and a creator does not
    /// follow themselves. Both were the template's conditions, and the count
    /// stands in where the control does not.
    fn can_follow(&self) -> bool {
        self.signed_in && !self.is_own_profile
    }

    /// What a tip on this page is about.
    ///
    /// A method rather than the literal the caller used to write inline: a
    /// `Type { .. }` aggregate is the form's hard limit, and the offer is a
    /// fact about the profile anyway.
    fn tip_offer(&self) -> super::tip::Offer<'_> {
        super::tip::Offer {
            creator_id: self.user_id,
            project_id: None,
            signed_in: self.signed_in,
        }
    }

    /// 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>")
    }
}

declare! {
    /// The whole document.
    ///
    /// The creator's Tier 0 sheet rides on `styled`, written last in the head
    /// and outside the layer statement, which is the property the hand-written
    /// `<style id="creator-theme">` block existed to hold.
    #[must_use]
    pub shape screen(profile: &Profile<'_>, theme_css: &str) -> Screen;

    let name = profile.user.display_name_or_username();
    let feed = feed_path(&profile.user.username);

    screen single "{name} - Makenotwork" {
        measured MEASURE;
        documented Document::default()
            .classed(crate::shell::body_class(MEASURE, &["user-page"]))
            .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, "{name} - RSS Feed", feed);

        region PAGE_REGION as Pane {
            // A creator on a break, said before anything they published: a
            // reader about to buy is the one who needs it.
            banner layout::Tone::Info
                "This creator is currently on break. Existing purchases remain accessible."
                when profile.paused;

            page name;
            text profile.user.username.clone();
            text profile.bio() when profile.has_bio();

            act "Edit Profile" to get "/dashboard?tab=settings" navigating
                when profile.is_own_profile;

            include super::follow::control(
                "user",
                profile.user_id,
                profile.is_following,
                profile.follower_count
            ) when profile.can_follow();
            // An `-> Option<_>` shape is placed with a loop, because an
            // `Option` is an iterator of at most one. `.into_iter()` is a
            // method step the hole grammar already admits, and it is what says
            // at-most-one was meant rather than a fallible iterated by
            // accident. The guard is the other half of the control's: a reader
            // offered the control is not also told the count.
            for counted in super::follow::count_only(profile.follower_count).into_iter() {
                include counted unless profile.can_follow();
            }

            include super::tip::control(&profile.tip_offer()) when profile.tips_enabled;

            act "RSS Feed" to get feed.clone() navigating;
            // Already sayable: `copying` 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.
            act "Copy link" to local {
                copying profile.canonical();
            }

            list {
                for link in profile.custom_links.iter() {
                    row 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 to external link.url.clone();
                    }
                }
            } unless profile.custom_links.is_empty();

            section "Projects" unless profile.projects.is_empty();
            list {
                for project in profile.projects.iter() {
                    row project.title.clone() {
                        meta "{project.project_type} - {project.item_count} items";
                        activate to get "/p/{project.slug}" navigating;
                    }
                }
            } unless profile.projects.is_empty();

            section "Collections" unless profile.collections.is_empty();
            list {
                for collection in profile.collections.iter() {
                    row collection.title.clone() {
                        meta "{collection.item_count} items";
                        activate to get
                            "/c/{profile.user.username}/{collection.slug}" navigating;
                    }
                }
            } unless profile.collections.is_empty();

            // 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.
            link "Powered by Makenot.work" to get "/" navigating;
        }
    }
}

/// 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");
        }
    }
}