use nix::Error as NixError;
use nix::sys::termios;
use nix::sys::termios::{InputFlags, LocalFlags, OutputFlags, SpecialCharacterIndices, Termios};

use std::io;
use std::io::{BufReader, Error};
use std::io::prelude::*;

use term_parser::ActionIter;

mod editor;
mod helpers;

// use crate::editor::Editor;
use crate::helpers::*;

// Redefine the posix constants for rust land
const STDIN_FILENO: i32 = 0;
// const STDOUT_FILENO: i32 = 1;
// const STDERR_FILENO: i32 = 2;

fn disable_raw_mode(original: &Termios) -> Result<(), Error> {
    match termios::tcsetattr(STDIN_FILENO, termios::SetArg::TCSAFLUSH, original) {
        Ok(()) => Ok(()),
        Err(E) => match E.as_errno() {
            Some(errno) => die(&errno, "tcsetattr"),
            None => panic!("Failed to disable raw mode")
        }
    }
}

fn enable_raw_mode() -> Result<(), Error> {
    let mut raw = termios::tcgetattr(STDIN_FILENO).unwrap();

    raw.input_flags.remove(
        InputFlags::BRKINT &
        InputFlags::ICRNL &
        InputFlags::INPCK &
        InputFlags::ISTRIP &
        InputFlags::IXON
    );

    raw.output_flags.remove(OutputFlags::OPOST);

    raw.local_flags.remove(
        LocalFlags::ECHO &
        LocalFlags::ICANON &
        LocalFlags::IEXTEN &
        LocalFlags::ISIG
    );

    // 8 bit characters
    raw.control_flags |= termios::ControlFlags::CS8;

    raw.control_chars[SpecialCharacterIndices::VMIN as usize] = 0;
    raw.control_chars[SpecialCharacterIndices::VTIME as usize] = 1;

    match termios::tcsetattr(STDIN_FILENO, termios::SetArg::TCSAFLUSH, &raw) {
        Ok(()) => Ok(()),
        Err(e) => match e.as_errno() {
            Some(errno) => die(&errno, "tcsetattr"),
            None => panic!("Failed to enable raw mode")
        }
    }
}

fn main() -> Result<(), Error> {
    let orig_termios = termios::tcgetattr(STDIN_FILENO).unwrap();

    enable_raw_mode()?;

    let stdin = io::stdin();
    let buffer = BufReader::new(stdin);
    let term_code_iter = ActionIter::new(buffer);

    for term_code in term_code_iter {
        let term_code = match term_code {
            Ok(code) => code,
            Err(e) => panic!("{:?}", e),
        };
        println!("\r{:?}", term_code);
    }

    Ok(())

//    loop {
//        let stdin = io::stdin();
//        let mut in_str = String::new();
//        let mut input = BufReader::new(stdin.take(1));
//        input.read_to_string(&mut in_str)?;
//
//        let mut chars = in_str.chars();
//        let char = chars.next().unwrap();
//
//        if char == 'q' {
//            return disable_raw_mode(&orig_termios);
//        }
//
//        // Echo characters
//        if is_cntrl(char) {
//            print!("{}\r\n", char as u8);
//            continue;
//        } else {
//            print!("{} ('{}')\r\n", char as u8, char);
//            continue;
//        }
//    }
}