extern crate sexp;

use std::fs::File;
use std::io::BufReader;
use std::io::prelude::*;
use sexp::Sexp::{Atom, List};
use sexp::Atom::{S,I,F};

#[derive(Debug)]
enum TokenType {
    Atom,
    Not,
    And,
    Or,
    Impl,
    True,
    False,
    Undef,
}

struct Node<'a> {
    _type: TokenType,
    symbol: Option<&'a str>,
    left: Option<&'a Node<'a>>,
    right: Option<&'a Node<'a>>
}

impl<'a> Node<'a> {
    fn new() -> Node<'a> {
        return Node{_type: TokenType::Undef, symbol: None, left: None, right: None};
    }

    fn atom(symbol: &'a str) -> Node<'a> {
        return Node{_type: TokenType::Atom, symbol: Some(symbol), left: None, right: None};
    }
}

fn parse(buf: &str) -> Result<Node,String> {

    let tokens = sexp::parse(buf);

    match tokens {
        Ok(s) => {
            println!("{:?}",s);

            match s {
                Atom(atom) => {

                    match atom {
                        S(s) => {
                            // println!("ATOM: {:?}",s);
                            return Ok(Node::atom(s.as_str()));
                        }
                        I(i) => {
                            panic!("not supported");
                        }
                        F(f) => {
                            panic!("not supported");
                        }
                    }


                }
                List(list) => {
                    println!("LIST: {:?}",list);

                }
            }

        }
        Err(m) => {
            println!("{:?}",m);
            panic!("parse error")
        }
    }

    let node = Node::new();
    return Ok(node);
}

fn main() -> std::io::Result<()> {
    let file = File::open("hoge.txt")?;
    let mut buf_reader = BufReader::new(file);
    let mut contents = String::new();

    buf_reader.read_to_string(&mut contents)?;
    let lines = contents.split('\n');

    for line in lines {
        if line.len() != 0 {
            let tree = parse(line);
        }
    }

    Ok(())
}