//! Page: home. Landing page for visitors; repo dashboard for signed-in users.
//!
//! The dashboard is a greeting, the contribution calendar, then two columns: the user's
//! repositories and the unread inbox rows that need them.

use std::time::Duration;

use forge_core::{Notification, Repo, Visibility};
use time::OffsetDateTime;
use topcoat::Result;
use topcoat::context::{Cx, app_context};
use topcoat::router::page;
use topcoat::view::{View, component, view};

use crate::auth::{current_user, percent_encode};
use crate::i18n::misc::{self as m, K as MK};
use crate::i18n::orgs::{self as g, K};
use crate::i18n::{self, Lang};
use crate::pages::issue_parts::stamp_unix;
use crate::pages::repo_settings::{notice_banner_for, take_notice};
use crate::state::AppState;
use crate::views::heatmap::{self, Calendar, contribution_calendar};
use crate::views::{display_name, now_unix, relative_time, shell};

/// How far back the calendar reads contributions: 53 weeks plus the days of the current week.
const CALENDAR_DAYS: u64 = 371;

/// Unread inbox rows in the "Needs your attention" column.
const ATTENTION_ROWS: u32 = 5;

/// What the signed-in dashboard shows, loaded once per page view.
struct Dashboard {
    name: String,
    hour: u8,
    repos: Vec<Repo>,
    calendar: Calendar,
    attention: Vec<AttentionRow>,
}

/// One unread inbox row, with its strings ready for the view.
struct AttentionRow {
    href: String,
    reference: String,
    title: String,
    kind: &'static str,
    relative: String,
}

#[page("/")]
async fn home(cx: &Cx) -> Result<impl View> {
    let state = app_context::<AppState>(cx);
    let viewer = current_user(cx).await?;
    let lang = i18n::lang(cx, viewer.as_ref().map(|(u, _)| u));
    let dash = match &viewer {
        Some((user, _)) => Some(load_dashboard(state, user, lang).await?),
        None => None,
    };
    let has_users = viewer.is_none() && state.store.user_count().await? > 0;
    let title = if viewer.is_some() {
        g::t(lang, K::Dashboard)
    } else {
        g::t(lang, K::Home)
    };
    let notice = take_notice(cx);
    Ok(view! {
        shell(title: title, viewer: viewer.as_ref(),
            notice_banner_for(lang: lang, title: notice)
            if let Some(dash) = dash {
            dashboard(dash: dash, lang: lang)
        } else {
            landing(has_users: has_users, lang: lang)
        })
    })
}

/// Reads the dashboard data for a signed-in user.
async fn load_dashboard(
    state: &AppState,
    user: &forge_core::User,
    lang: Lang,
) -> Result<Dashboard> {
    let repos = state.store.list_repos_by_owner(&user.id).await?;
    let now = OffsetDateTime::now_utc();
    let today = (
        i64::from(now.year()),
        i64::from(u8::from(now.month())),
        i64::from(now.day()),
    );
    let since = forge_core::time::stamp_ago(Duration::from_secs(CALENDAR_DAYS * 86_400));
    let counts = state.store.contribution_counts(&user.id, &since).await?;
    let calendar = heatmap::build(&counts, today);
    let now_secs = now_unix();
    let attention = state
        .store
        .list_notifications(&user.id, true, None, ATTENTION_ROWS)
        .await?
        .iter()
        .map(|note| attention_row(lang, note, now_secs))
        .collect();
    Ok(Dashboard {
        name: display_name(lang, &user.username),
        hour: now.hour(),
        repos,
        calendar,
        attention,
    })
}

#[component]
async fn landing(has_users: bool, lang: Lang) -> Result<impl View> {
    Ok(view! {
        <section class="hero">
            <h1>"forge"</h1>
            <p class="muted">(g::t(lang, K::LandingTagline))</p>
            <div class="actions">
                <a class="button primary" href="/login">(g::t(lang, K::LogIn))</a>
                if !has_users {
                    <a class="button" href="/setup">(g::t(lang, K::SetUpForge))</a>
                }
            </div>
        </section>
    })
}

#[component]
async fn dashboard(dash: Dashboard, lang: Lang) -> Result<impl View> {
    let empty = dash.repos.is_empty();
    let count = m::repositories_count(lang, dash.repos.len() as u64);
    let greeting = m::greeting(lang, dash.hour, &dash.name);
    let attention_empty = dash.attention.is_empty();
    Ok(view! {
        <h1 class="greet">(greeting)</h1>
        contribution_calendar(calendar: dash.calendar, lang: lang)
        <div class="dash-cols">
            <section class="dash-repos" aria-labelledby="repos-h">
                <div class="sec-head">
                    <h2 id="repos-h">(g::t(lang, K::YourRepositories))</h2>
                    <span class="small">(count)</span>
                    <a class="button primary" href="/new">(g::t(lang, K::NewRepository))</a>
                </div>
                if empty {
                    <p class="muted">(g::t(lang, K::NoReposYet))</p>
                } else {
                    <div class="table-wrap">
                        <table class="table">
                            <thead>
                                <tr>
                                    <th scope="col">(g::t(lang, K::Name))</th>
                                    <th scope="col" class="dash-desc">(g::t(lang, K::Description))</th>
                                </tr>
                            </thead>
                            <tbody>
                                for repo in dash.repos.into_iter() {
                                    <tr>
                                        <td>
                                            <a class="repo-name" href=(format!("/{}/{}", repo.owner_name, repo.name))>
                                                (format!("{}/{}", repo.owner_name, repo.name))
                                            </a>
                                            if repo.visibility == Visibility::Private {
                                                <span class=(badge_class(repo.visibility))>(i18n::visibility_label(lang, repo.visibility))</span>
                                            }
                                        </td>
                                        <td class="muted dash-desc">(repo.description)</td>
                                    </tr>
                                }
                            </tbody>
                        </table>
                    </div>
                }
            </section>
            <section class="dash-attention" aria-labelledby="attn-h">
                <div class="sec-head">
                    <h2 id="attn-h">(m::t(lang, MK::NeedsAttention))</h2>
                </div>
                if attention_empty {
                    <p class="muted">(m::t(lang, MK::NothingNeedsYou))</p>
                } else {
                    <ul class="attn">
                        for item in dash.attention.into_iter() {
                            <li>
                                <a href=(item.href.as_str())><span class="mono">(item.reference.as_str())</span> (item.title.as_str())</a>
                                <span class="sub">(item.kind) " · " (item.relative.as_str())</span>
                            </li>
                        }
                    </ul>
                }
                <p class="small"><a href="/notifications">(m::t(lang, MK::ViewAllNotifications))</a></p>
            </section>
        </div>
    })
}

/// The row for an unread inbox entry on the dashboard.
fn attention_row(lang: Lang, note: &Notification, now: i64) -> AttentionRow {
    let kind = match (note.is_pull, note.issue_state.as_str()) {
        (false, "open") => m::t(lang, MK::KindOpenIssue),
        (false, _) => m::t(lang, MK::KindClosedIssue),
        (true, "open") => m::t(lang, MK::KindOpenPull),
        (true, _) => m::t(lang, MK::KindClosedPull),
    };
    AttentionRow {
        href: format!("/notifications/{}/open", percent_encode(&note.id)),
        reference: format!("{}/{} #{}", note.repo_owner, note.repo_name, note.number),
        title: note.title.clone(),
        kind,
        relative: relative_time(lang, stamp_unix(&note.updated_at), now),
    }
}

/// CSS class for a visibility badge.
pub fn badge_class(visibility: Visibility) -> &'static str {
    match visibility {
        Visibility::Public => "badge public",
        Visibility::Private => "badge private",
    }
}