use wasm_bindgen::prelude::*;

use fql_deserialize as des;
use fql_serialize as se;

#[wasm_bindgen]
pub fn serialize_fql(query: &str) -> Result<String, JsError> {
  se::serialize_fql(query).map_err(|err| JsError::new(&format!("{}", err)))
}

#[wasm_bindgen]
pub fn parse_fauna_response(response: &str) -> Result<String, JsError> {
  des::parse_fauna_response(response).map_err(|err| JsError::new(&format!("{}", err)))
}

#[wasm_bindgen]
pub fn parse_expr(expr: &str) -> Result<String, JsError> {
  des::parse_expr(expr).map_err(|err| JsError::new(&format!("{}", err)))
}

#[wasm_bindgen]
pub fn to_fql_string(json: &str) -> Result<String, JsError> {
  des::to_fql_string(json).map_err(|err| JsError::new(&format!("{}", err)))
}

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

  #[test]
  fn parse_fauna_response_works() {
    let response = r#"{
            "resource": {
                "@query":{
                    "api_version": "4",
                    "lambda": [],
                    "expr": true
                }
            }
        }"#;
    let transformed = parse_fauna_response(response.into())
      .map_err(|_| ())
      .unwrap();

    let expected = r#"{"resource":"Query(Lambda([],true))"}"#;

    assert_eq!(transformed, expected)
  }

  #[test]
  fn parse_expr_works() {
    let expr = r#"{
            "@query":{
                "api_version": "4",
                "lambda": [],
                "expr": true
            }
        }"#;
    let transformed = parse_expr(expr.into()).map_err(|_| ()).unwrap();

    let expected = r#""Query(Lambda([],true))""#;

    assert_eq!(transformed, expected)
  }

  #[test]
  fn to_fql_string_works() {
    let fql = r#"{
            "query":{
                "lambda": [],
                "expr": true
            }
        }"#;
    let transformed = to_fql_string(fql.into()).map_err(|_| ()).unwrap();

    let expected = r#"Query(Lambda([],true))"#;

    assert_eq!(transformed, expected)
  }
}