//! A board's Charts tab (oxygenhub#357): cumulative flow, cycle time,
//! throughput, the open iteration's burn-down, and forecasts of when the
//! remaining cards are done, all from the board's card moves
//! ([`crate::board_stats`]). Drawn as inline SVG in the hub's chart style,
//! with the numbers behind each chart in a table; the API gives the series.

use super::projects::{board_columns, rights_of, CardFilter};
use super::{Error, Page, Shell};
use crate::auth::Viewer;
use crate::board_stats::{self as bs, Move, DAY_MS, WEEK_MS};
use crate::db::{self, projects as pdb};
use crate::Shared;
use askama::Template;
use axum::extract::{Path, Query, State};
use axum::response::{IntoResponse, Response};
use serde::Deserialize;
use std::fmt::Write;

/// Days of cumulative flow drawn, and weeks of throughput a forecast
/// draws from.
pub const FLOW_DAYS: usize = 60;
pub const HISTORY_WEEKS: usize = 12;
/// Monte Carlo trials per forecast.
const TRIALS: usize = 4000;
/// The trials, for the page to say.
pub const TRIALS_SHOWN: usize = TRIALS;

const W: i64 = 640;
const H: i64 = 170;

fn day_of(ms: i64) -> String {
    let t = time::OffsetDateTime::from_unix_timestamp(ms.div_euclid(1000)).unwrap_or(time::OffsetDateTime::UNIX_EPOCH);
    format!("{:04}-{:02}-{:02}", t.year(), u8::from(t.month()), t.day())
}

fn esc(s: &str) -> String {
    s.replace('&', "&amp;").replace('<', "&lt;").replace('>', "&gt;").replace('"', "&quot;")
}

/// One forecast: what it covers, how many cards are left, and the dates
/// they are done by at 50% and 85%, or why there are none.
#[derive(Clone, Debug)]
pub struct ForecastRow {
    pub scope: String,
    pub remaining: usize,
    pub weeks_of_history: usize,
    pub p50: Option<String>,
    pub p85: Option<String>,
}

/// The open iteration's name, first day, and each day's (left, scope).
pub type Burn = (String, i64, Vec<(usize, usize)>);

/// Everything the Charts tab and the API show.
pub struct Charts {
    pub columns: Vec<String>,
    /// Cumulative flow: the first day and each day's counts per column.
    pub flow_first: i64,
    pub flow: Vec<Vec<usize>>,
    /// Cycle time of the cards finished in the last [`HISTORY_WEEKS`], in days.
    pub cycle_median_days: Option<f64>,
    pub cycle_p85_days: Option<f64>,
    pub cycle_finished: usize,
    /// Cards done in each of the last [`HISTORY_WEEKS`] weeks, and when
    /// the first of them began.
    pub throughput: Vec<usize>,
    pub throughput_from: i64,
    /// The open iteration's name, first day and its days' (left, scope).
    pub burn: Option<Burn>,
    pub forecasts: Vec<ForecastRow>,
    /// The timeline (#361): iterations as spans, and the board's milestones
    /// with their due dates and forecast spans.
    pub timeline: Vec<TimelineRow>,
}

/// A row of the timeline: an iteration's span, or a milestone's due date
/// with the span its open cards are forecast to be done in (50% to 85%).
#[derive(Clone, Debug)]
pub struct TimelineRow {
    pub name: String,
    pub milestone: bool,
    pub start: Option<i64>,
    pub end: Option<i64>,
    pub due: Option<i64>,
    pub forecast: Option<(i64, i64)>,
    pub open: bool,
}

/// The board's charts as `account` may see them; `q` narrows the
/// forecast's cards as the board's filter bar does.
pub async fn compute(
    app: &Shared,
    account: Option<&db::accounts::Account>,
    project: &pdb::Project,
    q: &str,
    now: i64,
) -> sqlx::Result<Charts> {
    let (columns, _) = board_columns(app, account, &project.owner, project, false).await?;
    let ids: Vec<i64> = columns.iter().map(|c| c.column.id).collect();
    let done = pdb::done_column(&columns.iter().map(|c| c.column.clone()).collect::<Vec<_>>());
    // Only the cards this viewer may see count: the history of the rest stays out.
    let visible: std::collections::HashSet<i64> = {
        let (archived, _) = board_columns(app, account, &project.owner, project, true).await?;
        columns.iter().chain(archived.iter()).flat_map(|c| c.cards.iter().map(|v| v.card.id)).collect()
    };
    let moves: Vec<Move> = pdb::moves(&app.db, project.id, 0)
        .await?
        .into_iter()
        .filter(|(card, _, _)| visible.contains(card))
        .map(|(card, column, at)| Move { card, column, at })
        .collect();
    let today = now - now.rem_euclid(DAY_MS);
    let flow_first = (today - (FLOW_DAYS as i64 - 1) * DAY_MS).max(project.created_ms - project.created_ms.rem_euclid(DAY_MS));
    let days = ((today - flow_first) / DAY_MS + 1) as usize;
    let flow = bs::cumulative_flow(&moves, &ids, flow_first, days);
    let (mut cycle_median_days, mut cycle_p85_days, mut cycle_finished) = (None, None, 0);
    let mut throughput = vec![0; HISTORY_WEEKS];
    if let (Some(first), Some(done)) = (ids.first().copied(), done) {
        let times = bs::cycle_times(&moves, first, done);
        cycle_finished = times.len();
        let days = |ms: i64| (ms as f64 / DAY_MS as f64 * 10.0).round() / 10.0;
        cycle_median_days = bs::percentile(&times, 50).map(days);
        cycle_p85_days = bs::percentile(&times, 85).map(days);
        throughput = bs::weekly_throughput(&moves, done, now, HISTORY_WEEKS);
    }
    // History begins with the board: fewer weeks than that are not history.
    let weeks_old = ((now - project.created_ms) / WEEK_MS).max(1) as usize;
    let history: Vec<usize> = throughput[HISTORY_WEEKS.saturating_sub(weeks_old)..].to_vec();
    let iterations = pdb::iterations(&app.db, project.id).await?;
    let open = iterations.iter().find(|i| i.closed_ms.is_none());
    let burn = match (open, done) {
        (Some(it), Some(done)) => {
            let so_far = ((now.min(it.end_ms - 1) - it.start_ms) / DAY_MS + 1).clamp(1, pdb::iteration_days(it)) as usize;
            Some((it.name.clone(), it.start_ms, bs::burn_down(&moves, done, it.start_ms, so_far)))
        }
        _ => None,
    };
    // Forecasts: the open iteration's (or the whole board's) open cards,
    // each milestone's, and the filter's when one is given.
    let filter = CardFilter::parse(q);
    let open_cards: Vec<&super::projects::CardView> = columns
        .iter()
        .filter(|c| Some(c.column.id) != done)
        .flat_map(|c| c.cards.iter())
        .filter(|c| !matches!(c.state.as_str(), "closed" | "landed"))
        .collect();
    let seed = (project.id as u64).wrapping_mul(0x9E37_79B9_7F4A_7C15) ^ (today / DAY_MS) as u64;
    let row = |scope: String, remaining: usize| {
        let f = bs::forecast(&history, remaining, TRIALS, seed);
        let date = |w: Option<usize>| w.map(|w| day_of(now + w as i64 * WEEK_MS));
        ForecastRow { scope, remaining, weeks_of_history: f.weeks_of_history, p50: date(f.p50_weeks), p85: date(f.p85_weeks) }
    };
    let mut forecasts = Vec::new();
    let mut timeline: Vec<TimelineRow> = iterations
        .iter()
        .take(6)
        .rev()
        .map(|it| TimelineRow {
            name: it.name.clone(),
            milestone: false,
            start: Some(it.start_ms),
            end: Some(it.end_ms),
            due: None,
            forecast: None,
            open: it.closed_ms.is_none(),
        })
        .collect();
    if !q.trim().is_empty() {
        forecasts.push(row(format!("Cards matching {}", q.trim()), open_cards.iter().filter(|c| filter.keeps(c, now)).count()));
    }
    let scope = match open {
        Some(it) => format!("{} (open cards on the board)", it.name),
        None => "Open cards on the board".to_string(),
    };
    forecasts.push(row(scope, open_cards.len()));
    let mut milestones: Vec<String> = open_cards.iter().map(|c| c.milestone.clone()).filter(|m| !m.is_empty()).collect();
    milestones.sort();
    milestones.dedup();
    // Milestones' due dates, from the repositories of the cards that name them.
    let mut due: std::collections::HashMap<String, i64> = Default::default();
    let mut repos: Vec<i64> = open_cards.iter().filter(|c| !c.milestone.is_empty()).filter_map(|c| c.card.repo_id).collect();
    repos.sort();
    repos.dedup();
    for rid in repos {
        for ms in db::issues::milestones(&app.db, rid).await? {
            if let Some(d) = ms.due_ms {
                due.entry(ms.title).and_modify(|e| *e = (*e).min(d)).or_insert(d);
            }
        }
    }
    for m in milestones {
        let n = open_cards.iter().filter(|c| c.milestone == m).count();
        let f = bs::forecast(&history, n, TRIALS, seed);
        let at = |w: Option<usize>| w.map(|w| now + w as i64 * WEEK_MS);
        timeline.push(TimelineRow {
            name: m.clone(),
            milestone: true,
            start: None,
            end: None,
            due: due.get(&m).copied(),
            forecast: at(f.p50_weeks).zip(at(f.p85_weeks)),
            open: true,
        });
        forecasts.push(row(format!("Milestone {m}"), n));
    }
    Ok(Charts {
        columns: columns.iter().map(|c| c.column.name.clone()).collect(),
        flow_first,
        flow,
        cycle_median_days,
        cycle_p85_days,
        cycle_finished,
        throughput,
        throughput_from: now - HISTORY_WEEKS as i64 * WEEK_MS,
        burn,
        forecasts,
        timeline,
    })
}

/// The timeline as SVG: a row per iteration (its span) and per milestone
/// (its due date as a mark, its forecast as a band), today as a line.
pub fn timeline_svg(rows: &[TimelineRow], now: i64) -> String {
    let times: Vec<i64> = rows
        .iter()
        .flat_map(|r| [r.start, r.end, r.due, r.forecast.map(|f| f.0), r.forecast.map(|f| f.1)])
        .flatten()
        .chain([now - 14 * DAY_MS, now + 14 * DAY_MS])
        .collect();
    let (lo, hi) = (*times.iter().min().unwrap_or(&now), *times.iter().max().unwrap_or(&now));
    let span = (hi - lo).max(DAY_MS) as f64;
    const LABEL: f64 = 150.0;
    let x = |t: i64| LABEL + (t - lo) as f64 / span * (W as f64 - LABEL - 4.0);
    let row_h = 22.0;
    let h = rows.len() as f64 * row_h + 22.0;
    let mut out = format!(
        r#"<svg class="chart timeline" viewBox="0 0 {W} {h:.0}" role="img" aria-label="Timeline: {} iterations and milestones from {} to {}">"#,
        rows.len(),
        day_of(lo),
        day_of(hi)
    );
    for (i, r) in rows.iter().enumerate() {
        let y = i as f64 * row_h + 4.0;
        let _ = write!(out, r#"<text class="axis" x="0" y="{:.1}">{}</text>"#, y + 13.0, esc(&r.name.chars().take(22).collect::<String>()));
        if let (Some(a), Some(b)) = (r.start, r.end) {
            let class = if r.open { "s-main" } else { "s-mute" };
            let _ = write!(
                out,
                r#"<rect class="bar {class}" x="{:.1}" y="{:.1}" width="{:.1}" height="12"><title>{}: {} to {}</title></rect>"#,
                x(a),
                y + 3.0,
                (x(b) - x(a)).max(2.0),
                esc(&r.name),
                day_of(a),
                day_of(b - 1)
            );
        }
        if let Some((a, b)) = r.forecast {
            let _ = write!(
                out,
                r#"<rect class="bar s-warn forecast" x="{:.1}" y="{:.1}" width="{:.1}" height="12"><title>{}: done 50% by {}, 85% by {}</title></rect>"#,
                x(a),
                y + 3.0,
                (x(b) - x(a)).max(3.0),
                esc(&r.name),
                day_of(a),
                day_of(b)
            );
        }
        if let Some(d) = r.due {
            let _ = write!(
                out,
                r#"<path class="line s-bad" d="M{0:.1},{1:.1} l5,7 l-5,7 l-5,-7 z"><title>{2} due {3}</title></path>"#,
                x(d),
                y + 2.0,
                esc(&r.name),
                day_of(d)
            );
        }
    }
    let _ = write!(out, r#"<line class="grid today" x1="{0:.1}" x2="{0:.1}" y1="0" y2="{1:.0}"/>"#, x(now), h - 18.0);
    let _ = write!(out, r#"<text class="axis" x="{LABEL}" y="{:.0}">{}</text>"#, h - 4.0, day_of(lo));
    let _ = write!(out, r#"<text class="axis" x="{:.1}" y="{:.0}" text-anchor="middle">today</text>"#, x(now), h - 4.0);
    let _ = write!(out, r#"<text class="axis" x="{W}" y="{:.0}" text-anchor="end">{}</text></svg>"#, h - 4.0, day_of(hi));
    out
}

/// Cumulative flow as stacked bands, the board's first column on top.
fn flow_svg(c: &Charts) -> String {
    let bands = bs::flow_bands(&c.flow, W, H);
    let mut out = format!(
        r#"<svg class="chart flow" viewBox="0 0 {W} {}" role="img" aria-label="Cumulative flow: cards per column each day for {} days">"#,
        H + 18,
        c.flow.len()
    );
    for (k, pts) in bands.iter().enumerate() {
        let class = if k + 1 == bands.len() { 5 } else { k % 5 };
        let _ = write!(out, r#"<polygon class="band cf-{class}" points="{pts}"><title>{}</title></polygon>"#, esc(&c.columns[k]));
    }
    let _ = write!(out, r#"<text class="axis" x="0" y="{}">{}</text>"#, H + 14, day_of(c.flow_first));
    let _ = write!(out, r#"<text class="axis" x="{W}" y="{}" text-anchor="end">today</text></svg>"#, H + 14);
    out
}

/// Bars, one per week.
fn bars_svg(values: &[usize], label: &str) -> String {
    let max = values.iter().copied().max().unwrap_or(0).max(1);
    let step = W as f64 / values.len().max(1) as f64;
    let mut out = format!(r#"<svg class="chart" viewBox="0 0 {W} {}" role="img" aria-label="{}">"#, H + 18, esc(label));
    for (i, v) in values.iter().enumerate() {
        let h = (*v as f64 / max as f64) * H as f64;
        let _ = write!(
            out,
            r#"<rect class="bar s-ok" x="{:.1}" y="{:.1}" width="{:.1}" height="{h:.1}"><title>{v} done</title></rect>"#,
            i as f64 * step + step * 0.15,
            H as f64 - h,
            step * 0.7
        );
    }
    let _ = write!(out, r#"<text class="axis" x="0" y="{}">{} weeks ago</text>"#, H + 14, values.len());
    let _ = write!(out, r#"<text class="axis" x="{W}" y="{}" text-anchor="end">this week</text></svg>"#, H + 14);
    out
}

/// The burn-down: cards left, and the scope above it.
fn burn_svg(days: &[(usize, usize)]) -> String {
    let max = days.iter().map(|(_, s)| *s).max().unwrap_or(0).max(1);
    let left: Vec<usize> = days.iter().map(|(l, _)| *l).collect();
    let scope: Vec<usize> = days.iter().map(|(_, s)| *s).collect();
    format!(
        r#"<svg class="chart" viewBox="0 0 {W} {H}" role="img" aria-label="Burn-down: {} cards left of {} after {} days"><polyline class="line s-mute" points="{}"><title>scope</title></polyline><polyline class="line s-main" points="{}"><title>left</title></polyline></svg>"#,
        left.last().unwrap_or(&0),
        scope.last().unwrap_or(&0),
        days.len(),
        bs::polyline(&scope, max, W, H),
        bs::polyline(&left, max, W, H)
    )
}

#[derive(Template)]
#[template(path = "project_charts.html")]
pub struct ChartsPage {
    shell: Shell,
    project: pdb::Project,
    views: Vec<pdb::View>,
    c: Charts,
    flow_svg: String,
    throughput_svg: String,
    burn_svg: String,
    timeline_svg: String,
    /// The last fortnight of cumulative flow, for its table: day and counts.
    flow_table: Vec<(String, Vec<usize>)>,
    week_table: Vec<(String, usize)>,
    q: String,
}

#[derive(Deserialize, Default)]
pub struct ChartsQuery {
    #[serde(default)]
    q: Option<String>,
}

pub async fn show(
    State(app): State<Shared>,
    viewer: Viewer,
    Path((owner, number)): Path<(String, i64)>,
    Query(query): Query<ChartsQuery>,
) -> Result<Response, Error> {
    let shell = Shell::new(&app, &format!("/projects/{owner}/{number}/charts"), &viewer);
    let e = |e| Error::from_db(shell.clone(), e);
    let r = rights_of(&app, viewer.account(), &owner).await.map_err(e)?.ok_or_else(|| Error::not_found(shell.clone()))?;
    let project = pdb::get(&app.db, &owner, number)
        .await
        .map_err(e)?
        .filter(|p| p.public || r.member)
        .ok_or_else(|| Error::not_found(shell.clone()))?;
    let now = db::now_ms();
    let q = query.q.unwrap_or_default();
    let c = compute(&app, viewer.account(), &project, &q, now).await.map_err(e)?;
    let flow_table = c
        .flow
        .iter()
        .enumerate()
        .skip(c.flow.len().saturating_sub(14))
        .map(|(d, row)| (day_of(c.flow_first + d as i64 * DAY_MS), row.clone()))
        .collect();
    let week_table = c.throughput.iter().enumerate().map(|(i, n)| (day_of(c.throughput_from + i as i64 * WEEK_MS), *n)).collect();
    let page = ChartsPage {
        flow_svg: flow_svg(&c),
        throughput_svg: bars_svg(&c.throughput, "Throughput: cards done each week"),
        burn_svg: c.burn.as_ref().map(|(_, _, d)| burn_svg(d)).unwrap_or_default(),
        timeline_svg: if c.timeline.is_empty() { String::new() } else { timeline_svg(&c.timeline, now) },
        views: pdb::views(&app.db, project.id).await.map_err(e)?,
        shell,
        project,
        c,
        flow_table,
        week_table,
        q,
    };
    Ok(Page(page).into_response())
}

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

    #[test]
    fn the_timeline_draws_iterations_milestones_and_forecasts() {
        let now = 1_000 * DAY_MS;
        let rows = vec![
            TimelineRow {
                name: "Sprint 1".into(),
                milestone: false,
                start: Some(now - 20 * DAY_MS),
                end: Some(now - 6 * DAY_MS),
                due: None,
                forecast: None,
                open: false,
            },
            TimelineRow {
                name: "Sprint 2".into(),
                milestone: false,
                start: Some(now - 6 * DAY_MS),
                end: Some(now + 8 * DAY_MS),
                due: None,
                forecast: None,
                open: true,
            },
            TimelineRow {
                name: "Release <1>".into(),
                milestone: true,
                start: None,
                end: None,
                due: Some(now + 10 * DAY_MS),
                forecast: Some((now + 7 * DAY_MS, now + 21 * DAY_MS)),
                open: true,
            },
        ];
        let svg = timeline_svg(&rows, now);
        assert!(svg.starts_with("<svg class=\"chart timeline\"") && svg.ends_with("</svg>"));
        assert_eq!(svg.matches("class=\"bar s-mute\"").count(), 1, "a past iteration");
        assert_eq!(svg.matches("class=\"bar s-main\"").count(), 1, "the open one");
        assert!(svg.contains("Release &lt;1&gt;: done 50% by") && svg.contains("class=\"line s-bad\""), "{svg}");
        assert!(svg.contains("aria-label=\"Timeline: 3 iterations and milestones"), "named for a screen reader");
        assert!(!svg.contains("style="), "coloured by the theme's classes only");
    }
}