//extern crate termion;

//use termion::event::Key;
//use termion::input::TermRead;
//use termion::raw::IntoRawMode;
use std::collections::LinkedList;
use std::io::{stdin, stdout, Write};

#[derive(Debug, Copy, Clone)]
pub enum Direction {
    Up,
    Down,
    Left,
    Right,
}

#[derive(Clone, Debug)]
pub struct Location {
    x: i16,
    y: i16,
}

#[derive(Clone, Debug)]
pub struct Block {
    loc: Location,
    color: String,
}

#[derive(Debug)]
pub struct Snake {
    dir: Direction,
    head: Block,
    body: LinkedList<Block>,
    last: Option<Block>,
    alive: bool,
    moving: bool,
}

impl Location {
    pub fn new(x: i16, y: i16) -> Location {
        Location { x: x, y: y }
    }
}

impl Direction {
    pub fn opposite(dir: Direction) -> Direction {
        match dir {
            Direction::Up => Direction::Down,
            Direction::Down => Direction::Up,
            Direction::Left => Direction::Right,
            Direction::Right => Direction::Left,
        }
    }
    pub fn delta(dir: Direction) -> (i16, i16) {
        match dir {
            Direction::Up => (0, 1),
            Direction::Down => (0, -1),
            Direction::Left => (-1, 0),
            Direction::Right => (1, 0),
        }
    }
}

impl Block {
    pub fn new(x: i16, y: i16, color: String) -> Block {
        Block {
            loc: Location { x, y },
            color: color,
        }
    }
}

impl Snake {
    pub fn new(x: i16, y: i16, len: i16, dir: Direction) -> Snake {
        let mut body: LinkedList<Block> = LinkedList::new();
        let delta = Direction::delta(dir);
        for s in 1..len + 1 {
            let bx: i16 = x + (delta.0 * s);
            let by: i16 = y + (delta.1 * s);
            body.push_back(Block::new(bx, by, "0".to_string()));
        }
        Snake {
            dir: dir,
            head: Block::new(x, y, "0".to_string()),
            body: body,
            last: None,
            alive: true,
            moving: false,
        }
    }

    pub fn update(&mut self, dir: Direction) {
        self.dir = dir;
        let mut b: Block = self.head.clone();
        let delta = Direction::delta(dir);
        self.head.loc.x += delta.0;
        self.head.loc.y += delta.1;
    }

    fn moveblock(target_block: &mut Block, tool_block: Block) {
        target_block.loc = tool_block.loc;
    }
}

fn main() {
    let stdin = stdin();
    //let mut stdout = stdout().into_raw_mode().unwrap();

    let _width = 30;
    let _height = 30;

    // Clear Terminal, Hide cursor
    /*
    write!(
        stdout,
        "{}{}{}",
        termion::clear::All,
        termion::cursor::Goto(1, 1),
        termion::cursor::Hide
    ).unwrap();
    stdout.flush().unwrap();
    */

    let mut _s = Snake::new(5, 5, 3, Direction::Up);

    for b in _s.body {
        //write!(
            //stdout,
            //"{}#",
            //termion::cursor::Goto(b.loc.x as u16, b.loc.y as u16)
        //);
    }

    // Handle Keys
    //for c in stdin.keys() {
        //write!(
            //stdout,
            //"{}{}",
            //termion::cursor::Goto(1, 1),
            //termion::clear::CurrentLine
        //).unwrap();
        //match c.unwrap() {
            //Key::Char('q') => break,
            //Key::Left => println!("<"),
            //Key::Right => println!(">"),
            //Key::Up => println!("^"),
            //Key::Down => println!("v"),
            //_ => {}
        //}
        //stdout.flush().unwrap();
    //}
    //write!(stdout, "{}", termion::cursor::Show).unwrap();
}