use crate::{
    PrimitiveType, Type,
    parse::{
        Ast, Constant,
        sexpr::{Sexpr, parse_string},
    },
};

use super::{parse, parse_type};

#[test]
fn parse_to_sexpr() {
    let input = "((\\x:Nat.x) (5))";
    let parsed = parse_string(input).unwrap();
    assert_eq!(
        parsed,
        Sexpr::List(vec![
            Sexpr::List(vec![Sexpr::Symbol("\\x:Nat.x".to_string())]),
            Sexpr::List(vec![Sexpr::Symbol("5".to_string())])
        ])
    );
}

#[test]
fn parse_prim_type() {
    let input = Sexpr::Symbol("Nat".to_string());
    let parsed = parse_type(&input).unwrap();
    assert_eq!(parsed, Type::Primitive(PrimitiveType::Nat))
}

#[test]
fn parse_simpl_arr_type() {
    let input = Sexpr::List(vec![
        Sexpr::Symbol("Nat".to_string()),
        Sexpr::Symbol("->".to_string()),
        Sexpr::Symbol("Nat".to_string()),
    ]);
    let parsed = parse_type(&input).unwrap();
    assert_eq!(parsed, Type::arrow(PrimitiveType::Nat, PrimitiveType::Nat))
}

#[test]
fn parse_apply_arr_type() {
    let input = Sexpr::List(vec![
        Sexpr::List(vec![
            Sexpr::Symbol("Nat".to_string()),
            Sexpr::Symbol("->".to_string()),
            Sexpr::Symbol("Nat".to_string()),
        ]),
        Sexpr::Symbol("->".to_string()),
        Sexpr::Symbol("Nat".to_string()),
        Sexpr::Symbol("->".to_string()),
        Sexpr::Symbol("Nat".to_string()),
    ]);
    let parsed = parse_type(&input).unwrap();
    assert_eq!(
        parsed,
        Type::arrow(
            Type::arrow(PrimitiveType::Nat, PrimitiveType::Nat),
            Type::arrow(PrimitiveType::Nat, PrimitiveType::Nat)
        )
    )
}

#[test]
fn parse_abstraction() {
    let input = "(\\ (x (Nat -> Nat)) (x 5))";
    let parsed = parse(input).unwrap();
    assert_eq!(
        parsed,
        Ast::Abstraction(
            "x".to_string(),
            Type::arrow(PrimitiveType::Nat, PrimitiveType::Nat),
            Box::new(Ast::Application(
                Box::new(Ast::Variable("x".to_string())),
                Box::new(Ast::Constant(Constant::Nat(5)))
            ))
        )
    )
}

#[test]
fn parse_application() {
    let input = "((add 5) 6)";
    let parsed = parse(input).unwrap();
    assert_eq!(
        parsed,
        Ast::Application(
            Box::new(Ast::Application(
                Box::new(Ast::Variable("add".to_string())),
                Box::new(Ast::Constant(Constant::Nat(5)))
            )),
            Box::new(Ast::Constant(Constant::Nat(6)))
        )
    )
}