use std::{
    io::{Error, Result},
    mem,
    ptr
};

// ptrace() in libc does not specify which pointer type is inputted,
// thus we'll want an easy constant which just uses any old type since
// we'll just set it to NULL anyway. For example: the empty tuple
// type.
const NULL: *mut () = ptr::null_mut();

// Nice macro to return `Result::Err<io::Error>` on failure. This is
// not provided as it is hardly related to ptrace.
macro_rules! t { ... }

fn main() -> Result<()> {
    match unsafe { t!(libc::fork()) } {
        0 => child(),
        pid => Parent::new(pid).run()
    }
}
fn child() -> Result<()> {
    unsafe {
        // Attach the parent process to debug this child process
        t!(libc::ptrace(libc::PTRACE_TRACEME, 0 as libc::pid_t, NULL, NULL));
        // Pause execution by raising SIGSTOP until restarted by parent
        t!(libc::raise(libc::SIGSTOP));
    }
    // Instead of writing the program you want to override here (which
    // isn't very useful), you can use the `execve` syscall to execute
    // an external application. But this is just for demonstration
    // purposes.
    println!("Hello, this is a test");
    println!("So the question is, does using STDERR really terminate the program?");
    println!("That would be pretty sad");
    println!("Let's try:");
    eprintln!("Please let me in?");
    println!("Well fsck.");
    Ok(())
}

// TODO
struct Parent { ... }

struct Parent {
    pid: libc::pid_t
}
impl Parent {
    fn new(pid: libc::pid_t) -> Self {
        Self {
            pid
        }
    }
    fn run(&self) -> Result<()> {
        // Wait for the initial raise(SIGSTOP)
        self.wait()?;
        loop {
            match self.step() {
                Err(ref err) if err.raw_os_error() == Some(libc::ESRCH) => {
                    println!("Uncaught child termination.");
                    break;
                },
                Ok(Some(status)) => {
                    println!("Child terminated with error code {}.", status);
                    break;
                },
                other => { other?; }
            }
        }
        Ok(())
    }
    fn step(&self) -> Result<Option<libc::c_int>> {
        // Pre-syscall
        self.next_syscall()?; // Sets breakpoint
        if let Some(status) = self.wait()? { // Waits for next SIGSTOP (or any other signal)
            return Ok(Some(status)); // return if program exited
        }

        let mut regs = self.getregs()?; // Get all assembly registers
        if regs.orig_rax == 1 && regs.rdi == 2 { // Check if the syscall is 1 (write) and first argument is 2 (STDERR)
            // File is STDERR
            regs.orig_rax = 60;
            regs.rdi = 123;
            self.setregs(&regs)?; // Override syscall params with 60 (exit) and 123 (our exit status)
        }

        // Post-syscall
        self.next_syscall()?;
        if let Some(status) = self.wait()? {
            return Ok(Some(status));
        }
        Ok(None)
    }

    // TODO ...
}

fn wait(&self) -> Result<Option<libc::c_int>> {
    unsafe {
        let mut status = 0;
        t!(libc::waitpid(self.pid, &mut status, 0));

        // WIFEXITED returns true if the program was closed, see `man waitpid`
        if libc::WIFEXITED(status) {
            Ok(Some(libc::WEXITSTATUS(status)))
        } else {
            Ok(None)
        }
    }
}
fn next_syscall(&self) -> Result<()> {
    unsafe {
        // See `man ptrace`
        t!(libc::ptrace(libc::PTRACE_SYSCALL, self.pid, NULL, NULL));
        Ok(())
    }
}
fn getregs(&self) -> Result<libc::user_regs_struct> {
    unsafe {
        // Both mem::uninitialized() and mem::zeroed() should be safe
        // here, since the struct only contains integers and no
        // references, enums, slices, etc. It's not pretty, but the
        // struct contains no Default implementation, sadly.
        let mut regs: libc::user_regs_struct = mem::uninitialized();
        t!(libc::ptrace(libc::PTRACE_GETREGS, self.pid, NULL, &mut regs as *mut _));
        Ok(regs)
    }
}
fn setregs(&self, regs: &libc::user_regs_struct) -> Result<()> {
    unsafe {
        t!(libc::ptrace(libc::PTRACE_SETREGS, self.pid, NULL, regs as *const _));
        Ok(())
    }
}