use super::LodaCppError;
use loda_rust_core::util::BigIntVec;
use num_bigint::BigInt;
use std::error::Error;

pub struct LodaCppEvalTerms {
    terms: BigIntVec,
}

impl LodaCppEvalTerms {
    fn new(terms: BigIntVec) -> Self {
        Self {
            terms: terms,
        }
    }

    pub fn parse(raw_output_from_lodacpp: &String, term_count: usize) -> Result<LodaCppEvalTerms, Box<dyn Error>> {
        let trimmed_output: String = raw_output_from_lodacpp.trim().to_string();
        if trimmed_output.is_empty() {
            error!("No output to parse.");
            return Err(Box::new(LodaCppError::NoOutput));
        }
        let term_strings = trimmed_output.split(",");
        let mut terms_bigintvec = BigIntVec::with_capacity(term_count);
        for term_string in term_strings {
            if term_string.starts_with("+") {
                error!("Positive number should not start with plus symbol. '{}'", term_string);
                return Err(Box::new(LodaCppError::ParseTerms));
            }
            let bytes: &[u8] = term_string.as_bytes();
            let bigint: BigInt = match BigInt::parse_bytes(bytes, 10) {
                Some(value) => value,
                None => {
                    error!("Unable to parse a number as BigInt. '{}'", term_string);
                    return Err(Box::new(LodaCppError::ParseTerms));
                }
            };
            terms_bigintvec.push(bigint);
        };
        Ok(LodaCppEvalTerms::new(terms_bigintvec))
    }

    #[allow(dead_code)]
    pub fn terms(&self) -> &BigIntVec {
        &self.terms
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use loda_rust_core::util::BigIntVecToString;

    fn parse(input: &str) -> String {
        let s = input.to_string();
        let evalterms: LodaCppEvalTerms = match LodaCppEvalTerms::parse(&s, 0) {
            Ok(value) => value,
            Err(error) => {
                if let Some(lodacpp_error) = error.downcast_ref::<LodaCppError>() {
                    if LodaCppError::NoOutput == *lodacpp_error {
                        return "ERROR NoOutput".to_string();
                    }
                    if LodaCppError::ParseTerms == *lodacpp_error {
                        return "ERROR ParseTerms".to_string();
                    }
                    return format!("ERROR LODACPP: {:?}", lodacpp_error);
                }
                return format!("ERROR OTHER: {:?}", error);
            }
        };
        evalterms.terms().to_compact_comma_string()
    }

    #[test]
    fn test_10000_parse_ok() {
        assert_eq!(parse("-1,2,-3,4"), "-1,2,-3,4");
        assert_eq!(parse("\n  42\t  "), "42");
        assert_eq!(parse("0"), "0");
        assert_eq!(parse("0,0"), "0,0");
        assert_eq!(parse("0000555"), "555");
    }
    
    #[test]
    fn test_20000_parse_error() {
        assert_eq!(parse(""), "ERROR NoOutput");
        assert_eq!(parse(" "), "ERROR NoOutput");
        assert_eq!(parse(" \n "), "ERROR NoOutput");
        assert_eq!(parse("1,2,overflow"), "ERROR ParseTerms");
        assert_eq!(parse("c++ exception"), "ERROR ParseTerms");
        assert_eq!(parse("+123"), "ERROR ParseTerms");
    }
}