use crate::postgres::common::*;
use crate::Decimal;
use diesel::{
    deserialize::{self, FromSql},
    pg::data_types::PgNumeric,
    pg::Pg,
    serialize::{self, Output, ToSql},
    sql_types::Numeric,
};
use std::error;

impl<'a> TryFrom<&'a PgNumeric> for Decimal {
    type Error = Box<dyn error::Error + Send + Sync>;

    fn try_from(numeric: &'a PgNumeric) -> deserialize::Result<Self> {
        let (neg, weight, scale, digits) = match *numeric {
            PgNumeric::Positive {
                weight,
                scale,
                ref digits,
            } => (false, weight, scale, digits),
            PgNumeric::Negative {
                weight,
                scale,
                ref digits,
            } => (true, weight, scale, digits),
            PgNumeric::NaN => return Err(Box::from("NaN is not supported in Decimal")),
        };

        Ok(Self::from_postgres(PostgresDecimal {
            neg,
            weight,
            scale,
            digits: digits.iter().copied().map(|v| v.try_into().unwrap()),
        }))
    }
}

impl TryFrom<PgNumeric> for Decimal {
    type Error = Box<dyn error::Error + Send + Sync>;

    fn try_from(numeric: PgNumeric) -> deserialize::Result<Self> {
        (&numeric).try_into()
    }
}

impl<'a> From<&'a Decimal> for PgNumeric {
    fn from(decimal: &'a Decimal) -> Self {
        let PostgresDecimal {
            neg,
            weight,
            scale,
            digits,
        } = decimal.to_postgres();

        if neg {
            PgNumeric::Negative { digits, scale, weight }
        } else {
            PgNumeric::Positive { digits, scale, weight }
        }
    }
}

impl From<Decimal> for PgNumeric {
    fn from(decimal: Decimal) -> Self {
        (&decimal).into()
    }
}

#[cfg(all(feature = "diesel1", not(feature = "diesel2")))]
impl ToSql<Numeric, Pg> for Decimal {
    fn to_sql<W: std::io::Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
        let numeric = PgNumeric::from(self);
        ToSql::<Numeric, Pg>::to_sql(&numeric, out)
    }
}

#[cfg(feature = "diesel2")]
impl ToSql<Numeric, Pg> for Decimal {
    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> serialize::Result {
        let numeric = PgNumeric::from(self);
        ToSql::<Numeric, Pg>::to_sql(&numeric, &mut out.reborrow())
    }
}

#[cfg(all(feature = "diesel1", not(feature = "diesel2")))]
impl FromSql<Numeric, Pg> for Decimal {
    fn from_sql(numeric: Option<&[u8]>) -> deserialize::Result<Self> {
        PgNumeric::from_sql(numeric)?.try_into()
    }
}

#[cfg(feature = "diesel2")]
impl FromSql<Numeric, Pg> for Decimal {
    fn from_sql(numeric: diesel::pg::PgValue) -> deserialize::Result<Self> {
        PgNumeric::from_sql(numeric)?.try_into()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use core::str::FromStr;

    #[test]
    fn test_unnecessary_zeroes() {
        fn extract(value: &str) -> Decimal {
            Decimal::from_str(value).unwrap()
        }

        let tests = &[
            ("0.000001660"),
            ("41.120255926293000"),
            ("0.5538973300"),
            ("08883.55986854293100"),
            ("0.0000_0000_0016_6000_00"),
            ("0.00000166650000"),
            ("1666500000000"),
            ("1666500000000.0000054500"),
            ("8944.000000000000"),
        ];

        for &value in tests {
            let value = extract(value);
            let pg = PgNumeric::from(value);
            let dec = Decimal::try_from(pg).unwrap();
            assert_eq!(dec, value);
        }
    }

    #[test]
    fn decimal_to_pgnumeric_converts_digits_to_base_10000() {
        let decimal = Decimal::from_str("1").unwrap();
        let expected = PgNumeric::Positive {
            weight: 0,
            scale: 0,
            digits: vec![1],
        };
        assert_eq!(expected, decimal.into());

        let decimal = Decimal::from_str("10").unwrap();
        let expected = PgNumeric::Positive {
            weight: 0,
            scale: 0,
            digits: vec![10],
        };
        assert_eq!(expected, decimal.into());

        let decimal = Decimal::from_str("10000").unwrap();
        let expected = PgNumeric::Positive {
            weight: 1,
            scale: 0,
            digits: vec![1, 0],
        };
        assert_eq!(expected, decimal.into());

        let decimal = Decimal::from_str("10001").unwrap();
        let expected = PgNumeric::Positive {
            weight: 1,
            scale: 0,
            digits: vec![1, 1],
        };
        assert_eq!(expected, decimal.into());

        let decimal = Decimal::from_str("100000000").unwrap();
        let expected = PgNumeric::Positive {
            weight: 2,
            scale: 0,
            digits: vec![1, 0, 0],
        };
        assert_eq!(expected, decimal.into());
    }

    #[test]
    fn decimal_to_pg_numeric_properly_adjusts_scale() {
        let decimal = Decimal::from_str("1").unwrap();
        let expected = PgNumeric::Positive {
            weight: 0,
            scale: 0,
            digits: vec![1],
        };
        assert_eq!(expected, decimal.into());

        let decimal = Decimal::from_str("1.0").unwrap();
        let expected = PgNumeric::Positive {
            weight: 0,
            scale: 1,
            digits: vec![1],
        };
        assert_eq!(expected, decimal.into());

        let decimal = Decimal::from_str("1.1").unwrap();
        let expected = PgNumeric::Positive {
            weight: 0,
            scale: 1,
            digits: vec![1, 1000],
        };
        assert_eq!(expected, decimal.into());

        let decimal = Decimal::from_str("1.10").unwrap();
        let expected = PgNumeric::Positive {
            weight: 0,
            scale: 2,
            digits: vec![1, 1000],
        };
        assert_eq!(expected, decimal.into());

        let decimal = Decimal::from_str("100000000.0001").unwrap();
        let expected = PgNumeric::Positive {
            weight: 2,
            scale: 4,
            digits: vec![1, 0, 0, 1],
        };
        assert_eq!(expected, decimal.into());

        let decimal = Decimal::from_str("0.1").unwrap();
        let expected = PgNumeric::Positive {
            weight: -1,
            scale: 1,
            digits: vec![1000],
        };
        assert_eq!(expected, decimal.into());
    }

    #[test]
    fn decimal_to_pg_numeric_retains_sign() {
        let decimal = Decimal::from_str("123.456").unwrap();
        let expected = PgNumeric::Positive {
            weight: 0,
            scale: 3,
            digits: vec![123, 4560],
        };
        assert_eq!(expected, decimal.into());

        let decimal = Decimal::from_str("-123.456").unwrap();
        let expected = PgNumeric::Negative {
            weight: 0,
            scale: 3,
            digits: vec![123, 4560],
        };
        assert_eq!(expected, decimal.into());
    }

    #[test]
    fn pg_numeric_to_decimal_works() {
        let expected = Decimal::from_str("50").unwrap();
        let pg_numeric = PgNumeric::Positive {
            weight: 0,
            scale: 0,
            digits: vec![50],
        };
        let res: Decimal = pg_numeric.try_into().unwrap();
        assert_eq!(res, expected);
        let expected = Decimal::from_str("123.456").unwrap();
        let pg_numeric = PgNumeric::Positive {
            weight: 0,
            scale: 3,
            digits: vec![123, 4560],
        };
        let res: Decimal = pg_numeric.try_into().unwrap();
        assert_eq!(res, expected);

        let expected = Decimal::from_str("-56.78").unwrap();
        let pg_numeric = PgNumeric::Negative {
            weight: 0,
            scale: 2,
            digits: vec![56, 7800],
        };
        let res: Decimal = pg_numeric.try_into().unwrap();
        assert_eq!(res, expected);

        // Verify no trailing zeroes are lost.

        let expected = Decimal::from_str("1.100").unwrap();
        let pg_numeric = PgNumeric::Positive {
            weight: 0,
            scale: 3,
            digits: vec![1, 1000],
        };
        let res: Decimal = pg_numeric.try_into().unwrap();
        assert_eq!(res.to_string(), expected.to_string());

        // To represent 5.00, Postgres can return either [5, 0] as the list of digits.
        let expected = Decimal::from_str("5.00").unwrap();
        let pg_numeric = PgNumeric::Positive {
            weight: 0,
            scale: 2,

            digits: vec![5, 0],
        };
        let res: Decimal = pg_numeric.try_into().unwrap();
        assert_eq!(res.to_string(), expected.to_string());

        // To represent 5.00, Postgres can return [5] as the list of digits.
        let expected = Decimal::from_str("5.00").unwrap();
        let pg_numeric = PgNumeric::Positive {
            weight: 0,
            scale: 2,
            digits: vec![5],
        };
        let res: Decimal = pg_numeric.try_into().unwrap();
        assert_eq!(res.to_string(), expected.to_string());

        let expected = Decimal::from_str("3.1415926535897932384626433833").unwrap();
        let pg_numeric = PgNumeric::Positive {
            weight: 0,
            scale: 30,
            digits: vec![3, 1415, 9265, 3589, 7932, 3846, 2643, 3832, 7950, 2800],
        };
        let res: Decimal = pg_numeric.try_into().unwrap();
        assert_eq!(res.to_string(), expected.to_string());

        let expected = Decimal::from_str("3.1415926535897932384626433833").unwrap();
        let pg_numeric = PgNumeric::Positive {
            weight: 0,
            scale: 34,
            digits: vec![3, 1415, 9265, 3589, 7932, 3846, 2643, 3832, 7950, 2800],
        };

        let res: Decimal = pg_numeric.try_into().unwrap();
        assert_eq!(res.to_string(), expected.to_string());

        let expected = Decimal::from_str("1.2345678901234567890123456790").unwrap();
        let pg_numeric = PgNumeric::Positive {
            weight: 0,
            scale: 34,
            digits: vec![1, 2345, 6789, 0123, 4567, 8901, 2345, 6789, 5000, 0],
        };

        let res: Decimal = pg_numeric.try_into().unwrap();
        assert_eq!(res.to_string(), expected.to_string());
    }
}