//! Page: public profile at `/{username}`. Avatar, about (rendered markdown), local time and the
//! repositories the viewer is allowed to read. Fixed single-segment routes are registered
//! statically, so they win over this parameter route.

use forge_core::authz::{Action, authorize};
use forge_core::tz::local_time_now;
use forge_core::{Repo, User};
use topcoat::Result;
use topcoat::context::{Cx, app_context};
use topcoat::router::error::not_found;
use topcoat::router::{page, path_param};
use topcoat::view::{Unescaped, View, component, view};

use crate::auth::current_user;
use crate::i18n::orgs::{self as g, K};
use crate::i18n::{self, Lang};
use crate::pages::dashboard::badge_class;
use crate::render::markdown::render_markdown;
use crate::state::AppState;
use crate::views::{avatar_url, now_unix, repo_href, shell};

path_param!(username);

#[page("/{username}")]
async fn profile_page(cx: &Cx) -> Result<impl View> {
    let name = path_param::<Username>(cx);
    let state = app_context::<AppState>(cx);
    let viewer = current_user(cx).await?;

    let Some(user) = state.store.user_by_username(name).await? else {
        return Err(not_found().into());
    };
    let avatar = state.store.avatar_hash(&user.id).await?;
    let about = user.about.trim();
    let about_html = if about.is_empty() {
        String::new()
    } else {
        render_markdown(about, None)
    };
    let local_time = local_time_now(&user.timezone, now_unix());

    let actor = viewer.as_ref().map(|(u, _)| u);
    let mut repos = Vec::new();
    for repo in state.store.list_repos_by_owner(&user.id).await? {
        let (role, org_role) = match actor {
            Some(u) => (
                state.store.collaborator_role(&repo.id, &u.id).await?,
                state
                    .store
                    .org_repo_role(&repo.owner_id, &u.id, &repo.id)
                    .await?,
            ),
            None => (None, None),
        };
        if authorize(actor, &repo, role, org_role, Action::Read).is_ok() {
            repos.push(repo);
        }
    }

    // Starred repos are the user's bookmarks; only the ones the viewer may read are shown.
    let mut starred = Vec::new();
    for repo in state.store.starred_repos(&user.id).await? {
        let (role, org_role) = match actor {
            Some(u) => (
                state.store.collaborator_role(&repo.id, &u.id).await?,
                state
                    .store
                    .org_repo_role(&repo.owner_id, &u.id, &repo.id)
                    .await?,
            ),
            None => (None, None),
        };
        if authorize(actor, &repo, role, org_role, Action::Read).is_ok() {
            starred.push(repo);
        }
    }

    // An organization shows its members and how many teams it has. Its `about` is its description.
    let org = if user.is_org() {
        let members = state.store.org_members(&user.id).await?;
        let teams = state.store.teams_for_org(&user.id).await?.len();
        Some(OrgSummary {
            members: members
                .into_iter()
                .map(|(member, _)| member.username)
                .collect(),
            teams,
        })
    } else {
        None
    };

    let title = user.username.clone();
    let lang = i18n::lang(cx, viewer.as_ref().map(|(u, _)| u));
    Ok(view! { cx =>
        shell(title: title.as_str(), viewer: viewer.as_ref(),
            profile_card(user: user, avatar: avatar, about_html: about_html, local_time: local_time, repos: repos, starred: starred, org: org, lang: lang))
    })
}

/// What an organization's profile adds: its member names and its team count.
struct OrgSummary {
    members: Vec<String>,
    teams: usize,
}

#[component]
async fn profile_card(
    user: User,
    avatar: Option<String>,
    about_html: String,
    local_time: String,
    repos: Vec<Repo>,
    starred: Vec<Repo>,
    org: Option<OrgSummary>,
    lang: Lang,
) -> Result<impl View> {
    let src = avatar_url(&user.username, avatar.as_deref());
    let has_about = !about_html.is_empty();
    let no_repos = repos.is_empty();
    let no_starred = starred.is_empty();
    let is_org = user.is_org();
    let members_href = format!("/org/{}/members", user.username);
    let teams_href = format!("/org/{}/teams", user.username);
    Ok(view! {
        <article class="profile-page">
            <header class="profile-head">
                <img class="profile-avatar" src=(src) alt="" width="256" height="256">
                <div class="profile-id">
                    <h1>(user.username.as_str())</h1>
                    if is_org {
                        <p class="muted small">(g::t(lang, K::Organization))</p>
                    }
                    <p class="muted">(g::t(lang, K::LocalTime)) (local_time.as_str())</p>
                </div>
            </header>
            if has_about {
                <section class="profile-about markdown-body">(Unescaped::new_unchecked(about_html))</section>
            }
            if let Some(summary) = org {
                <section class="profile-org">
                    <h2>(g::t(lang, K::Members))</h2>
                    <p class="muted small">
                        (g::members_and_teams(lang, summary.members.len(), summary.teams))
                        " \u{b7} "
                        <a href=(members_href.as_str())>(g::t(lang, K::AllMembers))</a>
                        " \u{b7} "
                        <a href=(teams_href.as_str())>(g::t(lang, K::Teams))</a>
                    </p>
                    if summary.members.is_empty() {
                        <p class="muted">(g::t(lang, K::NoMembers))</p>
                    } else {
                        <ul class="item-list">
                            for name in summary.members.iter() {
                                <li><a href=(format!("/{}", name.as_str()))>(name.as_str())</a></li>
                            }
                        </ul>
                    }
                </section>
            }
            <section class="profile-repos">
                <h2>(g::t(lang, K::Repositories))</h2>
                if no_repos {
                    <p class="muted">(g::t(lang, K::NoVisibleRepos))</p>
                } else {
                    <ul class="repo-list">
                        for repo in repos.into_iter() {
                            <li class="repo-item">
                                <a class="repo-name" href=(repo_href(&repo.owner_name, &repo.name, "", ""))>
                                    (format!("{}/{}", repo.owner_name, repo.name))
                                </a>
                                <span class=(badge_class(repo.visibility))>(i18n::visibility_label(lang, repo.visibility))</span>
                                if !repo.description.is_empty() {
                                    <p class="muted">(repo.description.as_str())</p>
                                }
                            </li>
                        }
                    </ul>
                }
            </section>
            <section class="profile-starred">
                <h2>(g::t(lang, K::Starred))</h2>
                if no_starred {
                    <p class="muted">(g::t(lang, K::NoVisibleStarred))</p>
                } else {
                    <ul class="repo-list">
                        for repo in starred.into_iter() {
                            <li class="repo-item">
                                <a class="repo-name" href=(repo_href(&repo.owner_name, &repo.name, "", ""))>
                                    (format!("{}/{}", repo.owner_name, repo.name))
                                </a>
                                <span class=(badge_class(repo.visibility))>(i18n::visibility_label(lang, repo.visibility))</span>
                                if !repo.description.is_empty() {
                                    <p class="muted">(repo.description.as_str())</p>
                                }
                            </li>
                        }
                    </ul>
                }
            </section>
        </article>
    })
}

#[cfg(test)]
mod tests {

    use forge_core::{Role, Store, Visibility};

    use topcoat::router::request::Request;
    use topcoat::router::{Body, Router, to_bytes};

    use crate::auth::SESSION_COOKIE;

    const CSRF: &str = "profile-test-csrf";

    struct Site {
        router: Router,
        store: Store,
        _dir: tempfile::TempDir,
    }

    async fn site() -> Site {
        let dir = tempfile::tempdir().expect("tempdir");
        let path = dir.path().to_path_buf();
        let state = crate::test_support::test_state(&path).await;
        let store = state.store.clone();
        let router = crate::test_support::app_router(state);
        Site {
            router,
            store,
            _dir: dir,
        }
    }

    /// Creates a session for `user_id` and returns the cookie header value.
    async fn sign_in(store: &Store, user_id: &str, token: &str) -> String {
        crate::test_support::create_session(store, user_id, token, CSRF).await;
        format!("__Host-{SESSION_COOKIE}={token}")
    }

    async fn get(router: &Router, uri: &str, cookie: Option<&str>) -> (u16, String) {
        let mut builder = Request::builder().method("GET").uri(uri);
        if let Some(cookie) = cookie {
            builder = builder.header("cookie", cookie);
        }
        let res = router.handle(builder.body(Body::empty()).unwrap()).await;
        let status = res.status().as_u16();
        let bytes = to_bytes(res.into_body(), usize::MAX).await.unwrap();
        (status, String::from_utf8_lossy(&bytes).into_owned())
    }

    /// Alice has a public repo, a private repo and a private repo that carol collaborates on.
    async fn seeded() -> Site {
        let site = site().await;
        let alice = site
            .store
            .create_user("alice", None, "not-a-real-hash", false)
            .await
            .unwrap();
        site.store
            .set_profile(
                &alice.id,
                "# Hello heading\n\n<script>alert(1)</script>\n\nSome **bold** text",
                "UTC",
            )
            .await
            .unwrap();
        site.store
            .create_repo(&alice.id, "open-repo", "", Visibility::Public, "main")
            .await
            .unwrap();
        site.store
            .create_repo(&alice.id, "secret-repo", "", Visibility::Private, "main")
            .await
            .unwrap();
        let shared = site
            .store
            .create_repo(&alice.id, "shared-repo", "", Visibility::Private, "main")
            .await
            .unwrap();
        let carol = site
            .store
            .create_user("carol", None, "not-a-real-hash", false)
            .await
            .unwrap();
        site.store
            .set_collaborator(&shared.id, &carol.id, Role::Read)
            .await
            .unwrap();
        site
    }

    #[tokio::test]
    async fn about_is_rendered_and_sanitized() {
        let site = seeded().await;
        let (status, body) = get(&site.router, "/alice", None).await;
        assert_eq!(status, 200);
        assert!(body.contains("<h1"), "heading rendered: {body}");
        assert!(body.contains("Hello heading"));
        assert!(body.contains("<strong>bold</strong>"));
        assert!(!body.contains("<script>"), "script stripped: {body}");
        assert!(!body.contains("alert(1)"));
    }

    #[tokio::test]
    async fn anonymous_and_other_users_see_only_public_repos() {
        let site = seeded().await;
        let (_, anon) = get(&site.router, "/alice", None).await;
        assert!(anon.contains("alice/open-repo"));
        assert!(!anon.contains("alice/secret-repo"));
        assert!(!anon.contains("alice/shared-repo"));

        let bob = site
            .store
            .create_user("bob", None, "not-a-real-hash", false)
            .await
            .unwrap();
        let cookie = sign_in(&site.store, &bob.id, "bob-token").await;
        let (_, other) = get(&site.router, "/alice", Some(&cookie)).await;
        assert!(other.contains("alice/open-repo"));
        assert!(!other.contains("alice/secret-repo"));
        assert!(!other.contains("alice/shared-repo"));
    }

    #[tokio::test]
    async fn owner_sees_private_and_collaborator_sees_their_repo() {
        let site = seeded().await;
        let alice = site.store.user_by_username("alice").await.unwrap().unwrap();
        let cookie = sign_in(&site.store, &alice.id, "alice-token").await;
        let (_, body) = get(&site.router, "/alice", Some(&cookie)).await;
        assert!(body.contains("alice/secret-repo"));
        assert!(body.contains("alice/shared-repo"));

        let carol = site.store.user_by_username("carol").await.unwrap().unwrap();
        let cookie = sign_in(&site.store, &carol.id, "carol-token").await;
        let (_, body) = get(&site.router, "/alice", Some(&cookie)).await;
        assert!(body.contains("alice/shared-repo"));
        assert!(!body.contains("alice/secret-repo"));
    }

    #[tokio::test]
    async fn unknown_user_is_404_and_lookup_is_case_insensitive() {
        let site = seeded().await;
        let (status, _) = get(&site.router, "/nobody-here", None).await;
        assert_eq!(status, 404);
        let (status, body) = get(&site.router, "/ALICE", None).await;
        assert_eq!(status, 200);
        assert!(body.contains("alice"));
    }

    #[tokio::test]
    async fn fixed_routes_are_not_shadowed_by_the_profile() {
        let site = seeded().await;
        for uri in [
            "/new",
            "/login",
            "/logout",
            "/setup",
            "/healthz",
            "/settings/profile",
            "/settings/keys",
            "/admin/users",
            "/assets/main.css",
            "/avatars/alice",
        ] {
            let (_, body) = get(&site.router, uri, None).await;
            assert!(
                !body.contains("<article class=\"profile-page\""),
                "{uri} was served by the profile page"
            );
        }
        // The fixed login page still renders its form, not a profile.
        let (status, body) = get(&site.router, "/login", None).await;
        assert_eq!(status, 200);
        assert!(body.contains("<form"));
        // Two-segment repo routes keep working and still 404 for a missing repo.
        let (status, body) = get(&site.router, "/alice/missing", None).await;
        assert_eq!(status, 404);
        assert!(!body.contains("<article class=\"profile-page\""));
    }
}