use std::io::{self, Read, Write, IsTerminal};
use std::os::unix::io::AsRawFd;
use std::process::Command;
use std::ffi::OsStr;
use std::os::unix::ffi::OsStrExt;
use std::path::Path;

mod raw;
mod parse;
use raw::*;

macro_rules! print {
    ($($x:tt)*) => {{
        write!(io::stdout(), $($x)*).unwrap();
        io::stdout().flush().unwrap();
    }}
}

macro_rules! println {
    () => {{
        println!("")
    }};
    ($($x:tt)*) => {{
        write!(io::stdout(), $($x)*).unwrap();
        write!(io::stdout(), "\r\n").unwrap();
        io::stdout().flush().unwrap();
    }};
}

struct LineBuffer {
    pre: Vec<u8>,
    post: Vec<u8>,
}

#[allow(unused)]
impl LineBuffer {
    pub fn new() -> Self {
        Self {
            pre: Vec::new(),
            post: Vec::new(),
        }
    }
    pub fn del_left(&mut self) -> Option<u8> {
        self.pre.pop()
    }
    pub fn del_right(&mut self) -> Option<u8> {
        self.post.pop()
    }
    pub fn left(&mut self) -> bool {
        if let Some(byte) = self.del_left() {
            self.post.push(byte);
            true
        } else {
            false
        }
    }
    pub fn right(&mut self) -> bool {
        if let Some(byte) = self.del_right() {
            self.pre.push(byte);
            true
        } else {
            false
        }
    }
    pub fn add(&mut self, chr: u8) {
        self.pre.push(chr);
    }

    /// returns the whole contents of the buffer, and empties it in the process
    pub fn dump(&mut self) -> Vec<u8> {
        while self.right() {}
        let mut buf = Vec::new();
        core::mem::swap(&mut self.pre, &mut buf);
        buf
    }

    pub fn display_post(&self) {
        for &x in self.post.iter().rev() {
            io::stdout().write_all(&[x]).unwrap();
        }
        move_cursor(Direction::Left, self.post.len());
        io::stdout().flush().unwrap();
    }
}

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

pub fn move_cursor(direction: Direction, n: usize) {
    if n == 0 {
        return;
    }

    let code = match direction {
        Direction::Up => 'A',    // CUU
        Direction::Down => 'B',  // CUD
        Direction::Right => 'C', // CUF
        Direction::Left => 'D',  // CUB
    };

    print!("\x1b[{n}{code}");
}

/// Represents a cursor position
#[derive(Debug, Clone, Copy)]
pub struct CursorPos {
    pub row: usize,
    pub col: usize,
}

const PROMPT: &str = "> ";

fn run_command(raw: &ScopedRawMode, line: Vec<u8>) {
    let mut words: Vec<&[u8]> = line.split(|x| *x == b' ').collect();
    words.retain(|w| !w.is_empty());

    if words.is_empty() {
        print!("{PROMPT}");
        return;
    }

    let cmd = words[0];

    match cmd {
        b"cd" => {
            let target: &Path = match words.get(1) {
                Some(&b"-") => todo!("prev"),
                Some(path) => OsStr::from_bytes(path).as_ref(),
                None => todo!("homedir"),
            };

            if let Err(_) = std::env::set_current_dir(target) {
                print!("ERR {PROMPT}");
            } else {
                print!("{PROMPT}");
            }

            return;
        },
        _ => (),
    }

    let mut cmd = Command::new(OsStr::from_bytes(cmd));
    for arg in words[1..].iter() {
        cmd.arg(OsStr::from_bytes(arg));
    }

    raw.disable();
    let status = cmd.status();
    raw.enable();

    let status_string = match status {
        Ok(ec) if ec.success() => String::new(),
        Ok(ec) => format!("{ec} "),
        Err(_) => String::from("IO ERROR "),
    };

    print!("{status_string}{PROMPT}");
}

fn main() {
    let stdin = io::stdin();
    let stdout = io::stdout();

    if !stdin.is_terminal() {
        println!("need to run in a tty");
        return;
    }

    let fd = stdin.as_raw_fd();
    let raw = ScopedRawMode::on_fd(fd);
    raw.enable();

    let mut stdin = stdin.lock();
    let mut stdout = stdout.lock();

    let mut buffer = [0u8; 1];
    let mut line = LineBuffer::new();

    print!("{PROMPT}");

    loop {
        let Ok(_) = stdin.read_exact(&mut buffer) else {
            break;
        };

        match buffer[0] {
            // EOF
            4 => {
                break;
            }

            // Enter
            b'\r' => {
                let line = line.dump();
                if !line.is_empty() {
                    print!("\r\n");
                    run_command(&raw, line);
                }
            }

            // Backspace (127 on most systems)
            127 => {
                if line.del_left().is_some() {
                    print!("\x08 \x08");
                }
            }

            // Escape sequence
            27 => {
                let mut seq = [0u8; 2];
                stdin.read_exact(&mut seq).unwrap();

                if seq[0] == b'[' {
                    match seq[1] {
                        b'A' => {
                            // up
                        },
                        b'B' => {
                            // down
                        },
                        b'C' => {
                            move_cursor(Direction::Right, 1);
                            line.right();
                        }
                        b'D' => {
                            move_cursor(Direction::Left, 1);
                            line.left();
                        }
                        x => todo!("escape character {x}")
                    }
                }
            }

            // Normal character
            x => {
                line.add(x);
                stdout.write_all(&[x]).unwrap();
                line.display_post();
            }
        }
    }

    raw.disable();
    println!();
}