use std::fmt;

use crate::{
    calc_result::CalcResult,
    expressions::{
        lexer::util::get_tokens,
        parser::Node,
        token::{Error, OpSum, TokenType},
        types::CellReferenceIndex,
    },
    model::Model,
    number_format::to_precision,
};

/// This implements all functions with complex arguments in the standard
/// NOTE: If performance is ever needed we should have a new entry in CalcResult,
/// So this functions will return CalcResult::Complex(x,y, Suffix)
/// and not having to parse it over and over again.

#[derive(PartialEq, Debug)]
enum Suffix {
    I,
    J,
}

impl fmt::Display for Suffix {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            Suffix::I => write!(f, "i"),
            Suffix::J => write!(f, "j"),
        }
    }
}

struct Complex {
    x: f64,
    y: f64,
    suffix: Suffix,
}

impl fmt::Display for Complex {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let x = to_precision(self.x, 15);
        let y = to_precision(self.y, 15);
        let suffix = &self.suffix;
        // it is a bit weird what Excel does but it seems it uses general notation for
        // numbers > 1e-20 and scientific notation for the rest
        let y_str = if y.abs() <= 9e-20 {
            format!("{:E}", y)
        } else if y == 1.0 {
            "".to_string()
        } else if y == -1.0 {
            "-".to_string()
        } else {
            format!("{}", y)
        };
        let x_str = if x.abs() <= 9e-20 {
            format!("{:E}", x)
        } else {
            format!("{}", x)
        };
        if y == 0.0 && x == 0.0 {
            write!(f, "0")
        } else if y == 0.0 {
            write!(f, "{x_str}")
        } else if x == 0.0 {
            write!(f, "{y_str}{suffix}")
        } else if y > 0.0 {
            write!(f, "{x_str}+{y_str}{suffix}")
        } else {
            write!(f, "{x_str}{y_str}{suffix}")
        }
    }
}

fn parse_complex_number(s: &str) -> Result<(f64, f64, Suffix), String> {
    // Check for i, j, -i, -j
    let (sign, s) = match s.strip_prefix('-') {
        Some(r) => (-1.0, r),
        None => (1.0, s),
    };
    match s {
        "i" => return Ok((0.0, sign * 1.0, Suffix::I)),
        "j" => return Ok((0.0, sign * 1.0, Suffix::J)),
        _ => {
            // Let it go
        }
    };

    // TODO: This is an overuse
    let tokens = get_tokens(s);

    // There has to be 1, 2 3, or 4 tokens
    // number
    // number suffix
    // number1+suffix
    // number1+number2 suffix

    match tokens.len() {
        1 => {
            // Real number
            let number1 = match tokens[0].token {
                TokenType::Number(f) => f,
                _ => return Err(format!("Not a complex number: {s}")),
            };
            // i is the default
            Ok((sign * number1, 0.0, Suffix::I))
        }
        2 => {
            // number2 i
            let number2 = match tokens[0].token {
                TokenType::Number(f) => f,
                _ => return Err(format!("Not a complex number: {s}")),
            };
            let suffix = match &tokens[1].token {
                TokenType::Ident(w) => match w.as_str() {
                    "i" => Suffix::I,
                    "j" => Suffix::J,
                    _ => return Err(format!("Not a complex number: {s}")),
                },
                _ => {
                    return Err(format!("Not a complex number: {s}"));
                }
            };
            Ok((0.0, sign * number2, suffix))
        }
        3 => {
            let number1 = match tokens[0].token {
                TokenType::Number(f) => f,
                _ => return Err(format!("Not a complex number: {s}")),
            };
            let operation = match &tokens[1].token {
                TokenType::Addition(f) => f,
                _ => return Err(format!("Not a complex number: {s}")),
            };
            let suffix = match &tokens[2].token {
                TokenType::Ident(w) => match w.as_str() {
                    "i" => Suffix::I,
                    "j" => Suffix::J,
                    _ => return Err(format!("Not a complex number: {s}")),
                },
                _ => {
                    return Err(format!("Not a complex number: {s}"));
                }
            };
            let number2 = if matches!(operation, OpSum::Minus) {
                -1.0
            } else {
                1.0
            };
            Ok((sign * number1, number2, suffix))
        }
        4 => {
            let number1 = match tokens[0].token {
                TokenType::Number(f) => f,
                _ => return Err(format!("Not a complex number: {s}")),
            };
            let operation = match &tokens[1].token {
                TokenType::Addition(f) => f,
                _ => return Err(format!("Not a complex number: {s}")),
            };
            let mut number2 = match tokens[2].token {
                TokenType::Number(f) => f,
                _ => return Err(format!("Not a complex number: {s}")),
            };
            let suffix = match &tokens[3].token {
                TokenType::Ident(w) => match w.as_str() {
                    "i" => Suffix::I,
                    "j" => Suffix::J,
                    _ => return Err(format!("Not a complex number: {s}")),
                },
                _ => {
                    return Err(format!("Not a complex number: {s}"));
                }
            };
            if matches!(operation, OpSum::Minus) {
                number2 = -number2
            }
            Ok((sign * number1, number2, suffix))
        }
        _ => Err(format!("Not a complex number: {s}")),
    }
}

impl Model {
    fn get_complex_number(
        &mut self,
        node: &Node,
        cell: CellReferenceIndex,
    ) -> Result<(f64, f64, Suffix), CalcResult> {
        let value = match self.get_string(node, cell) {
            Ok(s) => s,
            Err(s) => return Err(s),
        };
        if value.is_empty() {
            return Ok((0.0, 0.0, Suffix::I));
        }
        match parse_complex_number(&value) {
            Ok(s) => Ok(s),
            Err(message) => Err(CalcResult::new_error(Error::NUM, cell, message)),
        }
    }
    // COMPLEX(real_num, i_num, [suffix])
    pub(crate) fn fn_complex(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if !(2..=3).contains(&args.len()) {
            return CalcResult::new_args_number_error(cell);
        }
        let x = match self.get_number(&args[0], cell) {
            Ok(s) => s,
            Err(s) => return s,
        };
        let y = match self.get_number(&args[1], cell) {
            Ok(s) => s,
            Err(s) => return s,
        };
        let suffix = if args.len() == 3 {
            match self.get_string(&args[2], cell) {
                Ok(s) => {
                    if s == "i" || s.is_empty() {
                        Suffix::I
                    } else if s == "j" {
                        Suffix::J
                    } else {
                        return CalcResult::new_error(
                            Error::VALUE,
                            cell,
                            "Invalid suffix".to_string(),
                        );
                    }
                }
                Err(s) => return s,
            }
        } else {
            Suffix::I
        };

        let complex = Complex { x, y, suffix };
        CalcResult::String(complex.to_string())
    }

    pub(crate) fn fn_imabs(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, _) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        CalcResult::Number(f64::sqrt(x * x + y * y))
    }

    pub(crate) fn fn_imaginary(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (_, y, _) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        CalcResult::Number(y)
    }
    pub(crate) fn fn_imargument(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, _) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        if x == 0.0 && y == 0.0 {
            return CalcResult::new_error(Error::DIV, cell, "Division by zero".to_string());
        }
        let angle = f64::atan2(y, x);
        CalcResult::Number(angle)
    }
    pub(crate) fn fn_imconjugate(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        let complex = Complex { x, y: -y, suffix };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imcos(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let value = match self.get_string(&args[0], cell) {
            Ok(s) => s,
            Err(s) => return s,
        };
        let (x, y, suffix) = match parse_complex_number(&value) {
            Ok(s) => s,
            Err(message) => return CalcResult::new_error(Error::NUM, cell, message),
        };

        let complex = Complex {
            x: x.cos() * y.cosh(),
            y: -x.sin() * y.sinh(),
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imcosh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let value = match self.get_string(&args[0], cell) {
            Ok(s) => s,
            Err(s) => return s,
        };
        let (x, y, suffix) = match parse_complex_number(&value) {
            Ok(s) => s,
            Err(message) => return CalcResult::new_error(Error::NUM, cell, message),
        };

        let complex = Complex {
            x: x.cosh() * y.cos(),
            y: x.sinh() * y.sin(),
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imcot(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let value = match self.get_string(&args[0], cell) {
            Ok(s) => s,
            Err(s) => return s,
        };
        let (x, y, suffix) = match parse_complex_number(&value) {
            Ok(s) => s,
            Err(message) => return CalcResult::new_error(Error::NUM, cell, message),
        };

        if x == 0.0 && y != 0.0 {
            let complex = Complex {
                x: 0.0,
                y: -1.0 / y.tanh(),
                suffix,
            };
            return CalcResult::String(complex.to_string());
        } else if y == 0.0 {
            let complex = Complex {
                x: 1.0 / x.tan(),
                y: 0.0,
                suffix,
            };
            return CalcResult::String(complex.to_string());
        }

        let x_cot = 1.0 / x.tan();
        let y_coth = 1.0 / y.tanh();

        let t = x_cot * x_cot + y_coth * y_coth;
        let x = (x_cot * y_coth * y_coth - x_cot) / t;
        let y = (-x_cot * x_cot * y_coth - y_coth) / t;

        if x.is_infinite() || y.is_infinite() || x.is_nan() || y.is_nan() {
            return CalcResult::new_error(Error::NUM, cell, "Invalid operation".to_string());
        }

        let complex = Complex { x, y, suffix };
        CalcResult::String(complex.to_string())
    }

    pub(crate) fn fn_imcsc(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let value = match self.get_string(&args[0], cell) {
            Ok(s) => s,
            Err(s) => return s,
        };
        let (x, y, suffix) = match parse_complex_number(&value) {
            Ok(s) => s,
            Err(message) => return CalcResult::new_error(Error::NUM, cell, message),
        };
        let x_cos = x.cos();
        let x_sin = x.sin();

        let y_cosh = y.cosh();
        let y_sinh = y.sinh();

        let t = x_sin * x_sin * y_cosh * y_cosh + x_cos * x_cos * y_sinh * y_sinh;

        let complex = Complex {
            x: x_sin * y_cosh / t,
            y: -x_cos * y_sinh / t,
            suffix,
        };
        CalcResult::String(complex.to_string())
    }

    pub(crate) fn fn_imcsch(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let value = match self.get_string(&args[0], cell) {
            Ok(s) => s,
            Err(s) => return s,
        };
        let (x, y, suffix) = match parse_complex_number(&value) {
            Ok(s) => s,
            Err(message) => return CalcResult::new_error(Error::NUM, cell, message),
        };
        let x_cosh = x.cosh();
        let x_sinh = x.sinh();

        let y_cos = y.cos();
        let y_sin = y.sin();

        let t = x_sinh * x_sinh * y_cos * y_cos + x_cosh * x_cosh * y_sin * y_sin;

        let complex = Complex {
            x: x_sinh * y_cos / t,
            y: -x_cosh * y_sin / t,
            suffix,
        };
        CalcResult::String(complex.to_string())
    }

    pub(crate) fn fn_imdiv(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 2 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x1, y1, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        let (x2, y2, suffix2) = match self.get_complex_number(&args[1], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        if suffix != suffix2 {
            return CalcResult::new_error(Error::VALUE, cell, "Different suffixes".to_string());
        }
        let t = x2 * x2 + y2 * y2;
        if t == 0.0 {
            return CalcResult::new_error(Error::NUM, cell, "Invalid".to_string());
        }
        let complex = Complex {
            x: (x1 * x2 + y1 * y2) / t,
            y: (-x1 * y2 + y1 * x2) / t,
            suffix,
        };
        CalcResult::String(complex.to_string())
    }

    pub(crate) fn fn_imexp(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        let complex = Complex {
            x: x.exp() * y.cos(),
            y: x.exp() * y.sin(),
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imln(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        let r = f64::sqrt(x * x + y * y);
        let a = f64::atan2(y, x);

        let complex = Complex {
            x: r.ln(),
            y: a,
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imlog10(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        let r = f64::sqrt(x * x + y * y);
        let a = f64::atan2(y, x);

        let complex = Complex {
            x: r.log10(),
            y: a * f64::log10(f64::exp(1.0)),
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imlog2(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        let r = f64::sqrt(x * x + y * y);
        let a = f64::atan2(y, x);

        let complex = Complex {
            x: r.log2(),
            y: a * f64::log2(f64::exp(1.0)),
            suffix,
        };
        CalcResult::String(complex.to_string())
    }

    // IMPOWER(imnumber, power)
    // If $(r, \theta)$ is the polar representation the formula is:
    //  $$ x = r^n*\cos(n\dot\theta), y = r^n*\csin(n\dot\theta) $
    pub(crate) fn fn_impower(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 2 {
            return CalcResult::new_args_number_error(cell);
        }

        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        let n = match self.get_number_no_bools(&args[1], cell) {
            Ok(f) => f,
            Err(s) => return s,
        };

        // if n == n.trunc() && n < 10.0 {
        //     // for small powers we compute manually
        //     let (mut x0, mut y0) = (x, y);
        //     for _ in 1..(n.trunc() as i32) {
        //         (x0, y0) = (x0 * x - y0 * y, x0 * y + y0 * x);
        //     }
        //     let complex = Complex {
        //         x: x0,
        //         y: y0,
        //         suffix,
        //     };
        //     return CalcResult::String(complex.to_string());
        // };

        let r = f64::sqrt(x * x + y * y);
        let a = f64::atan2(y, x);

        let x = r.powf(n) * f64::cos(a * n);
        let y = r.powf(n) * f64::sin(a * n);

        if x.is_infinite() || y.is_infinite() || x.is_nan() || y.is_nan() {
            return CalcResult::new_error(Error::NUM, cell, "Invalid operation".to_string());
        }

        let complex = Complex { x, y, suffix };
        CalcResult::String(complex.to_string())
    }

    pub(crate) fn fn_improduct(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 2 {
            return CalcResult::new_args_number_error(cell);
        }

        let (x1, y1, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        let (x2, y2, suffix2) = match self.get_complex_number(&args[1], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        if suffix != suffix2 {
            return CalcResult::new_error(Error::VALUE, cell, "Different suffixes".to_string());
        }
        let complex = Complex {
            x: x1 * x2 - y1 * y2,
            y: x1 * y2 + y1 * x2,
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imreal(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, _, _) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        CalcResult::Number(x)
    }
    pub(crate) fn fn_imsec(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        let x_cos = x.cos();
        let x_sin = x.sin();

        let y_cosh = y.cosh();
        let y_sinh = y.sinh();

        let t = x_cos * x_cos * y_cosh * y_cosh + x_sin * x_sin * y_sinh * y_sinh;

        let complex = Complex {
            x: x_cos * y_cosh / t,
            y: x_sin * y_sinh / t,
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imsech(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        let x_cosh = x.cosh();
        let x_sinh = x.sinh();

        let y_cos = y.cos();
        let y_sin = y.sin();

        let t = x_cosh * x_cosh * y_cos * y_cos + x_sinh * x_sinh * y_sin * y_sin;

        let complex = Complex {
            x: x_cosh * y_cos / t,
            y: -x_sinh * y_sin / t,
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imsin(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        let complex = Complex {
            x: x.sin() * y.cosh(),
            y: x.cos() * y.sinh(),
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imsinh(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        let complex = Complex {
            x: x.sinh() * y.cos(),
            y: x.cosh() * y.sin(),
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imsqrt(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        let r = f64::sqrt(x * x + y * y).sqrt();
        let a = f64::atan2(y, x);

        let complex = Complex {
            x: r * f64::cos(a / 2.0),
            y: r * f64::sin(a / 2.0),
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
    pub(crate) fn fn_imsub(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 2 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x1, y1, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        let (x2, y2, suffix2) = match self.get_complex_number(&args[1], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        if suffix != suffix2 {
            return CalcResult::new_error(Error::VALUE, cell, "Different suffixes".to_string());
        }
        let complex = Complex {
            x: x1 - x2,
            y: y1 - y2,
            suffix,
        };
        CalcResult::String(complex.to_string())
    }

    pub(crate) fn fn_imsum(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 2 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x1, y1, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        let (x2, y2, suffix2) = match self.get_complex_number(&args[1], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };
        if suffix != suffix2 {
            return CalcResult::new_error(Error::VALUE, cell, "Different suffixes".to_string());
        }
        let complex = Complex {
            x: x1 + x2,
            y: y1 + y2,
            suffix,
        };
        CalcResult::String(complex.to_string())
    }

    pub(crate) fn fn_imtan(&mut self, args: &[Node], cell: CellReferenceIndex) -> CalcResult {
        if args.len() != 1 {
            return CalcResult::new_args_number_error(cell);
        }
        let (x, y, suffix) = match self.get_complex_number(&args[0], cell) {
            Ok(s) => s,
            Err(error) => return error,
        };

        let x_tan = x.tan();
        let y_tanh = y.tanh();

        let t = 1.0 + x_tan * x_tan * y_tanh * y_tanh;

        let complex = Complex {
            x: (x_tan - x_tan * y_tanh * y_tanh) / t,
            y: (y_tanh + x_tan * x_tan * y_tanh) / t,
            suffix,
        };
        CalcResult::String(complex.to_string())
    }
}

#[cfg(test)]
mod tests {
    use crate::functions::engineering::complex::Suffix;

    use super::parse_complex_number as parse;

    #[test]
    fn test_parse_complex() {
        assert_eq!(parse("1+2i"), Ok((1.0, 2.0, Suffix::I)));
        assert_eq!(parse("2i"), Ok((0.0, 2.0, Suffix::I)));
        assert_eq!(parse("7.5"), Ok((7.5, 0.0, Suffix::I)));
        assert_eq!(parse("-7.5"), Ok((-7.5, 0.0, Suffix::I)));
        assert_eq!(parse("7-5i"), Ok((7.0, -5.0, Suffix::I)));
        assert_eq!(parse("i"), Ok((0.0, 1.0, Suffix::I)));
        assert_eq!(parse("7+i"), Ok((7.0, 1.0, Suffix::I)));
        assert_eq!(parse("7-i"), Ok((7.0, -1.0, Suffix::I)));
        assert_eq!(parse("-i"), Ok((0.0, -1.0, Suffix::I)));
        assert_eq!(parse("0"), Ok((0.0, 0.0, Suffix::I)));
    }
}