// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {
    diagnostics_data::{InspectData, InspectHandleName},
    diagnostics_hierarchy::{
        ArrayContent, DiagnosticsHierarchy, ExponentialHistogram, LinearHistogram, Property,
    },
    either::Either,
    nom::HexDisplay,
    num_traits::{Bounded, Zero},
    std::{
        fmt,
        ops::{Add, AddAssign, Mul, MulAssign},
    },
};

const INDENT: usize = 2;
const HEX_DISPLAY_CHUNK_SIZE: usize = 16;

pub fn format<W>(w: &mut W, path: &str, diagnostics_hierarchy: DiagnosticsHierarchy) -> fmt::Result
where
    W: fmt::Write,
{
    writeln!(w, "{}:", path)?;
    output_hierarchy(w, &diagnostics_hierarchy, 1)
}

pub fn output_schema<W>(w: &mut W, schema: &InspectData) -> fmt::Result
where
    W: fmt::Write,
{
    writeln!(w, "{}:", schema.moniker)?;
    writeln!(w, "  metadata:")?;
    if let Some(errors) = &schema.metadata.errors {
        writeln!(w, "    errors = {}", errors.join(", "))?;
    }

    if let Some(name) = &schema.metadata.name {
        match name {
            InspectHandleName::Filename(f) => {
                writeln!(w, "    filename = {}", f)?;
            }
            InspectHandleName::Name(n) => {
                writeln!(w, "    name = {}", n)?;
            }
        }
    }

    write!(w, "    component_url = ")?;
    match &schema.metadata.component_url {
        Some(url) => writeln!(w, "{}", url)?,
        None => writeln!(w, "null")?,
    }
    writeln!(w, "    timestamp = {}", schema.metadata.timestamp)?;

    match &schema.payload {
        Some(hierarchy) => {
            writeln!(w, "  payload:")?;
            output_hierarchy(w, &hierarchy, 2)
        }
        None => writeln!(w, "  payload: null"),
    }
}

fn output_hierarchy<W>(
    w: &mut W,
    diagnostics_hierarchy: &DiagnosticsHierarchy,
    indent: usize,
) -> fmt::Result
where
    W: fmt::Write,
{
    let name_indent = " ".repeat(INDENT * indent);
    let value_indent = " ".repeat(INDENT * (indent + 1));
    let array_broken_line_indent = " ".repeat(INDENT * (indent + 2));

    writeln!(w, "{}{}:", name_indent, diagnostics_hierarchy.name)?;

    for property in &diagnostics_hierarchy.properties {
        match property {
            Property::String(name, value) => writeln!(w, "{}{} = {}", value_indent, name, value)?,
            Property::Int(name, value) => writeln!(w, "{}{} = {}", value_indent, name, value)?,
            Property::Uint(name, value) => writeln!(w, "{}{} = {}", value_indent, name, value)?,
            Property::Double(name, value) => {
                writeln!(w, "{}{} = {:.6}", value_indent, name, value)?
            }
            Property::Bytes(name, array) => {
                let byte_str = array.to_hex(HEX_DISPLAY_CHUNK_SIZE);
                writeln!(w, "{}{} = Binary:\n{}", value_indent, name, byte_str.trim())?;
            }
            Property::Bool(name, value) => writeln!(w, "{}{} = {}", value_indent, name, value)?,
            Property::IntArray(name, array) => output_array(w, &value_indent, &name, &array)?,
            Property::UintArray(name, array) => output_array(w, &value_indent, &name, &array)?,
            Property::DoubleArray(name, array) => output_array(w, &value_indent, &name, &array)?,
            Property::StringList(name, list) => {
                let max_line_length = 100;
                let length_of_brackets = 2;
                let length_of_comma_space = 2;
                let total_len = list
                    .iter()
                    .fold(length_of_brackets, |acc, v| acc + v.len() + length_of_comma_space);
                if total_len < max_line_length {
                    writeln!(w, "{}{} = {:?}", value_indent, name, list)?;
                } else {
                    writeln!(w, "{}{} = [", value_indent, name)?;
                    for v in list {
                        writeln!(w, r#"{}"{}","#, array_broken_line_indent, v)?;
                    }
                    writeln!(w, "{}]", value_indent)?;
                }
            }
        }
    }

    for child in &diagnostics_hierarchy.children {
        output_hierarchy(w, child, indent + 1)?;
    }
    Ok(())
}

trait FromUsize {
    fn from_usize(n: usize) -> Self;
}

impl FromUsize for i64 {
    fn from_usize(n: usize) -> Self {
        i64::try_from(n).unwrap()
    }
}

impl FromUsize for u64 {
    fn from_usize(n: usize) -> Self {
        u64::try_from(n).unwrap()
    }
}

impl FromUsize for f64 {
    fn from_usize(n: usize) -> Self {
        u64::try_from(n).unwrap() as f64
    }
}

trait ExponentialBucketBound {
    fn bound(floor: Self, initial_step: Self, step_multiplier: Self, index: usize) -> Self;
}

impl ExponentialBucketBound for i64 {
    fn bound(floor: Self, initial_step: Self, step_multiplier: Self, index: usize) -> Self {
        floor + initial_step * i64::pow(step_multiplier, index as u32)
    }
}

impl ExponentialBucketBound for u64 {
    fn bound(floor: Self, initial_step: Self, step_multiplier: Self, index: usize) -> Self {
        floor + initial_step * u64::pow(step_multiplier, index as u32)
    }
}

impl ExponentialBucketBound for f64 {
    fn bound(floor: Self, initial_step: Self, step_multiplier: Self, index: usize) -> Self {
        floor + initial_step * f64::powi(step_multiplier, (index as u64) as i32)
    }
}

struct ExponentialBucketBoundsArgs<T> {
    floor: T,
    initial_step: T,
    step_multiplier: T,
    index: usize,
    size: usize,
}

fn exponential_bucket_bounds<T>(args: ExponentialBucketBoundsArgs<T>) -> (T, T)
where
    T: Bounded + Add<Output = T> + ExponentialBucketBound + Copy,
{
    let ExponentialBucketBoundsArgs { floor, initial_step, step_multiplier, index, size } = args;
    match index {
        0 => (T::min_value(), floor),
        1 if size == 2 => (floor, T::max_value()),
        1 => (floor, floor + initial_step),
        index if index == size - 1 => {
            (T::bound(floor, initial_step, step_multiplier, index - 2), T::max_value())
        }
        _ => (
            T::bound(floor, initial_step, step_multiplier, index - 2),
            T::bound(floor, initial_step, step_multiplier, index - 1),
        ),
    }
}

struct LinearBucketBoundsArgs<T> {
    floor: T,
    step: T,
    index: usize,
    size: usize,
}

fn linear_bucket_bounds<T>(args: LinearBucketBoundsArgs<T>) -> (T, T)
where
    T: Bounded + Add<Output = T> + Mul<Output = T> + FromUsize + Copy,
{
    let LinearBucketBoundsArgs { floor, step, index, size } = args;
    match index {
        0 => (T::min_value(), floor),
        index if index == size - 1 => (floor + step * T::from_usize(index - 1), T::max_value()),
        _ => (floor + step * T::from_usize(index - 1), floor + step * T::from_usize(index)),
    }
}

fn output_histogram<T, F, W>(
    w: &mut W,
    indent: &str,
    name: &str,
    histogram_type: &str,
    counts: &[T],
    indexes: &Option<Vec<usize>>,
    size: usize,
    bound_calculator: F,
) -> fmt::Result
where
    W: fmt::Write,
    T: NumberFormat + fmt::Display + PartialOrd + Zero,
    F: Fn(usize) -> (T, T),
{
    let value_indent = format!("{}{}", indent, " ".repeat(INDENT));
    write!(
        w,
        "{indent}{name}:\n\
                {value_indent}type = {histogram_type}\n\
                {value_indent}size = {size}\n\
                {value_indent}buckets = ["
    )?;
    let mut nonzero_counts = match indexes {
        None => Either::Left(counts.iter().enumerate().filter(|(_, count)| **count > T::zero())),
        Some(indexes) => Either::Right(
            indexes
                .iter()
                .zip(counts)
                .filter(|(_, count)| **count > T::zero())
                .map(|(u, t)| (*u, t)),
        ),
    }
    .peekable();
    while let Some((index, count)) = nonzero_counts.next() {
        let (low_bound, high_bound) = bound_calculator(index);
        write!(w, "[{},{})={}", low_bound.format(), high_bound.format(), count)?;
        if nonzero_counts.peek().is_some() {
            write!(w, ", ")?;
        }
    }
    write!(w, "]\n")
}

fn output_array<T, W>(
    w: &mut W,
    value_indent: &str,
    name: &str,
    array: &ArrayContent<T>,
) -> fmt::Result
where
    W: fmt::Write,
    T: AddAssign
        + MulAssign
        + Copy
        + Add<Output = T>
        + fmt::Display
        + NumberFormat
        + Bounded
        + Mul<Output = T>
        + ExponentialBucketBound
        + FromUsize
        + PartialOrd
        + Zero,
{
    match array {
        ArrayContent::Values(values) => {
            write!(w, "{value_indent}{name} = [")?;
            for (i, value) in values.iter().enumerate() {
                write!(w, "{value}")?;
                if i < values.len() - 1 {
                    w.write_str(", ")?;
                }
            }
            writeln!(w, "]")
        }
        ArrayContent::LinearHistogram(LinearHistogram { floor, step, counts, indexes, size }) => {
            let bucket_bounder = |index| {
                linear_bucket_bounds::<T>(LinearBucketBoundsArgs {
                    floor: *floor,
                    step: *step,
                    index,
                    size: *size,
                })
            };
            output_histogram(
                w,
                value_indent,
                name,
                "linear",
                counts,
                indexes,
                *size,
                bucket_bounder,
            )
        }
        ArrayContent::ExponentialHistogram(ExponentialHistogram {
            floor,
            initial_step,
            step_multiplier,
            counts,
            indexes,
            size,
        }) => {
            let bucket_bounder = |index| {
                exponential_bucket_bounds::<T>(ExponentialBucketBoundsArgs {
                    floor: *floor,
                    initial_step: *initial_step,
                    step_multiplier: *step_multiplier,
                    index,
                    size: *size,
                })
            };
            output_histogram(
                w,
                value_indent,
                name,
                "exponential",
                counts,
                indexes,
                *size,
                bucket_bounder,
            )
        }
    }
}

trait NumberFormat {
    fn format(&self) -> String;
}

impl NumberFormat for i64 {
    fn format(&self) -> String {
        match *self {
            i64::MAX => "<max>".to_string(),
            std::i64::MIN => "<min>".to_string(),
            x => format!("{}", x),
        }
    }
}

impl NumberFormat for u64 {
    fn format(&self) -> String {
        match *self {
            u64::MAX => "<max>".to_string(),
            x => format!("{}", x),
        }
    }
}

impl NumberFormat for usize {
    fn format(&self) -> String {
        match *self {
            std::usize::MAX => "<max>".to_string(),
            x => format!("{}", x),
        }
    }
}

impl NumberFormat for f64 {
    fn format(&self) -> String {
        if *self == std::f64::MAX || *self == std::f64::INFINITY {
            "inf".to_string()
        } else if *self == std::f64::MIN || *self == std::f64::NEG_INFINITY {
            "-inf".to_string()
        } else {
            format!("{}", self)
        }
    }
}

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

    #[fuchsia::test]
    fn test_array_line_breaks() {
        let h = DiagnosticsHierarchy {
            name: "test".into(),
            properties: vec![Property::StringList(
                "short_array".to_owned(),
                vec!["short".into(), "array".into()],
            )],
            children: vec![],
            missing: vec![],
        };
        let mut buf = String::new();
        output_hierarchy(&mut buf, &h, 2).unwrap();

        let expected = r#"    test:
      short_array = ["short", "array"]
"#;
        assert_eq!(expected, buf);

        // joined up would be 104 characters
        let long_array = vec![
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
            "12345678".into(),
        ];

        let h = DiagnosticsHierarchy {
            name: "test".into(),
            properties: vec![Property::StringList("long_array".to_owned(), long_array)],
            children: vec![],
            missing: vec![],
        };
        let mut buf = String::new();
        output_hierarchy(&mut buf, &h, 2).unwrap();

        let expected = r#"    test:
      long_array = [
        "12345678",
        "12345678",
        "12345678",
        "12345678",
        "12345678",
        "12345678",
        "12345678",
        "12345678",
        "12345678",
        "12345678",
        "12345678",
        "12345678",
        "12345678",
      ]
"#;
        assert_eq!(expected, buf);
    }

    #[test_case(LinearBucketBoundsArgs { floor: -10, step: 2, index: 0, size: 4 }, (i64::MIN, -10))]
    #[test_case(LinearBucketBoundsArgs { floor: -10, step: 2, index: 1, size: 4 }, (-10, -8))]
    #[test_case(LinearBucketBoundsArgs { floor: -10, step: 2, index: 2, size: 4 }, (-8, -6))]
    #[test_case(LinearBucketBoundsArgs { floor: -10, step: 2, index: 3, size: 4 }, (-6, i64::MAX))]
    #[fuchsia::test]
    fn test_linear_bucket_bounds_i64(args: LinearBucketBoundsArgs<i64>, bounds: (i64, i64)) {
        // floor, step, index, size
        assert_eq!(linear_bucket_bounds(args), bounds);
    }

    // u64 min is 0, so the underflow bucket may be weird
    #[test_case(LinearBucketBoundsArgs { floor: 0, step: 2, index: 0, size: 4 }, (0, 0))]
    #[test_case(LinearBucketBoundsArgs { floor: 0, step: 2, index: 1, size: 4 }, (0, 2))]
    #[test_case(LinearBucketBoundsArgs { floor: 0, step: 2, index: 2, size: 4 }, (2, 4))]
    #[test_case(LinearBucketBoundsArgs { floor: 0, step: 2, index: 3, size: 4 }, (4, u64::MAX))]
    #[test_case(LinearBucketBoundsArgs { floor: 1, step: 2, index: 0, size: 4 }, (0, 1))]
    #[test_case(LinearBucketBoundsArgs { floor: 1, step: 2, index: 1, size: 4 }, (1, 3))]
    #[test_case(LinearBucketBoundsArgs { floor: 1, step: 2, index: 2, size: 4 }, (3, 5))]
    #[test_case(LinearBucketBoundsArgs { floor: 1, step: 2, index: 3, size: 4 }, (5, u64::MAX))]
    #[fuchsia::test]
    fn test_linear_bucket_bounds_u64(args: LinearBucketBoundsArgs<u64>, bounds: (u64, u64)) {
        assert_eq!(linear_bucket_bounds(args), bounds);
    }

    #[test_case(
        LinearBucketBoundsArgs { floor: -0.5, step: 0.5, index: 0, size: 4 },
        (f64::MIN, -0.5)
    )]
    #[test_case(LinearBucketBoundsArgs { floor: -0.5, step: 0.5, index: 1, size: 4 }, (-0.5, 0.0))]
    #[test_case(LinearBucketBoundsArgs { floor: -0.5, step: 0.5, index: 2, size: 4 }, (0.0, 0.5))]
    #[test_case(
        LinearBucketBoundsArgs { floor: -0.5, step: 0.5, index: 3, size: 4 },
        (0.5, f64::MAX)
    )]
    #[fuchsia::test]
    fn test_linear_bucket_bounds_f64(args: LinearBucketBoundsArgs<f64>, bounds: (f64, f64)) {
        assert_eq!(linear_bucket_bounds(args), bounds);
    }

    // Check logic for few-bucket histograms. 2-bucket shouldn't occur, but let's treat it
    // well anyway. (Using i64)
    #[test_case(LinearBucketBoundsArgs { floor: -10, step: 2, index: 0, size: 3 }, (i64::MIN, -10))]
    #[test_case(LinearBucketBoundsArgs { floor: -10, step: 2, index: 1, size: 3 }, (-10, -8))]
    #[test_case(LinearBucketBoundsArgs { floor: -10, step: 2, index: 2, size: 3 }, (-8, i64::MAX))]
    #[test_case(LinearBucketBoundsArgs { floor: -10, step: 2, index: 0, size: 2 }, (i64::MIN, -10))]
    #[test_case(LinearBucketBoundsArgs { floor: -10, step: 2, index: 1, size: 2 }, (-10, i64::MAX))]
    #[fuchsia::test]
    fn test_linear_small_bucket_bounds(args: LinearBucketBoundsArgs<i64>, bounds: (i64, i64)) {
        // floor, step, index, size
        assert_eq!(linear_bucket_bounds(args), bounds);
    }

    // Test cases for i64 exponential
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 0,
            size: 5 },
        (i64::MIN, -10)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 1,
            size: 5 },
        (-10, -8)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 2,
            size: 5
        },
        (-8, -4)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 3,
            size: 5
        },
        (-4, 8)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 4,
            size: 5
        },
        (8, i64::MAX)
    )]
    #[fuchsia::test]
    fn test_exponential_bucket_bounds_i64(
        args: ExponentialBucketBoundsArgs<i64>,
        bounds: (i64, i64),
    ) {
        assert_eq!(exponential_bucket_bounds(args), bounds);
    }

    // Test cases for u64 exponential
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: 0,
            initial_step: 2,
            step_multiplier: 3,
            index: 0,
            size: 5
        },
        (0, 0)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: 0,
            initial_step: 2,
            step_multiplier: 3,
            index: 1,
            size: 5
        },
        (0, 2)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: 0,
            initial_step: 2,
            step_multiplier: 3,
            index: 2,
            size: 5
        },
        (2, 6)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: 0,
            initial_step: 2,
            step_multiplier: 3,
            index: 3,
            size: 5
        },
        (6, 18)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
        floor: 0,
        initial_step: 2,
        step_multiplier: 3,
        index: 4,
        size: 5 },
        (18, u64::MAX)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: 1,
            initial_step: 2,
            step_multiplier: 3,
            index: 0,
            size: 5
        },
        (0, 1)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: 1,
            initial_step: 2,
            step_multiplier: 3,
            index: 1,
            size: 5
        },
        (1, 3)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: 1,
            initial_step: 2,
            step_multiplier: 3,
            index: 2,
            size: 5
        },
        (3, 7)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: 1,
            initial_step: 2,
            step_multiplier: 3,
            index: 3,
            size: 5
        },
        (7, 19)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: 1,
            initial_step: 2,
            step_multiplier: 3,
            index: 4,
            size: 5
        },
        (19, u64::MAX)
    )]
    #[fuchsia::test]
    fn test_exponential_bucket_bounds_u64(
        args: ExponentialBucketBoundsArgs<u64>,
        bounds: (u64, u64),
    ) {
        assert_eq!(exponential_bucket_bounds(args), bounds);
    }

    // Test cases for f64 exponential
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -0.5,
            initial_step: 0.5,
            step_multiplier: 3.0,
            index: 0,
            size: 5 },
        (f64::MIN, -0.5)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -0.5,
            initial_step: 0.5,
            step_multiplier: 3.0,
            index: 1,
            size: 5 },
        (-0.5, 0.0)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -0.5,
            initial_step: 0.5,
            step_multiplier: 3.0,
            index: 2,
            size: 5 },
        (0.0, 1.0)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -0.5,
            initial_step: 0.5,
            step_multiplier: 3.0,
            index: 3,
            size: 5 },
        (1.0, 4.0)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -0.5,
            initial_step: 0.5,
            step_multiplier: 3.0,
            index: 4,
            size: 5 },
            (4.0, f64::MAX)
        )]
    #[fuchsia::test]
    fn test_exponential_bucket_bounds_f64(
        args: ExponentialBucketBoundsArgs<f64>,
        bounds: (f64, f64),
    ) {
        assert_eq!(exponential_bucket_bounds(args), bounds);
    }

    // Check logic for few-bucket histograms. 2-bucket shouldn't occur, but let's treat it
    // well anyway. (Using i64)
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 0,
            size: 4
        },
        (i64::MIN, -10)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 1,
            size: 4
        },
        (-10, -8)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 2,
            size: 4
        },
        (-8, -4)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 3,
            size: 4
        },
        (-4, i64::MAX)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 0,
            size: 3
        },
        (i64::MIN, -10)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 1,
            size: 3
        },
        (-10, -8)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 2,
            size: 3
        },
        (-8, i64::MAX)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 0,
            size: 2
        },
        (i64::MIN, -10)
    )]
    #[test_case(
        ExponentialBucketBoundsArgs {
            floor: -10,
            initial_step: 2,
            step_multiplier: 3,
            index: 1,
            size: 2
        },
        (-10, i64::MAX)
    )]
    #[fuchsia::test]
    fn test_exponential_small_bucket_bounds(
        args: ExponentialBucketBoundsArgs<i64>,
        bounds: (i64, i64),
    ) {
        assert_eq!(exponential_bucket_bounds(args), bounds);
    }
}