//! The Flow tab (hub spec §13.2): runs of a repository, and a run's job

//! graph with live status and logs.

use super::{filters, lookup, Error, Page, RepoShell, Shell};

use crate::auth::Viewer;

use crate::db::{self, flow as fdb};

use crate::Shared;

use askama::Template;

use axum::extract::{Path, Query, State};

use axum::response::{IntoResponse, Response};

use axum::Json;

use serde::Deserialize;

pub struct RunRow {

    pub r: fdb::Run,

    pub duration: String,

    pub jobs: Vec<(String, String)>,

}

#[derive(Template)]

#[template(path = "flow_runs.html")]

pub struct RunsPage {

    shell: Shell,

    repo: RepoShell,

    runs: Vec<RunRow>,

    enabled: bool,

    older: Option<i64>,

}

#[derive(Deserialize)]

pub struct RunsQuery {

    before: Option<i64>,

}

const PER_PAGE: i64 = 30;

pub async fn runs(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name)): Path<(String, String)>,

    Query(q): Query<RunsQuery>,

) -> Result<Page<RunsPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/flow"), &viewer);

    let (_repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let list = fdb::runs(&app.db, row.id, PER_PAGE + 1, q.before).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let older = (list.len() as i64 > PER_PAGE).then(|| list[PER_PAGE as usize - 1].id);

    let mut runs = Vec::new();

    for r in list.into_iter().take(PER_PAGE as usize) {

        let jobs = fdb::jobs(&app.db, r.id).await.unwrap_or_default();

        let duration = match r.finished_ms {

            Some(f) => crate::flow::human_ms(f - r.created_ms),

            None if r.live() => crate::flow::human_ms(db::now_ms() - r.created_ms),

            None => "–".into(),

        };

        runs.push(RunRow { jobs: jobs.into_iter().map(|j| (j.name, j.status)).collect(), duration, r });

    }

    let enabled = crate::flow::enabled(&app, &row);

    Ok(Page(RunsPage { shell, repo: RepoShell::new(&app, &row, "flow").with_role(role), runs, enabled, older }))

}

/// A job placed in the graph.

pub struct Node {

    pub j: fdb::Job,

    pub x: i64,

    pub y: i64,

    pub duration: String,

}

pub struct Edge {

    pub d: String,

    pub status: String,

}

pub struct Graph {

    pub nodes: Vec<Node>,

    pub edges: Vec<Edge>,

    pub width: i64,

    pub height: i64,

}

pub const NODE_W: i64 = 200;

pub const NODE_H: i64 = 48;

const COL_GAP: i64 = 72;

const ROW_GAP: i64 = 18;

const PAD: i64 = 12;

/// Columns by dependency depth, jobs in each column in name order.

pub fn layout(jobs: Vec<fdb::Job>) -> Graph {

    let mut by_depth: std::collections::BTreeMap<i64, Vec<fdb::Job>> = Default::default();

    for j in jobs {

        by_depth.entry(j.depth).or_default().push(j);

    }

    let rows = by_depth.values().map(Vec::len).max().unwrap_or(0) as i64;

    let height = PAD * 2 + rows * NODE_H + (rows - 1).max(0) * ROW_GAP;

    let mut nodes = Vec::new();

    for (col, (_, mut js)) in by_depth.into_iter().enumerate() {

        js.sort_by(|a, b| a.name.cmp(&b.name));

        let n = js.len() as i64;

        let column_h = n * NODE_H + (n - 1).max(0) * ROW_GAP;

        let top = (height - column_h) / 2;

        for (i, j) in js.into_iter().enumerate() {

            let duration = crate::flow::duration(&j);

            nodes.push(Node { x: PAD + col as i64 * (NODE_W + COL_GAP), y: top + i as i64 * (NODE_H + ROW_GAP), duration, j });

        }

    }

    let mut edges = Vec::new();

    for n in &nodes {

        for d in n.j.depends_on() {

            if let Some(from) = nodes.iter().find(|m| m.j.name == d) {

                let (x1, y1) = (from.x + NODE_W, from.y + NODE_H / 2);

                let (x2, y2) = (n.x, n.y + NODE_H / 2);

                let mid = (x1 + x2) / 2;

                edges.push(Edge { d: format!("M{x1},{y1} C{mid},{y1} {mid},{y2} {x2},{y2}"), status: from.j.status.clone() });

            }

        }

    }

    let cols = nodes.iter().map(|n| n.x).max().map(|x| x + NODE_W + PAD).unwrap_or(PAD * 2);

    Graph { nodes, edges, width: cols, height: height.max(NODE_H + PAD * 2) }

}

pub fn glyph(status: &str) -> &'static str {

    match status {

        "passed" => "✓",

        "failed" => "✕",

        "running" => "●",

        "skipped" => "⤼",

        "error" => "!",

        _ => "○",

    }

}

pub struct JobLog {

    pub j: fdb::Job,

    pub lines: Vec<fdb::LogLine>,

    pub duration: String,

    /// The last line shown; the live view asks for what follows.

    pub last_seq: i64,

}

#[derive(Template)]

#[template(path = "flow_run.html")]

pub struct RunPage {

    shell: Shell,

    repo: RepoShell,

    run: fdb::Run,

    graph: Graph,

    logs: Vec<JobLog>,

    duration: String,

}

/// Lines of a job's log a page shows before "the rest is loaded as it comes".

const PAGE_LINES: i64 = 5000;

pub async fn run(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, id)): Path<(String, String, i64)>,

) -> Result<Page<RunPage>, Error> {

    let shell = Shell::new(&app, &format!("/{owner}/{name}/flow/{id}"), &viewer);

    let (_repo, row, role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let run = fdb::run(&app.db, row.id, id)

        .await

        .map_err(|e| Error::from_db(shell.clone(), e))?

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    let jobs = fdb::jobs(&app.db, run.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let mut logs = Vec::new();

    for j in &jobs {

        let lines = fdb::log(&app.db, j.id, 0, PAGE_LINES).await.unwrap_or_default();

        let last_seq = lines.last().map(|l| l.seq).unwrap_or(0);

        logs.push(JobLog { duration: crate::flow::duration(j), j: j.clone(), lines, last_seq });

    }

    let duration = match run.finished_ms {

        Some(f) => crate::flow::human_ms(f - run.created_ms),

        None => crate::flow::human_ms(db::now_ms() - run.created_ms),

    };

    let graph = layout(jobs);

    Ok(Page(RunPage { shell, repo: RepoShell::new(&app, &row, "flow").with_role(role), run, graph, logs, duration }))

}

#[derive(Deserialize)]

pub struct LiveQuery {

    /// `job:seq,job:seq`: the last log line each open job already shows.

    after: Option<String>,

}

/// `GET /{owner}/{name}/flow/{id}/live`: statuses and new log lines, for the

/// run page while it is live.

pub async fn live(

    State(app): State<Shared>,

    viewer: Viewer,

    Path((owner, name, id)): Path<(String, String, i64)>,

    Query(q): Query<LiveQuery>,

) -> Result<Response, Error> {

    let shell = Shell::new(&app, "", &viewer);

    let (_repo, row, _role) = lookup(&app, &shell, &viewer, &owner, &name).await?;

    let run = fdb::run(&app.db, row.id, id)

        .await

        .map_err(|e| Error::from_db(shell.clone(), e))?

        .ok_or_else(|| Error::not_found(shell.clone()))?;

    let jobs = fdb::jobs(&app.db, run.id).await.map_err(|e| Error::from_db(shell.clone(), e))?;

    let after: std::collections::HashMap<i64, i64> = q

        .after

        .unwrap_or_default()

        .split(',')

        .filter_map(|p| p.split_once(':'))

        .filter_map(|(a, b)| Some((a.parse().ok()?, b.parse().ok()?)))

        .collect();

    let mut out = Vec::new();

    for j in &jobs {

        let lines = match after.get(&j.id) {

            Some(seq) => fdb::log(&app.db, j.id, *seq, 1000).await.unwrap_or_default(),

            None => vec![],

        };

        out.push(serde_json::json!({

            "id": j.id,

            "name": j.name,

            "status": j.status,

            "glyph": glyph(&j.status),

            "duration": crate::flow::duration(j),

            "exit_code": j.exit_code,

            "lines": lines.iter().map(|l| serde_json::json!({ "seq": l.seq, "t": l.t, "stream": l.stream, "text": l.text })).collect::<Vec<_>>(),

        }));

    }

    Ok(Json(serde_json::json!({ "status": run.status, "live": run.live(), "jobs": out })).into_response())

}