nu-data 0.44.0

use crate::base::coerce_compare;
use crate::base::shape::{Column, InlineShape};
use crate::primitive::style_primitive;
use bigdecimal::Signed;
use chrono::{DateTime, NaiveDate, Utc};
use nu_errors::ShellError;
use nu_protocol::hir::Operator;
use nu_protocol::ShellTypeName;
use nu_protocol::{Primitive, Type, UntaggedValue};
use nu_source::{DebugDocBuilder, PrettyDebug, Span, Tagged};
use nu_table::TextStyle;
use num_bigint::BigInt;
use num_bigint::ToBigInt;
use num_traits::{ToPrimitive, Zero};
use std::collections::HashMap;

pub struct Date;

impl Date {
    pub fn from_regular_str(s: Tagged<&str>) -> Result<UntaggedValue, ShellError> {
        let date = DateTime::parse_from_rfc3339(s.item).map_err(|err| {
            ShellError::labeled_error(
                &format!("Date parse error: {}", err),
                "original value",
                s.tag,
            )
        })?;

        let date = date.with_timezone(&chrono::offset::Utc);

        Ok(UntaggedValue::Primitive(Primitive::Date(date.into())))
    }

    pub fn naive_from_str(s: Tagged<&str>) -> Result<UntaggedValue, ShellError> {
        let date = NaiveDate::parse_from_str(s.item, "%Y-%m-%d").map_err(|reason| {
            ShellError::labeled_error(
                &format!("Date parse error: {}", reason),
                "original value",
                s.tag,
            )
        })?;

        Ok(UntaggedValue::Primitive(Primitive::Date(
            DateTime::<Utc>::from_utc(date.and_hms(12, 34, 56), Utc).into(),
        )))
    }
}

pub fn date_from_str(s: Tagged<&str>) -> Result<UntaggedValue, ShellError> {
    Date::from_regular_str(s)
}

pub fn date_naive_from_str(s: Tagged<&str>) -> Result<UntaggedValue, ShellError> {
    Date::naive_from_str(s)
}

pub fn merge_values(
    left: &UntaggedValue,
    right: &UntaggedValue,
) -> Result<UntaggedValue, (&'static str, &'static str)> {
    match (left, right) {
        (UntaggedValue::Row(columns), UntaggedValue::Row(columns_b)) => {
            Ok(UntaggedValue::Row(columns.merge_from(columns_b)))
        }
        (left, right) => Err((left.type_name(), right.type_name())),
    }
}

fn zero_division_error() -> UntaggedValue {
    UntaggedValue::Error(ShellError::untagged_runtime_error("division by zero"))
}

pub fn unsafe_compute_values(
    operator: Operator,
    left: &UntaggedValue,
    right: &UntaggedValue,
) -> Result<UntaggedValue, (&'static str, &'static str)> {
    let computed = compute_values(operator, left, right);

    if computed.is_ok() {
        return computed;
    }

    match (left, right) {
        (UntaggedValue::Primitive(lhs), UntaggedValue::Primitive(rhs)) => match (lhs, rhs) {
            (Primitive::Filesize(x), Primitive::Int(y)) => match operator {
                Operator::Multiply => {
                    Ok(UntaggedValue::Primitive(Primitive::Filesize(x * *y as u64)))
                }
                Operator::Divide => {
                    Ok(UntaggedValue::Primitive(Primitive::Filesize(x / *y as u64)))
                }
                _ => Err((left.type_name(), right.type_name())),
            },
            (Primitive::Int(x), Primitive::Filesize(y)) => match operator {
                Operator::Multiply => {
                    Ok(UntaggedValue::Primitive(Primitive::Filesize(*x as u64 * y)))
                }
                _ => Err((left.type_name(), right.type_name())),
            },
            _ => Err((left.type_name(), right.type_name())),
        },
        _ => Err((left.type_name(), right.type_name())),
    }
}

pub fn compute_values(
    operator: Operator,
    left: &UntaggedValue,
    right: &UntaggedValue,
) -> Result<UntaggedValue, (&'static str, &'static str)> {
    match (left, right) {
        (UntaggedValue::Primitive(lhs), UntaggedValue::Primitive(rhs)) => match (lhs, rhs) {
            (Primitive::Filesize(x), Primitive::Filesize(y)) => {
                let result = match operator {
                    Operator::Plus => Ok(x + y),
                    Operator::Minus => Ok(x - y),
                    Operator::Multiply => Ok(x * y),
                    Operator::Divide => {
                        if y.is_zero() {
                            Err((left.type_name(), right.type_name()))
                        } else {
                            Ok(x / y)
                        }
                    }
                    _ => Err((left.type_name(), right.type_name())),
                }?;
                Ok(UntaggedValue::Primitive(Primitive::Filesize(result)))
            }
            (Primitive::Filesize(x), Primitive::Int(y)) => match operator {
                // Operator::Plus => Ok(UntaggedValue::Primitive(Primitive::Filesize(x + *y as u64))),
                // Operator::Minus => Ok(UntaggedValue::Primitive(Primitive::Filesize(x - *y as u64))),
                Operator::Multiply => {
                    Ok(UntaggedValue::Primitive(Primitive::Filesize(x * *y as u64)))
                }
                Operator::Divide => {
                    Ok(UntaggedValue::Primitive(Primitive::Filesize(x / *y as u64)))
                }
                _ => Err((left.type_name(), right.type_name())),
            },
            (Primitive::Int(x), Primitive::Filesize(y)) => match operator {
                // Operator::Plus => Ok(UntaggedValue::Primitive(Primitive::Filesize(*x as u64 + y))),
                // Operator::Minus => Ok(UntaggedValue::Primitive(Primitive::Filesize(*x as u64 - y))),
                Operator::Multiply => {
                    Ok(UntaggedValue::Primitive(Primitive::Filesize(*x as u64 * y)))
                }
                // Operator::Divide => {
                //     Ok(UntaggedValue::Primitive(Primitive::Filesize(*x as u64 / y)))
                // }
                _ => Err((left.type_name(), right.type_name())),
            },
            (Primitive::Int(x), Primitive::Int(y)) => match operator {
                Operator::Plus => Ok(UntaggedValue::Primitive(Primitive::Int(x + y))),
                Operator::Minus => Ok(UntaggedValue::Primitive(Primitive::Int(x - y))),
                Operator::Multiply => Ok(UntaggedValue::Primitive(Primitive::Int(x * y))),
                Operator::Divide => {
                    if y.is_zero() {
                        Ok(zero_division_error())
                    } else if x - (y * (x / y)) == 0 {
                        Ok(UntaggedValue::Primitive(Primitive::Int(x / y)))
                    } else {
                        Ok(UntaggedValue::Primitive(Primitive::Decimal(
                            bigdecimal::BigDecimal::from(*x) / bigdecimal::BigDecimal::from(*y),
                        )))
                    }
                }
                Operator::Modulo => {
                    if y.is_zero() {
                        Ok(zero_division_error())
                    } else {
                        Ok(UntaggedValue::Primitive(Primitive::Int(x % y)))
                    }
                }
                Operator::Pow => {
                    let prim_u32 = ToPrimitive::to_u32(y);

                    let sign = match x.is_negative() {
                        true => -1,
                        false => 1,
                    };

                    if !y.is_negative() {
                        match prim_u32 {
                            Some(num) => Ok(UntaggedValue::Primitive(Primitive::Int(
                                sign * (x.pow(num)),
                            ))),
                            _ => Err((left.type_name(), right.type_name())),
                        }
                    } else {
                        let yp = bigdecimal::ToPrimitive::to_f64(y).unwrap_or(0.0);
                        let xp = bigdecimal::ToPrimitive::to_f64(x).unwrap_or(0.0);

                        let pow =
                            bigdecimal::FromPrimitive::from_f64((sign as f64) * (xp.powf(yp)));

                        match pow {
                            Some(p) => Ok(UntaggedValue::Primitive(Primitive::Decimal(p))),
                            _ => Err((left.type_name(), right.type_name())),
                        }
                    }
                }
                _ => Err((left.type_name(), right.type_name())),
            },
            (Primitive::Int(x), Primitive::BigInt(y)) => match operator {
                Operator::Plus => Ok(UntaggedValue::Primitive(Primitive::BigInt(
                    BigInt::from(*x) + y,
                ))),
                Operator::Minus => Ok(UntaggedValue::Primitive(Primitive::BigInt(
                    BigInt::from(*x) - y,
                ))),
                Operator::Multiply => Ok(UntaggedValue::Primitive(Primitive::BigInt(
                    BigInt::from(*x) * y,
                ))),
                Operator::Divide => {
                    if y.is_zero() {
                        Ok(zero_division_error())
                    } else if x - (y * (x / y)) == BigInt::from(0) {
                        Ok(UntaggedValue::Primitive(Primitive::BigInt(
                            BigInt::from(*x) / y,
                        )))
                    } else {
                        Ok(UntaggedValue::Primitive(Primitive::Decimal(
                            bigdecimal::BigDecimal::from(*x)
                                / bigdecimal::BigDecimal::from(y.clone()),
                        )))
                    }
                }
                Operator::Modulo => {
                    if y.is_zero() {
                        Ok(zero_division_error())
                    } else {
                        Ok(UntaggedValue::Primitive(Primitive::BigInt(x % y)))
                    }
                }
                Operator::Pow => {
                    let prim_u32 = ToPrimitive::to_u32(y);

                    let sign = match x.is_negative() {
                        true => -1,
                        false => 1,
                    };

                    if !y.is_negative() {
                        match prim_u32 {
                            Some(num) => Ok(UntaggedValue::Primitive(Primitive::Int(
                                sign * (x.pow(num)),
                            ))),
                            _ => Err((left.type_name(), right.type_name())),
                        }
                    } else {
                        let yp = bigdecimal::ToPrimitive::to_f64(y).unwrap_or(0.0);
                        let xp = bigdecimal::ToPrimitive::to_f64(x).unwrap_or(0.0);
                        let pow =
                            bigdecimal::FromPrimitive::from_f64((sign as f64) * (xp.powf(yp)));
                        match pow {
                            Some(p) => Ok(UntaggedValue::Primitive(Primitive::Decimal(p))),
                            _ => Err((left.type_name(), right.type_name())),
                        }
                    }
                }
                _ => Err((left.type_name(), right.type_name())),
            },
            (Primitive::BigInt(x), Primitive::Int(y)) => match operator {
                Operator::Plus => Ok(UntaggedValue::Primitive(Primitive::BigInt(
                    x + BigInt::from(*y),
                ))),
                Operator::Minus => Ok(UntaggedValue::Primitive(Primitive::BigInt(
                    x - BigInt::from(*y),
                ))),
                Operator::Multiply => Ok(UntaggedValue::Primitive(Primitive::BigInt(
                    x * BigInt::from(*y),
                ))),
                Operator::Divide => {
                    if y.is_zero() {
                        Ok(zero_division_error())
                    } else if x - (y * (x / y)) == BigInt::from(0) {
                        Ok(UntaggedValue::Primitive(Primitive::BigInt(
                            x / BigInt::from(*y),
                        )))
                    } else {
                        Ok(UntaggedValue::Primitive(Primitive::Decimal(
                            bigdecimal::BigDecimal::from(x.clone())
                                / bigdecimal::BigDecimal::from(*y),
                        )))
                    }
                }
                Operator::Modulo => {
                    if y.is_zero() {
                        Ok(zero_division_error())
                    } else {
                        Ok(UntaggedValue::Primitive(Primitive::BigInt(x % y)))
                    }
                }
                Operator::Pow => {
                    let prim_u32 = ToPrimitive::to_u32(y);

                    let sign = match x.is_negative() {
                        true => -1,
                        false => 1,
                    };

                    if !y.is_negative() {
                        match prim_u32 {
                            Some(num) => Ok(UntaggedValue::Primitive(Primitive::BigInt(
                                (sign.to_bigint().unwrap_or_default()) * x.pow(num),
                            ))),
                            _ => Err((left.type_name(), right.type_name())),
                        }
                    } else {
                        let yp = bigdecimal::ToPrimitive::to_f64(y).unwrap_or(0.0);
                        let xp = bigdecimal::ToPrimitive::to_f64(x).unwrap_or(0.0);
                        let pow = bigdecimal::FromPrimitive::from_f64((sign as f64) * xp.powf(yp));
                        match pow {
                            Some(p) => Ok(UntaggedValue::Primitive(Primitive::Decimal(p))),
                            _ => Err((left.type_name(), right.type_name())),
                        }
                    }
                }
                _ => Err((left.type_name(), right.type_name())),
            },
            (Primitive::BigInt(x), Primitive::BigInt(y)) => match operator {
                Operator::Plus => Ok(UntaggedValue::Primitive(Primitive::BigInt(x + y))),
                Operator::Minus => Ok(UntaggedValue::Primitive(Primitive::BigInt(x - y))),
                Operator::Multiply => Ok(UntaggedValue::Primitive(Primitive::BigInt(x * y))),
                Operator::Divide => {
                    if y.is_zero() {
                        Ok(zero_division_error())
                    } else if x - (y * (x / y)) == BigInt::from(0) {
                        Ok(UntaggedValue::Primitive(Primitive::BigInt(x / y)))
                    } else {
                        Ok(UntaggedValue::Primitive(Primitive::Decimal(
                            bigdecimal::BigDecimal::from(x.clone())
                                / bigdecimal::BigDecimal::from(y.clone()),
                        )))
                    }
                }
                Operator::Modulo => {
                    if y.is_zero() {
                        Ok(zero_division_error())
                    } else {
                        Ok(UntaggedValue::Primitive(Primitive::BigInt(x % y)))
                    }
                }
                Operator::Pow => {
                    let prim_u32 = ToPrimitive::to_u32(y);

                    let sign = match x.is_negative() {
                        true => -1,
                        false => 1,
                    };

                    if !y.is_negative() {
                        match prim_u32 {
                            Some(num) => Ok(UntaggedValue::Primitive(Primitive::BigInt(
                                (sign.to_bigint().unwrap_or_default()).pow(num),
                            ))),
                            _ => Err((left.type_name(), right.type_name())),
                        }
                    } else {
                        let yp = bigdecimal::ToPrimitive::to_f64(y).unwrap_or(0.0);
                        let xp = bigdecimal::ToPrimitive::to_f64(x).unwrap_or(0.0);

                        let pow =
                            bigdecimal::FromPrimitive::from_f64((sign as f64) * (xp.powf(yp)));

                        match pow {
                            Some(p) => Ok(UntaggedValue::Primitive(Primitive::Decimal(p))),
                            _ => Err((left.type_name(), right.type_name())),
                        }
                    }
                }
                _ => Err((left.type_name(), right.type_name())),
            },
            (Primitive::Decimal(x), Primitive::Int(y)) => {
                let result = match operator {
                    Operator::Plus => Ok(x + bigdecimal::BigDecimal::from(*y)),
                    Operator::Minus => Ok(x - bigdecimal::BigDecimal::from(*y)),
                    Operator::Multiply => Ok(x * bigdecimal::BigDecimal::from(*y)),
                    Operator::Divide => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }
                        Ok(x / bigdecimal::BigDecimal::from(*y))
                    }
                    Operator::Modulo => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }
                        Ok(x % bigdecimal::BigDecimal::from(*y))
                    }

                    Operator::Pow => {
                        let sign = match x.is_negative() {
                            true => -1,
                            false => 1,
                        };

                        let yp = bigdecimal::ToPrimitive::to_f64(y).unwrap_or(0.0);
                        let xp = bigdecimal::ToPrimitive::to_f64(x).unwrap_or(0.0);
                        let pow =
                            bigdecimal::FromPrimitive::from_f64((sign as f64) * (xp.powf(yp)));
                        match pow {
                            Some(p) => Ok(p),
                            None => Err((left.type_name(), right.type_name())),
                        }
                    }
                    _ => Err((left.type_name(), right.type_name())),
                }?;
                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
            }
            (Primitive::Int(x), Primitive::Decimal(y)) => {
                let result = match operator {
                    Operator::Plus => Ok(bigdecimal::BigDecimal::from(*x) + y),
                    Operator::Minus => Ok(bigdecimal::BigDecimal::from(*x) - y),
                    Operator::Multiply => Ok(bigdecimal::BigDecimal::from(*x) * y),
                    Operator::Divide => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }
                        Ok(bigdecimal::BigDecimal::from(*x) / y)
                    }
                    Operator::Modulo => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }
                        Ok(bigdecimal::BigDecimal::from(*x) % y)
                    }

                    Operator::Pow => {
                        let sign = match x.is_negative() {
                            true => -1,
                            false => 1,
                        };

                        let yp = bigdecimal::ToPrimitive::to_f64(y).unwrap_or(0.0);
                        let xp = bigdecimal::ToPrimitive::to_f64(x).unwrap_or(0.0);
                        let pow =
                            bigdecimal::FromPrimitive::from_f64((sign as f64) * (xp.powf(yp)));
                        match pow {
                            Some(p) => Ok(p),
                            None => Err((left.type_name(), right.type_name())),
                        }
                    }
                    _ => Err((left.type_name(), right.type_name())),
                }?;
                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
            }
            (Primitive::Decimal(x), Primitive::BigInt(y)) => {
                let result = match operator {
                    Operator::Plus => Ok(x + bigdecimal::BigDecimal::from(y.clone())),
                    Operator::Minus => Ok(x - bigdecimal::BigDecimal::from(y.clone())),
                    Operator::Multiply => Ok(x * bigdecimal::BigDecimal::from(y.clone())),
                    Operator::Divide => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }
                        Ok(x / bigdecimal::BigDecimal::from(y.clone()))
                    }
                    Operator::Modulo => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }
                        Ok(x % bigdecimal::BigDecimal::from(y.clone()))
                    }

                    Operator::Pow => {
                        let sign = match x.is_negative() {
                            true => -1,
                            false => 1,
                        };

                        let yp = bigdecimal::ToPrimitive::to_f64(y).unwrap_or(0.0);
                        let xp = bigdecimal::ToPrimitive::to_f64(x).unwrap_or(0.0);
                        let pow =
                            bigdecimal::FromPrimitive::from_f64((sign as f64) * (xp.powf(yp)));
                        match pow {
                            Some(p) => Ok(p),
                            None => Err((left.type_name(), right.type_name())),
                        }
                    }
                    _ => Err((left.type_name(), right.type_name())),
                }?;
                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
            }
            (Primitive::BigInt(x), Primitive::Decimal(y)) => {
                let result = match operator {
                    Operator::Plus => Ok(bigdecimal::BigDecimal::from(x.clone()) + y),
                    Operator::Minus => Ok(bigdecimal::BigDecimal::from(x.clone()) - y),
                    Operator::Multiply => Ok(bigdecimal::BigDecimal::from(x.clone()) * y),
                    Operator::Divide => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }
                        Ok(bigdecimal::BigDecimal::from(x.clone()) / y)
                    }
                    Operator::Modulo => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }
                        Ok(bigdecimal::BigDecimal::from(x.clone()) % y)
                    }

                    Operator::Pow => {
                        let sign = match x.is_negative() {
                            true => -1,
                            false => 1,
                        };

                        let yp = bigdecimal::ToPrimitive::to_f64(y).unwrap_or(0.0);
                        let xp = bigdecimal::ToPrimitive::to_f64(x).unwrap_or(0.0);
                        let pow =
                            bigdecimal::FromPrimitive::from_f64((sign as f64) * (xp.powf(yp)));
                        match pow {
                            Some(p) => Ok(p),
                            None => Err((left.type_name(), right.type_name())),
                        }
                    }
                    _ => Err((left.type_name(), right.type_name())),
                }?;
                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
            }
            (Primitive::Decimal(x), Primitive::Decimal(y)) => {
                let result = match operator {
                    Operator::Plus => Ok(x + y),
                    Operator::Minus => Ok(x - y),
                    Operator::Multiply => Ok(x * y),
                    Operator::Divide => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }
                        Ok(x / y)
                    }
                    Operator::Modulo => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }
                        Ok(x % y)
                    }

                    Operator::Pow => {
                        let sign = match x.is_negative() {
                            true => -1,
                            false => 1,
                        };

                        let yp = bigdecimal::ToPrimitive::to_f64(y).unwrap_or(0.0);
                        let xp = bigdecimal::ToPrimitive::to_f64(x).unwrap_or(0.0);
                        let pow =
                            bigdecimal::FromPrimitive::from_f64((sign as f64) * (xp.powf(yp)));
                        match pow {
                            Some(p) => Ok(p),
                            None => Err((left.type_name(), right.type_name())),
                        }
                    }
                    _ => Err((left.type_name(), right.type_name())),
                }?;
                Ok(UntaggedValue::Primitive(Primitive::Decimal(result)))
            }
            (Primitive::Date(x), Primitive::Date(y)) => match operator {
                Operator::Minus => Ok(UntaggedValue::Primitive(Primitive::from(
                    x.signed_duration_since(*y),
                ))),
                _ => Err((left.type_name(), right.type_name())),
            },
            (Primitive::Date(x), Primitive::Duration(_)) => {
                let result = match operator {
                    Operator::Plus => {
                        // FIXME: Not sure if I could do something better with the Span.
                        match Primitive::into_chrono_duration(rhs.clone(), Span::unknown()) {
                            Ok(y) => match x.checked_add_signed(y) {
                                Some(value) => Ok(value),
                                None => Err(("Date", "Duration and date addition overflow")),
                            },
                            Err(_) => Err(("Date", "Duration overflow")),
                        }
                    }
                    Operator::Minus => {
                        match Primitive::into_chrono_duration(rhs.clone(), Span::unknown()) {
                            Ok(y) => match x.checked_sub_signed(y) {
                                Some(value) => Ok(value),
                                None => Err(("Date", "Duration and date addition overflow")),
                            },
                            Err(_) => Err(("Date", "Duration overflow")),
                        }
                    }
                    _ => Err((left.type_name(), right.type_name())),
                }?;
                Ok(UntaggedValue::Primitive(Primitive::Date(result)))
            }
            (Primitive::Duration(x), Primitive::Duration(y)) => {
                let result = match operator {
                    Operator::Plus => Ok(x + y),
                    Operator::Minus => Ok(x - y),
                    _ => Err((left.type_name(), right.type_name())),
                }?;

                Ok(UntaggedValue::Primitive(Primitive::Duration(result)))
            }
            (Primitive::Int(x), Primitive::Duration(y)) => {
                let result = match operator {
                    Operator::Plus => Ok(x + y),
                    Operator::Minus => Ok(x - y),
                    _ => Err((left.type_name(), right.type_name())),
                }?;

                Ok(UntaggedValue::Primitive(Primitive::Duration(result)))
            }
            (Primitive::Duration(x), Primitive::Decimal(y)) => {
                let result = match operator {
                    Operator::Divide => {
                        if y.is_zero() {
                            return Ok(zero_division_error());
                        }

                        let y = y.as_bigint_and_exponent();
                        Ok(x / y.0)
                    }
                    _ => Err((left.type_name(), right.type_name())),
                }?;

                Ok(UntaggedValue::Primitive(Primitive::Duration(result)))
            }
            (Primitive::String(x), Primitive::String(y)) => {
                let mut new_string = x.clone();
                new_string.push_str(y);
                Ok(UntaggedValue::Primitive(Primitive::String(new_string)))
            }
            _ => Err((left.type_name(), right.type_name())),
        },
        _ => Err((left.type_name(), right.type_name())),
    }
}

/// If left is {{ Operator }} right
pub fn compare_values(
    operator: Operator,
    left: &UntaggedValue,
    right: &UntaggedValue,
) -> Result<bool, (&'static str, &'static str)> {
    let coerced = coerce_compare(left, right)?;
    let ordering = coerced.compare();

    use std::cmp::Ordering;

    let result = matches!(
        (operator, ordering),
        (Operator::Equal, Ordering::Equal)
            | (Operator::GreaterThan, Ordering::Greater)
            | (Operator::GreaterThanOrEqual, Ordering::Greater)
            | (Operator::GreaterThanOrEqual, Ordering::Equal)
            | (Operator::LessThan, Ordering::Less)
            | (Operator::LessThanOrEqual, Ordering::Less)
            | (Operator::LessThanOrEqual, Ordering::Equal)
            | (Operator::NotEqual, Ordering::Greater)
            | (Operator::NotEqual, Ordering::Less)
    );

    Ok(result)
}

pub fn plain_type<'a>(value: impl Into<&'a UntaggedValue>, width: usize) -> String {
    Type::from_value(value.into()).plain_string(width)
}

pub fn format_type<'a>(value: impl Into<&'a UntaggedValue>, width: usize) -> String {
    Type::from_value(value.into()).colored_string(width)
}

pub fn format_leaf<'a>(value: impl Into<&'a UntaggedValue>) -> DebugDocBuilder {
    InlineShape::from_value(value.into()).format().pretty()
}

pub fn style_leaf<'a>(
    value: impl Into<&'a UntaggedValue>,
    color_hash_map: &HashMap<String, nu_ansi_term::Style>,
) -> TextStyle {
    match value.into() {
        UntaggedValue::Primitive(p) => {
            // This is just to return the name of the type so that style_primitive
            // can work on a string versus a type like String("some_text")
            let str: &str = &p.to_string();
            let str_len = str.len();
            let paren_index = str.find('(').unwrap_or(str_len - 1);
            let prim_type = str[0..paren_index].to_string();
            style_primitive(&prim_type, color_hash_map)
        }
        _ => TextStyle::basic_left(),
    }
}

pub fn format_for_column<'a>(
    value: impl Into<&'a UntaggedValue>,
    column: impl Into<Column>,
) -> DebugDocBuilder {
    InlineShape::from_value(value.into())
        .format_for_column(column)
        .pretty()
}

#[cfg(test)]
mod tests {
    use super::Date as d;
    use super::UntaggedValue as v;
    use super::{compute_values, merge_values};
    use nu_protocol::hir::Operator;
    use nu_protocol::{Primitive, UntaggedValue};
    use nu_source::TaggedItem;

    use indexmap::indexmap;

    #[test]
    fn merges_tables() {
        let (author_1_date, author_2_date) = (
            "2020-04-29".to_string().tagged_unknown(),
            "2019-10-10".to_string().tagged_unknown(),
        );

        let table_author_row = v::row(indexmap! {
            "name".into() => v::string("Andrés").into_untagged_value(),
            "country".into() => v::string("EC").into_untagged_value(),
            "date".into() => d::naive_from_str(author_1_date.borrow_tagged()).unwrap().into_untagged_value()
        });

        let other_table_author_row = v::row(indexmap! {
            "name".into() => v::string("YK").into_untagged_value(),
            "country".into() => v::string("US").into_untagged_value(),
            "date".into() => d::naive_from_str(author_2_date.borrow_tagged()).unwrap().into_untagged_value()
        });

        assert_eq!(
            other_table_author_row,
            merge_values(&table_author_row, &other_table_author_row).unwrap()
        );
    }

    #[test]
    fn pow_operator_negatives_and_decimals() {
        // test 2 ** 2
        let result_one = compute_values(
            Operator::Pow,
            &UntaggedValue::Primitive(Primitive::Int(2)),
            &UntaggedValue::Primitive(Primitive::Int(2)),
        );

        assert_eq!(
            result_one.unwrap(),
            UntaggedValue::Primitive(Primitive::Int(4))
        );

        // test 2 ** 2.0
        let rhs_decimal = bigdecimal::FromPrimitive::from_f64(2.0).unwrap();

        let result_two = compute_values(
            Operator::Pow,
            &UntaggedValue::Primitive(Primitive::Int(2)),
            &UntaggedValue::Primitive(Primitive::Decimal(rhs_decimal)),
        );

        let should_equal_four_decimal = bigdecimal::FromPrimitive::from_f64(4.0).unwrap();

        assert_eq!(
            result_two.unwrap(),
            UntaggedValue::Primitive(Primitive::Decimal(should_equal_four_decimal))
        );

        // test 2.0 ** 2.0
        let rhs_decimal = bigdecimal::FromPrimitive::from_f64(2.0).unwrap();
        let lhs_decimal = bigdecimal::FromPrimitive::from_f64(2.0).unwrap();
        let should_equal_four_decimal = bigdecimal::FromPrimitive::from_f64(4.0).unwrap();

        let result_three = compute_values(
            Operator::Pow,
            &UntaggedValue::Primitive(Primitive::Decimal(lhs_decimal)),
            &UntaggedValue::Primitive(Primitive::Decimal(rhs_decimal)),
        );

        assert_eq!(
            result_three.unwrap(),
            UntaggedValue::Primitive(Primitive::Decimal(should_equal_four_decimal))
        );

        // test 2 ** -2
        let result_four = compute_values(
            Operator::Pow,
            &UntaggedValue::Primitive(Primitive::Int(2)),
            &UntaggedValue::Primitive(Primitive::Int(-2)),
        );

        let should_equal_zero_decimal = bigdecimal::FromPrimitive::from_f64(0.25).unwrap();

        assert_eq!(
            result_four.unwrap(),
            UntaggedValue::Primitive(Primitive::Decimal(should_equal_zero_decimal))
        );

        // test -2 ** -2
        let result_five = compute_values(
            Operator::Pow,
            &UntaggedValue::Primitive(Primitive::Int(-2)),
            &UntaggedValue::Primitive(Primitive::Int(-2)),
        );

        let should_equal_neg_zero_decimal = bigdecimal::FromPrimitive::from_f64(-0.25).unwrap();

        assert_eq!(
            result_five.unwrap(),
            UntaggedValue::Primitive(Primitive::Decimal(should_equal_neg_zero_decimal))
        );

        // test -2 ** 2
        let result_six = compute_values(
            Operator::Pow,
            &UntaggedValue::Primitive(Primitive::Int(-2)),
            &UntaggedValue::Primitive(Primitive::Int(2)),
        );

        assert_eq!(
            result_six.unwrap(),
            UntaggedValue::Primitive(Primitive::Int(-4))
        );

        // test -2.0 ** 2
        let lhs_decimal = bigdecimal::FromPrimitive::from_f64(-2.0).unwrap();
        let should_equal_neg_four_decimal = bigdecimal::FromPrimitive::from_f64(-4.0).unwrap();

        let result_seven = compute_values(
            Operator::Pow,
            &UntaggedValue::Primitive(Primitive::Decimal(lhs_decimal)),
            &UntaggedValue::Primitive(Primitive::Int(2)),
        );

        // Need to validate
        assert_eq!(
            result_seven.unwrap(),
            UntaggedValue::Primitive(Primitive::Decimal(should_equal_neg_four_decimal))
        );
    }
}