use super::*;
use syntax_pos::SpanData;
use rustc_data_structures::fx::FxHashMap;
use rustc::util::common::QueryMsg;
use std::fs::File;
use std::time::{Duration, Instant};
use rustc::dep_graph::{DepNode};

#[derive(Debug, Clone, Eq, PartialEq)]
pub struct Query {
    pub span: SpanData,
    pub msg: QueryMsg,
}
pub enum Effect {
    QueryBegin(Query, CacheCase),
    TimeBegin(String),
    TaskBegin(DepNode),
}
pub enum CacheCase {
    Hit, Miss
}
/// Recursive trace structure
pub struct Rec {
    pub effect: Effect,
    pub start: Instant,
    pub dur_self: Duration,
    pub dur_total: Duration,
    pub extent: Box<Vec<Rec>>,
}
pub struct QueryMetric {
    pub count: usize,
    pub dur_self: Duration,
    pub dur_total: Duration,
}

fn cons(s: &str) -> String {
    let first = s.split(|d| d == '(' || d == '{').next();
    assert!(first.is_some() && first != Some(""));
    first.unwrap().to_owned()
}

pub fn cons_of_query_msg(q: &trace::Query) -> String {
    cons(&format!("{:?}", q.msg))
}

pub fn cons_of_key(k: &DepNode) -> String {
    cons(&format!("{:?}", k))
}

// First return value is text; second return value is a CSS class
pub fn html_of_effect(eff: &Effect) -> (String, String) {
    match *eff {
        Effect::TimeBegin(ref msg) => {
            (msg.clone(),
             "time-begin".to_string())
        },
        Effect::TaskBegin(ref key) => {
            let cons = cons_of_key(key);
            (cons.clone(), format!("{} task-begin", cons))
        },
        Effect::QueryBegin(ref qmsg, ref cc) => {
            let cons = cons_of_query_msg(qmsg);
            (cons.clone(),
             format!("{} {}",
                     cons,
                     match *cc {
                         CacheCase::Hit => "hit",
                         CacheCase::Miss => "miss",
                     }))
        }
    }
}

// First return value is text; second return value is a CSS class
fn html_of_duration(_start: &Instant, dur: &Duration) -> (String, String) {
    use rustc::util::common::duration_to_secs_str;
    (duration_to_secs_str(dur.clone()), String::new())
}

fn html_of_fraction(frac: f64) -> (String, &'static str) {
    let css = {
        if       frac > 0.50  { "frac-50" }
        else if  frac > 0.40  { "frac-40" }
        else if  frac > 0.30  { "frac-30" }
        else if  frac > 0.20  { "frac-20" }
        else if  frac > 0.10  { "frac-10" }
        else if  frac > 0.05  { "frac-05" }
        else if  frac > 0.02  { "frac-02" }
        else if  frac > 0.01  { "frac-01" }
        else if  frac > 0.001 { "frac-001" }
        else                  { "frac-0" }
    };
    let percent = frac * 100.0;

    if percent > 0.1 {
        (format!("{:.1}%", percent), css)
    } else {
        ("< 0.1%".to_string(), css)
    }
}

fn total_duration(traces: &[Rec]) -> Duration {
    Duration::new(0, 0) + traces.iter().map(|t| t.dur_total).sum()
}

fn duration_div(nom: Duration, den: Duration) -> f64 {
    fn to_nanos(d: Duration) -> u64 {
        d.as_secs() * 1_000_000_000 + d.subsec_nanos() as u64
    }

    to_nanos(nom) as f64 / to_nanos(den) as f64
}

fn write_traces_rec(file: &mut File, traces: &[Rec], total: Duration, depth: usize) {
    for t in traces {
        let (eff_text, eff_css_classes) = html_of_effect(&t.effect);
        let (dur_text, dur_css_classes) = html_of_duration(&t.start, &t.dur_total);
        let fraction = duration_div(t.dur_total, total);
        let percent = fraction * 100.0;
        let (frc_text, frc_css_classes) = html_of_fraction(fraction);
        writeln!(file, "<div class=\"trace depth-{} extent-{}{} {} {} {}\">",
                 depth,
                 t.extent.len(),
                 /* Heuristic for 'important' CSS class: */
                 if t.extent.len() > 5 || percent >= 1.0 { " important" } else { "" },
                 eff_css_classes,
                 dur_css_classes,
                 frc_css_classes,
        ).unwrap();
        writeln!(file, "<div class=\"eff\">{}</div>", eff_text).unwrap();
        writeln!(file, "<div class=\"dur\">{}</div>", dur_text).unwrap();
        writeln!(file, "<div class=\"frc\">{}</div>", frc_text).unwrap();
        write_traces_rec(file, &t.extent, total, depth + 1);
        writeln!(file, "</div>").unwrap();
    }
}

fn compute_counts_rec(counts: &mut FxHashMap<String,QueryMetric>, traces: &[Rec]) {
    counts.reserve(traces.len());
    for t in traces.iter() {
        match t.effect {
            Effect::TimeBegin(ref msg) => {
                let qm = match counts.get(msg) {
                    Some(_qm) => panic!("TimeBegin with non-unique, repeat message"),
                    None => QueryMetric {
                        count: 1,
                        dur_self: t.dur_self,
                        dur_total: t.dur_total,
                    }
                };
                counts.insert(msg.clone(), qm);
            },
            Effect::TaskBegin(ref key) => {
                let cons = cons_of_key(key);
                let qm = match counts.get(&cons) {
                    Some(qm) =>
                        QueryMetric {
                            count: qm.count + 1,
                            dur_self: qm.dur_self + t.dur_self,
                            dur_total: qm.dur_total + t.dur_total,
                        },
                    None => QueryMetric {
                        count: 1,
                        dur_self: t.dur_self,
                        dur_total: t.dur_total,
                    }
                };
                counts.insert(cons, qm);
            },
            Effect::QueryBegin(ref qmsg, ref _cc) => {
                let qcons = cons_of_query_msg(qmsg);
                let qm = match counts.get(&qcons) {
                    Some(qm) =>
                        QueryMetric {
                            count: qm.count + 1,
                            dur_total: qm.dur_total + t.dur_total,
                            dur_self: qm.dur_self + t.dur_self
                        },
                    None => QueryMetric {
                        count: 1,
                        dur_total: t.dur_total,
                        dur_self: t.dur_self,
                    }
                };
                counts.insert(qcons, qm);
            }
        }
        compute_counts_rec(counts, &t.extent)
    }
}

pub fn write_counts(count_file: &mut File, counts: &mut FxHashMap<String, QueryMetric>) {
    use rustc::util::common::duration_to_secs_str;
    use std::cmp::Reverse;

    let mut data = counts.iter().map(|(ref cons, ref qm)|
        (cons.clone(), qm.count.clone(), qm.dur_total.clone(), qm.dur_self.clone())
    ).collect::<Vec<_>>();

    data.sort_by_key(|k| Reverse(k.3));
    for (cons, count, dur_total, dur_self) in data {
        writeln!(count_file, "{}, {}, {}, {}",
                 cons, count,
                 duration_to_secs_str(dur_total),
                 duration_to_secs_str(dur_self)
        ).unwrap();
    }
}

pub fn write_traces(html_file: &mut File, counts_file: &mut File, traces: &[Rec]) {
    let capacity = traces.iter().fold(0, |acc, t| acc + 1 + t.extent.len());
    let mut counts = FxHashMap::with_capacity_and_hasher(capacity, Default::default());
    compute_counts_rec(&mut counts, traces);
    write_counts(counts_file, &mut counts);

    let total: Duration = total_duration(traces);
    write_traces_rec(html_file, traces, total, 0)
}

pub fn write_style(html_file: &mut File) {
    write!(html_file, "{}", "
body {
    font-family: sans-serif;
    background: black;
}
.trace {
    color: black;
    display: inline-block;
    border-style: solid;
    border-color: red;
    border-width: 1px;
    border-radius: 5px;
    padding: 0px;
    margin: 1px;
    font-size: 0px;
}
.task-begin {
    border-width: 1px;
    color: white;
    border-color: #ff8;
    font-size: 0px;
}
.miss {
    border-color: red;
    border-width: 1px;
}
.extent-0 {
    padding: 2px;
}
.time-begin {
    border-width: 4px;
    font-size: 12px;
    color: white;
    border-color: #afa;
}
.important {
    border-width: 3px;
    font-size: 12px;
    color: white;
    border-color: #f77;
}
.hit {
    padding: 0px;
    border-color: blue;
    border-width: 3px;
}
.eff {
  color: #fff;
  display: inline-block;
}
.frc {
  color: #7f7;
  display: inline-block;
}
.dur {
  display: none
}
.frac-50 {
  padding: 10px;
  border-width: 10px;
  font-size: 32px;
}
.frac-40 {
  padding: 8px;
  border-width: 8px;
  font-size: 24px;
}
.frac-30 {
  padding: 6px;
  border-width: 6px;
  font-size: 18px;
}
.frac-20 {
  padding: 4px;
  border-width: 6px;
  font-size: 16px;
}
.frac-10 {
  padding: 2px;
  border-width: 6px;
  font-size: 14px;
}
").unwrap();
}