use serde::Serialize;
use serde_json::json;
use serde_json::value::Value;
use std::collections::HashMap;
use tera::Tera;
use tera::{Error, Result};

use crate::queries;

#[derive(Debug, Serialize)]
pub enum Header {
    Payments,
    Categories,
    Incomes,
    Balance,
    Statistics,
}

pub fn get() -> Tera {
    let mut tera = match Tera::new("templates/**/*") {
        Ok(t) => t,
        Err(e) => {
            error!("Parsing error(s): {}", e);
            ::std::process::exit(1);
        }
    };
    tera.register_function("payments_params", payments_params);
    tera.register_filter("numeric", numeric);
    tera.register_filter("euros", euros);
    tera
}

fn payments_params(args: &HashMap<String, Value>) -> Result<Value> {
    let q = json!({
        "page": args.get("page"),
        "name": args.get("name"),
        "cost": args.get("cost"),
        "frequency": args.get("frequency"),
        "highlight": args.get("highlight"),
        "user": args.get("user"),
        "category": args.get("category"),
        "start_date": args.get("start_date"),
        "end_date": args.get("end_date"),
    });

    match serde_json::from_value(q) {
        Ok(q) => Ok(json!(queries::payments_url(q))),
        Err(msg) => Err(Error::msg(msg)),
    }
}

fn euros(value: &Value, _: &HashMap<String, Value>) -> Result<Value> {
    match value {
        Value::Number(n) => {
            if let Some(n) = n.as_i64() {
                let str = rgrouped(n.abs().to_string(), 3).join(" ");
                let sign = if n < 0 { "-" } else { "" };
                Ok(json!(format!("{}{} €", sign, str)))
            } else if let Some(n) = n.as_f64() {
                Ok(json!(format!("{} €", n)))
            } else {
                Err(Error::msg("Error parsing number"))
            }
        }
        _ => Err(Error::msg(format!("{:?} should be a number", value))),
    }
}

fn numeric(value: &Value, _: &HashMap<String, Value>) -> Result<Value> {
    match value {
        Value::Number(n) => {
            if let Some(n) = n.as_i64() {
                let str = rgrouped(n.abs().to_string(), 3).join(" ");
                let sign = if n < 0 { "-" } else { "" };
                Ok(json!(format!("{}{}", sign, str)))
            } else if let Some(n) = n.as_f64() {
                Ok(json!(format!("{}", n)))
            } else {
                Err(Error::msg("Error parsing number"))
            }
        }
        _ => Err(Error::msg(format!("{:?} should be a number", value))),
    }
}

fn rgrouped(str: String, n: usize) -> Vec<String> {
    let mut str = str;
    let mut l = str.len();
    let mut res = vec![];
    while l > n {
        let str2 = str.clone();
        let (start, end) = str2.split_at(l - n);
        l -= n;
        str = start.to_string();
        res.push(end.to_string());
    }
    if !str.is_empty() {
        res.push(str);
    }
    res.reverse();
    res
}