use std::fs;

mod parser_impls;
use parser_impls::chars::{AlphabeticCharacterParser, CharacterParser};

mod parser;
use parser::parser::Parser;

mod combinators;
use combinators::combinators::{Bind, Many, ManyA, Empty, Sat, Alternative, Zip, Map};


fn equals_a_fun(c: char) -> bool {
    c == 'a'
}

fn equals_i_fun(c: char) -> bool {
    c == 'i'
}

fn x_to_k(a: char) -> char {
    'k'
}

fn main() {
    let source = "src/examples/example_programs/word.txt";
    let _file = fs::read_to_string(source).expect("File was not found or could not be read");
    let _parse_a = Bind{
        parser_first : Box::new(AlphabeticCharacterParser{}),
        parser_second: Box::new(AlphabeticCharacterParser{}),
    };
    // let parse_b = Bind{
    //     parser_first : Box::new(AlphabeticCharacterParser{}),
    //     parser_second: Box::new(AlphabeticCharacterParser{}),
    // };
    // let parse_c = Bind{
    //     parser_first : Box::new(parse_a),
    //     parser_second: Box::new(parse_b),
    // };
    // let res = Parser::parse(&parse_c, file);

    // Parses character h
    let char_parser_h = CharacterParser {
        character : 'h'
    };

    // let res = Parser::parse(&char_parser, file);

    // Parses many of the same charcter
    let _char_many_parser = Many {
        parser: Box::new(char_parser_h)
    };

    // let res = Parser::parse(&char_many_parser, file);

    //Parsers all alphabet characters
    // let parser_many = Many{
    //     parser : Box::new(AlphabeticCharacterParser{})
    // };
    // let res = Parser::parse(&parser_many, file);

    let _many_a = ManyA {};
    // let res = many_a.parse("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaak");

    let _empty = Empty{};
    // let res = empty.parse("hello".to_owned());

    let equals_a = Sat {
        sat_fun: equals_a_fun
    };
    // let res = Parser::parse(&equals_a, "aaa".to_owned());
    

    let equals_i = Sat {
        sat_fun: equals_i_fun
    };


    // let a_or_i = Alternative{
    //     parser_first: Box::new(equals_a),
    //     parser_second: Box::new(equals_i)
    // };

    // let res = Parser::parse(&h_or_i, "i".to_owned());

    // let a_then_i = Zip {
    //     parser_first: Box::new(equals_a),
    //     parser_second: Box::new(equals_i)
    // };

    // let res = Parser::parse(&a_then_i, "aa".to_owned());

    let map_a_k = Map {
        map_a_b_fun: x_to_k,
        parser_a: Box::new(equals_a)
    };

    let res = Parser::parse(&map_a_k, "".to_owned());

    print!("{:#?}", res);

}