extern crate termion;
extern crate signal_hook;
pub mod alarm;
mod buffer;
pub mod clock;
pub mod consts;
pub mod layout;
pub mod utils;
#[cfg(test)]
mod tests;

use std::{env, process, thread, time};
use std::io::Write;
use signal_hook::consts::signal::*;
use signal_hook::iterator::Signals;
use signal_hook::low_level;
use termion::{clear, cursor, style};
use termion::raw::{IntoRawMode, RawTerminal};
use termion::event::Key;
use termion::input::TermRead;
use buffer::Buffer;
use clock::{Clock, font};
use layout::Layout;
use alarm::{Countdown, exec_command};
pub use alarm::AlarmRoster;
pub use consts::ui::*;


pub fn run(
    config: Config,
    mut alarm_roster: AlarmRoster,
) -> Result<Option<process::Child>, std::io::Error>
{
    let mut layout = Layout::new();
    // Initialise roster_width.
    layout.set_roster_width(alarm_roster.width());
    let mut clock = Clock::new(&config);
    let mut countdown = Countdown::new();
    let mut buffer = Buffer::new();

    let async_stdin = termion::async_stdin();
    let mut input_keys = async_stdin.keys();
    let stdout = std::io::stdout();
    let mut stdout = stdout.lock().into_raw_mode()?;
    let mut child: Option<process::Child> = None;
    let mut force_redraw = true;

    // Register signals.
    let mut signals = Signals::new(&[
        SIGTSTP,
        SIGCONT,
        SIGWINCH,
        SIGTERM,
        SIGINT,
        SIGUSR1,
        SIGUSR2,
    ])?;

    // Main loop entry.
    loop {
        // Process received signals.
        'outer: for signal in signals.pending() {
            match signal {
                // Suspend execution on SIGTSTP.
                SIGTSTP => suspend(&mut stdout)?,
                // Continuing after SIGTSTP or SIGSTOP.
                SIGCONT => {
                    restore_after_suspend(&mut stdout)?;
                    force_redraw = true;
                },
                SIGWINCH => layout.schedule_recalc(),
                // Exit main loop on SIGTERM and SIGINT.
                SIGTERM | SIGINT => break 'outer,
                // Reset clock on SIGUSR1.
                SIGUSR1 => {
                    clock.reset();
                    alarm_roster.reset_all();
                    layout.schedule_recalc();
                    force_redraw = true;
                },
                // (Un-)Pause clock on SIGUSR2.
                SIGUSR2 => {
                    clock.toggle();
                    force_redraw = true;
                },
                // We didn't register anything else.
                _ => unreachable!(),
            }
        }

        // Update elapsed time.
        let elapsed = if clock.paused {
                clock.elapsed
            } else {
                // Should never overflow as we reestablish a new "start"
                // instant every 24 hours.
                clock.start.elapsed().as_secs() as u32
            };

        // Conditional inner loop. Runs once every second or when explicitly
        // requested.
        if elapsed != clock.elapsed || force_redraw  {
            // Update clock. Advance one day after 24 hours.
            if elapsed < 24 * 60 * 60 {
                clock.elapsed = elapsed;
            } else {
                clock.next_day();
                // "clock.elapsed" set by "clock.next_day()".
                alarm_roster.reset_all();
                layout.schedule_recalc();
            }

            // Update window size information and calculate the clock position.
            // Also enforce recalculation of layout if we start displaying
            // hours.
            match layout.update(&clock, clock.elapsed == 3600) {
                Ok(true) => force_redraw = true,
                Ok(false) => (),
                Err(e) => return Err(e),
            }

            // Check on last spawned child process prior to processing the
            // alarm roster and possibly starting a new one.
            if let Some(ref mut spawn) = child {
                match spawn.try_wait() {
                    // Process exited successfully.
                    Ok(Some(status)) if status.success() => child = None,
                    // Abnormal exit.
                    Ok(Some(status)) => {
                        eprintln!("Spawned process terminated with non-zero exit status. ({})", status);
                        child = None;
                    },
                    // Process is still running.
                    Ok(None) => (),
                    // Other error.
                    Err(error) => {
                        eprintln!("Error executing command. ({})", error);
                        child = None;
                    },
                }
            }

            // Check for exceeded alarms.
            if let Some(alarm) = alarm_roster.check(
                &mut clock,
                &layout,
                &mut countdown,
                force_redraw)
            {
                // Do not react to exceeded alarms if the clock is paused.
                if !clock.paused {
                    force_redraw = true;

                    // Write ASCII bell code.
                    write!(stdout, "{}", 0x07 as char)?;

                    match config.command {
                        // Run command if configured and no command is running.
                        Some(ref command) if child.is_none() => {
                            child = exec_command(command, alarm.time, &alarm.label);
                        },
                        // Last command is still running.
                        Some(_) => eprintln!("Not executing command, as its predecessor is still running"),
                        None => (),
                    }
                    // Quit if configured.
                    if config.quit && alarm_roster.idle() { break };
                }
            }

            // Clear the window and redraw menu bar, alarm roster and buffer if
            // requested.
            if force_redraw {
                // Write menu at the top.
                write!(stdout,
                    "{}{}{}{}{}",
                    cursor::Goto(1, 1),
                    style::Faint,
                    // Switch menu bars. Use a compressed version or none at
                    // all if necessary.
                    match buffer.visible {
                        _ if clock.paused && layout.can_hold(MENUBAR_PAUSED) => MENUBAR_PAUSED,
                        true if layout.can_hold(MENUBAR_INS) => MENUBAR_INS,
                        false if layout.can_hold(MENUBAR) => MENUBAR,
                        false if layout.can_hold(MENUBAR_SHORT) => MENUBAR_SHORT,
                        // Clearing the screen from position 1, 1 seems to have
                        // unwanted side effects. We avoid this by writing a
                        // single space here.
                        _ => " ",
                    },
                    clear::AfterCursor,
                    style::NoFaint)?;

                // Redraw list of alarms.
                alarm_roster.draw(&mut stdout, &mut layout, &config)?;

                // Redraw buffer.
                buffer.draw(&mut stdout, &mut layout)?;
            }

            clock.draw(&mut stdout, &layout, force_redraw)?;

            // Display countdown.
            if countdown.value > 0 {
                countdown.draw(&mut stdout)?;
            }

            // End of conditional inner loop.
            // Reset redraw_all and flush stdout.
            force_redraw = false;
            stdout.flush()?;
        }

        // Update buffer whenever the cursor should be visible.
        if buffer.visible {
            buffer.draw(&mut stdout, &mut layout)?;
            stdout.flush()?;
        }

        // Process input.
        if let Some(key) = input_keys.next() {
            match key.expect("Error reading input") {
                // Enter.
                Key::Char('\n') => {
                    if !buffer.is_empty() {
                        if let Err(e) = alarm_roster.add(buffer.read()) {
                            // Error while processing input buffer.
                            buffer.message(e);
                        } else {
                            // Input buffer processed without error.
                            layout.set_roster_width(alarm_roster.width());
                        }
                        buffer.clear();
                        buffer.visible = false;
                        force_redraw = true;
                    }
                },
                // Escape and ^U clear input buffer.
                Key::Esc | Key::Ctrl('u') => {
                    buffer.reset();
                    buffer.visible = false;
                    force_redraw = true;
                },
                // ^W removes last word.
                Key::Ctrl('w') => {
                    buffer.strip_word();
                    if buffer.is_empty() {
                        buffer.visible = false;
                        force_redraw = true;
                    }
                },
                // Backspace.
                Key::Backspace => {
                    // Delete last char in buffer.
                    buffer.strip_char();
                    if buffer.is_empty() {
                        buffer.visible = false;
                        force_redraw = true;
                    }
                },
                // Set clock.
                Key::Up if clock.paused => {
                    clock.shift(10);
                    // We would very likely not detect us passing the hour
                    // barrier and would panic when trying to draw hours
                    // without position if we do not schedule a recalculation
                    // here.
                    layout.schedule_recalc();
                    force_redraw = true;
                },
                Key::Down if clock.paused => {
                    clock.shift(-10);
                    alarm_roster.time_travel(&mut clock);
                    layout.schedule_recalc();
                    force_redraw = true;
                },
                // Forward every char if in insert mode.
                Key::Char(c) if buffer.visible => {
                    buffer.push(c);
                },
                // Reset clock on 'r'.
                Key::Char('r') => {
                    clock.reset();
                    alarm_roster.reset_all();
                    layout.schedule_recalc();
                    force_redraw = true;
                },
                // (Un-)Pause on space.
                Key::Char(' ') => {
                    clock.toggle();
                    force_redraw = true;
                },
                // Clear clock color on 'c'.
                Key::Char('c') => {
                    clock.color_index = None;
                    force_redraw = true;
                },
                // Delete last alarm on 'd'.
                Key::Char('d') => {
                    if alarm_roster.drop_last() {
                        // If we remove the last alarm we have to reset "countdown"
                        // manually. It is safe to do it anyway.
                        layout.set_roster_width(alarm_roster.width());
                        countdown.reset();
                        force_redraw = true;
                    }
                },
                // Exit on q and ^C.
                Key::Char('q') | Key::Ctrl('c') => break,
                // Force redraw on ^R.
                Key::Ctrl('r') => force_redraw = true,
                // Suspend an ^Z.
                Key::Ctrl('z') => {
                    suspend(&mut stdout)?;
                    // Clear SIGCONT, as we have already taken care to reset
                    // the terminal.
                    //signal.compare_and_swap(SIGCONT, 0, Ordering::Relaxed);
                    force_redraw = true;
                    // Jump to the start of the main loop.
                    continue;
                },
                Key::Char(c) => {
                    if c.is_ascii_digit() {
                        buffer.push(c);
                        buffer.visible = true;
                        force_redraw = true;
                    } else if !buffer.is_empty() && c == ':' {
                        buffer.push(':');
                    }
                },
                // Any other key.
                _ => (),
            }
        } else {
            // Main loop delay. Skipped after key press.
            thread::sleep(time::Duration::from_millis(100));
        }
    }

    // Main loop exited. Clear screen and restore cursor.
    write!(stdout,
        "{}{}{}",
        clear::All,
        cursor::Restore,
        cursor::Show)?;
    stdout.flush()?;

    Ok(child)
}

pub struct Config {
    quit: bool,
    fancy: bool,
    font: &'static font::Font,
    command: Option<Vec<String>>,
}

impl Config {
    // Parse command line arguments into "config".
    pub fn new(args: env::Args, alarm_roster: &mut AlarmRoster)
        -> Result<Config, String>
    {
        let mut config = Config {
            quit: false,
            fancy: false,
            font: &font::NORMAL,
            command: None,
        };
        let mut iter = args.skip(1);

        loop {
            if let Some(arg) = iter.next() {
                match arg.as_str() {
                    "-h" | "--help" => {
                        // Print usage information and exit
                        println!("{}", USAGE);
                        process::exit(0);
                    },
                    "-v" | "--version" => {
                        println!("{} {}", NAME, VERSION);
                        process::exit(0);
                    },
                    "-p" | "--plain" => config.font = &font::PLAIN,
                    "-f" | "--fancy" => {
                        config.fancy = true;
                        config.font = &font::CHROME;
                    },
                    "-q" | "--quit" => config.quit = true,
                    "-e" | "--exec" => {
                        if let Some(e) = iter.next() {
                            config.command = Some(Config::parse_to_command(&e));
                        } else {
                            return Err(format!("Missing parameter to \"{}\".", arg));
                        }
                    },
                    any if any.starts_with('-') => {
                        // Unrecognized flag.
                        return Err(format!("Unrecognized option: \"{}\"\nUse \"-h\" or \"--help\" for a list of valid command line options.", any));
                    },
                    any => {
                        // Alarm to add.
                        if let Err(error) = alarm_roster.add(&String::from(any)) {
                            return Err(format!("Error adding \"{}\" as alarm. ({})", any, error));
                        }
                    },
                }
            } else { break; } // All command line parameters processed.
        }
        Ok(config)
    }

    // Parse command line argument to --command into a vector of strings suitable
    // for process::Command::new().
    fn parse_to_command(input: &str) -> Vec<String> {
        let mut command: Vec<String> = Vec::new();
        let mut segment: String = String::new();
        let mut quoted = false;
        let mut escaped = false;

        for c in input.chars() {
            match c {
                '\\' if !escaped => {
                    // Next char is escaped. (If not escaped itself.)
                    escaped = true;
                    continue;
                },
                // Keep spaces when escaped or quoted.
                ' ' if escaped || quoted => { &segment.push(' '); },
                // Otherwise end the current segment.
                ' ' => {
                    if !&segment.is_empty() {
                        command.push(segment.clone());
                        &segment.clear();
                    }
                },
                // Quotation marks toggle quote.
                '"' | '\'' if !escaped => quoted = !quoted,
                // Carry everything else. Escape if found escaped.
                _ => {
                    if escaped { &segment.push('\\'); }
                    &segment.push(c);
                },
            }
            escaped = false;
        }
        command.push(segment);
        command.shrink_to_fit();
        command
    }
}

// Prepare to suspend execution. Called on SIGTSTP.
fn suspend<W: Write>(stdout: &mut RawTerminal<W>)
    -> Result<(), std::io::Error>
{
    write!(stdout,
        "{}{}{}",
        cursor::Goto(1,1),
        clear::AfterCursor,
        cursor::Show)?;
    stdout.flush()?;
    stdout.suspend_raw_mode()
        .unwrap_or_else(|error| {
            eprintln!("Failed to leave raw terminal mode prior to suspend: {}", error);
        });

    if let Err(error) = low_level::emulate_default_handler(SIGTSTP as i32) {
        eprintln!("Error raising SIGTSTP: {}", error);
    }

    //restore_after_suspend(&mut stdout)
    Ok(())
}

// Set up terminal after SIGTSTP or SIGSTOP.
fn restore_after_suspend<W: Write>(stdout: &mut RawTerminal<W>)
    -> Result<(), std::io::Error>
{
    stdout.activate_raw_mode()
        .unwrap_or_else(|error| {
            eprintln!("Failed to re-enter raw terminal mode after suspend: {}", error);
            process::exit(1);
        });
    Ok(())
}