// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

mod commands;
use {
    crate::commands::{CmdHelper, Command, ReplControl},
    anyhow::{format_err, Context as _, Error},
    fidl_fuchsia_power as fpower, fidl_fuchsia_power_test as spower,
    fidl_fuchsia_power_test::BatterySimulatorProxy,
    fuchsia_async as fasync,
    fuchsia_component::client::connect_to_service,
    fuchsia_syslog as syslog,
    futures::{
        channel::mpsc::{channel, SendError},
        Sink, SinkExt, Stream, StreamExt, TryFutureExt,
    },
    pin_utils::pin_mut,
    rustyline::{error::ReadlineError, CompletionType, Config, EditMode, Editor},
    std::{fmt, thread, time::Duration},
};

static LOG_TAG: &str = "battery_simulator";
static PROMPT: &str = "\x1b[34mbattman>\x1b[0m ";

// ParseResult is used to convey the parsed commands input by user
// and display them either as an error or continue executing the commands
enum ParseResult<T> {
    Valid(T),
    Empty,
    Error(String),
}

// BatteryInfo is a wrapper for BatteryInfo so the print fmt could be
// implemented
struct BatteryInfo {
    info: fpower::BatteryInfo,
}

impl fmt::Display for BatteryInfo {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            formatter,
            concat!(
                "Battery Percentage: {:?}\n",
                "Battery Status: {:?}\n",
                "Charge Status: {:?}\n",
                "Level Status: {:?}\n",
                "Charge Source: {:?}\n",
                "Time Remaining: {:?}\n",
            ),
            self.info.level_percent,
            self.info.status,
            self.info.charge_status,
            self.info.level_status,
            self.info.charge_source,
            self.info.time_remaining.as_ref()
        )
    }
}

async fn print_battery_info(service: &BatterySimulatorProxy) -> Result<(), Error> {
    if service.is_simulating().await? {
        let bi = service.get_battery_info().await?;
        println!("{}", BatteryInfo { info: bi });
    } else {
        let battery_manager_server = connect_to_service::<fpower::BatteryManagerMarker>()?;
        let bi = battery_manager_server.get_battery_info().await?;
        println!("{}", BatteryInfo { info: bi });
    }
    Ok(())
}

fn print_set_help_message() {
    println!(concat!(
        "'set' modifies the state of the simulated battery. ",
        "Modifications only take place once disconnected.\n",
        "The usage of set is as follows:\n\n",
        "set <battery_attribute battery_attribute_value>\n\n",
        "The corresponding field and field values is as follows:\n\n",
        "\tBatteryPercentage\n",
        "\t\tAny int value from [1..100]\n",
        "\tChargeSource\n",
        "\t\tUNKNOWN\n",
        "\t\tNONE\n",
        "\t\tAC_ADAPTER\n",
        "\t\tUSB\n",
        "\t\tWIRELESS\n",
        "\tChargeStatus\n",
        "\t\tUNKNOWN\n",
        "\t\tNOT_CHARGING\n",
        "\t\tCHARGING\n",
        "\t\tDISCHARGING\n",
        "\tLevelStatus\n",
        "\t\tUNKNOWN\n",
        "\t\tOK\n",
        "\t\tWARNING\n",
        "\t\tLOW\n",
        "\t\tCRITICAL\n",
        "\tBatteryStatus\n",
        "\t\tUNKOWN\n",
        "\t\tOK\n",
        "\t\tNOT_AVAILABLE\n",
        "\t\tNOT_PRESENT\n",
        "\tTimeRemaining\n",
        "\t\tInt value representing time in seconds\n\n",
        "Examples:\n",
        "set ChargeSource WIRELESS BatteryPercentage 12\n",
        "set ChargeStatus DISCHARGING TimeRemaining 100 BatteryPercentage 2"
    ))
}

fn set_time_remaining(time_remaining: &str, service: &BatterySimulatorProxy) -> Result<(), Error> {
    let time = time_remaining.parse::<u64>()?;
    let duration = Duration::new(time, 0);
    service.set_time_remaining(duration.as_nanos() as i64)?;
    Ok(())
}

fn set_charge_source(charge_source: &str, service: &BatterySimulatorProxy) -> Result<(), Error> {
    let res = match charge_source {
        "UNKNOWN" => fpower::ChargeSource::Unknown,
        "NONE" => fpower::ChargeSource::None,
        "AC_ADAPTER" => fpower::ChargeSource::AcAdapter,
        "USB" => fpower::ChargeSource::Usb,
        "WIRELESS" => fpower::ChargeSource::Wireless,
        _ => {
            println!("{} does not exist as an option for ChargeSource. Type set --help for more information", charge_source);
            return Ok(());
        }
    };
    service.set_charge_source(res)?;
    Ok(())
}

fn set_battery_percentage(
    battery_percentage: &str,
    service: &BatterySimulatorProxy,
) -> Result<(), Error> {
    let percent: f32 = battery_percentage.parse().unwrap();
    if percent < 0.0 || percent > 100.0 {
        println!("Please enter battery percent from 0 to 100");
        return Ok(());
    }
    service.set_battery_percentage(percent)?;
    Ok(())
}

fn set_battery_status(battery_status: &str, service: &BatterySimulatorProxy) -> Result<(), Error> {
    let res = match battery_status {
        "UNKNOWN" => fpower::BatteryStatus::Unknown,
        "OK" => fpower::BatteryStatus::Ok,
        "NOT_AVAILABLE" => fpower::BatteryStatus::NotAvailable,
        "NOT_PRESENT" => fpower::BatteryStatus::NotPresent,
        _ => {
            println!("{} does not exist as an option for BatteryStatus. Type set --help for more information", battery_status);
            return Ok(());
        }
    };
    service.set_battery_status(res)?;
    Ok(())
}

fn set_level_status(level_status: &str, service: &BatterySimulatorProxy) -> Result<(), Error> {
    let res = match level_status {
        "UNKNOWN" => fpower::LevelStatus::Unknown,
        "OK" => fpower::LevelStatus::Ok,
        "WARNING" => fpower::LevelStatus::Warning,
        "LOW" => fpower::LevelStatus::Low,
        "CRITICAL" => fpower::LevelStatus::Critical,
        _ => {
            println!("{} does not exist as an option for LevelStatus. Type set --help for more information", level_status);
            return Ok(());
        }
    };
    service.set_level_status(res)?;
    Ok(())
}

fn set_charge_status(charge_status: &str, service: &BatterySimulatorProxy) -> Result<(), Error> {
    let res = match charge_status {
        "UNKNOWN" => fpower::ChargeStatus::Unknown,
        "NOT_CHARGING" => fpower::ChargeStatus::NotCharging,
        "CHARGING" => fpower::ChargeStatus::Charging,
        "DISCHARGING" => fpower::ChargeStatus::Discharging,
        "FULL" => fpower::ChargeStatus::Full,
        _ => {
            println!("{} does not exist as an option for ChargeStatus. Type set --help for more information", charge_status);
            return Ok(());
        }
    };
    service.set_charge_status(res)?;
    Ok(())
}

// args is the string of arguments provided by the user. The format is as follows
// args: "<Field> <Value> ...". The <Field> is any field of the BatteryInfo and
// <Value> is the fields corresponding value. The "..." signifies the repetition of
// the previous pattern of field and value.
async fn set_all_information(args: String, service: &BatterySimulatorProxy) -> Result<(), Error> {
    if !service.is_simulating().await? {
        println!("Please disconnect before running set. Type <set --help> for more information");
        return Ok(());
    }
    let commands: Vec<&str> = args.split(" ").collect();
    if commands.len() <= 1 || commands[0] == "--help" {
        print_set_help_message();
        return Ok(());
    } else if commands.len() % 2 != 0 {
        println!("Incorrect number of args. Type <set --help> for more information");
        return Ok(());
    }
    for i in (0..).take(commands.len()).step_by(2) {
        let field = commands[i];
        let arg = commands[i + 1];
        let _ = match field {
            "BatteryPercentage" => set_battery_percentage(arg, service)?,
            "BatteryStatus" => set_battery_status(arg, service)?,
            "ChargeStatus" => set_charge_status(arg, service)?,
            "ChargeSource" => set_charge_source(arg, service)?,
            "LevelStatus" => set_level_status(arg, service)?,
            "TimeRemaining" => set_time_remaining(arg, service)?,
            _ => println!("Incorrect Battery Field {}", field),
        };
    }
    Ok(())
}

/// Handle a single raw input command from a user and indicate whether the command should
/// result in continuation or breaking of the read evaluate print loop.
async fn handle_command(
    service: &BatterySimulatorProxy,
    cmd: Command,
    args: Vec<String>,
) -> Result<ReplControl, Error> {
    let args = args.join(" ");
    match cmd {
        Command::Get => print_battery_info(service).await,
        Command::Set => set_all_information(args, service).await,
        Command::Reconnect => service.reconnect_real_battery().map_err(|e| format_err!("{}", e)),
        Command::Disconnect => service.disconnect_real_battery().map_err(|e| format_err!("{}", e)),
        Command::Help => Ok(println!("{}", Command::help_msg().to_string())),
        Command::Exit | Command::Quit => return Ok(ReplControl::Break),
    }?;

    Ok(ReplControl::Continue)
}

/// Parse a single raw input command from a user into the command type and argument lsit
fn parse_command(line: String) -> ParseResult<(Command, Vec<String>)> {
    let components: Vec<_> = line.trim().split_whitespace().collect();
    match components.split_first() {
        Some((raw_cmd, args)) => match raw_cmd.parse() {
            Ok(cmd) => {
                let args = args.into_iter().map(|s| s.to_string()).collect();
                ParseResult::Valid((cmd, args))
            }
            Err(_) => ParseResult::Error(format!("\"{}\" is not a valid command", raw_cmd)),
        },
        None => ParseResult::Empty,
    }
}

// Parses the command passed and if it's a valid command then it would handle what it should do
async fn parse_and_handle_cmd(
    service: &BatterySimulatorProxy,
    line: String,
) -> Result<ReplControl, Error> {
    match parse_command(line) {
        ParseResult::Valid((cmd, args)) => handle_command(service, cmd, args).await,
        ParseResult::Empty => Ok(ReplControl::Continue),
        ParseResult::Error(err) => {
            println!("{}", err);
            Ok(ReplControl::Continue)
        }
    }
}

/// Generates a rustyline `Editor` in a separate thread to manage user input. This input is returned
/// as a `Stream` of lines entered by the user.
///
/// The thread exits and the `Stream` is exhausted when an error occurs on stdin or the user
/// sends a ctrl-c or ctrl-d sequence.
///
/// Because rustyline shares control over output to the screen with other parts of the system, a
/// `Sink` is passed to the caller to send acknowledgements that a command has been processed and
/// that rustyline should handle the next line of input.
fn cmd_stream() -> (impl Stream<Item = String>, impl Sink<(), Error = SendError>) {
    // Editor thread and command processing thread must be synchronized so that output
    // is printed in the correct order.
    let (mut cmd_sender, cmd_receiver) = channel(512);
    let (ack_sender, mut ack_receiver) = channel(512);
    thread::spawn(move || -> Result<(), Error> {
        let mut exec = fasync::Executor::new().context("error creating the readline event loop")?;
        let fut = async {
            let config = Config::builder()
                .auto_add_history(true)
                .history_ignore_space(true)
                .completion_type(CompletionType::List)
                .edit_mode(EditMode::Vi)
                .build();
            let mut rl: Editor<CmdHelper> = Editor::with_config(config);
            // Add tab completion
            let c = CmdHelper::new();
            rl.set_helper(Some(c));
            loop {
                let readline = rl.readline(PROMPT);
                match readline {
                    Ok(line) => {
                        cmd_sender.try_send(line)?;
                    }
                    Err(ReadlineError::Eof) | Err(ReadlineError::Interrupted) => {
                        return Ok(());
                    }
                    Err(e) => {
                        println!("Error: {:?}", e);
                        return Err(e.into());
                    }
                }
                // Wait until processing thread is finished evaluating the last command
                // before running the next loop in the repl
                ack_receiver.next().await;
            }
        };
        exec.run_singlethreaded(fut)
    });
    (cmd_receiver, ack_sender)
}

async fn run_repl(service: BatterySimulatorProxy) -> Result<(), Error> {
    // `cmd_stream` blocks on input in a separate thread and passes commands and acks back to
    // the main thread via async channels.
    let (mut commands, mut acks) = cmd_stream();
    while let Some(cmd) = commands.next().await {
        match parse_and_handle_cmd(&service, cmd).await {
            Ok(ReplControl::Continue) => {}
            Ok(ReplControl::Break) => break,
            Err(e) => println!("Error handling command: {}", e),
        }
        acks.send(()).await?;
    }
    Ok(())
}

#[fasync::run_singlethreaded]
async fn main() -> Result<(), Error> {
    syslog::init_with_tags(&[LOG_TAG]).expect("Can't init logger - batsim main");
    println!("Welcome to the Battery Simulator. Type help and <Enter> to see all the options!");
    let battery_simulator = connect_to_service::<spower::BatterySimulatorMarker>()?;
    let repl = run_repl(battery_simulator)
        .unwrap_or_else(|e| eprintln!("REPL failed unexpectedly {:?}", e));

    // Pins repl value on the stack
    pin_mut!(repl);

    repl.await;

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[fasync::run_singlethreaded(test)]
    async fn test_disconnect() {
        // Connect to service
        let battery_simulator = connect_to_service::<spower::BatterySimulatorMarker>().unwrap();
        // Disconnect battery
        let res = battery_simulator.disconnect_real_battery();
        assert!(res.is_ok(), "Failed to disconnect");
        // Test disconnect
        let res = battery_simulator.is_simulating().await;
        assert_eq!(res.unwrap(), true);
        // Reconnect battery
        let res = battery_simulator.reconnect_real_battery();
        assert!(res.is_ok(), "Failed to reconnect");
    }

    #[fasync::run_singlethreaded(test)]
    async fn test_set_battery_percentage() {
        // Connect to service
        let battery_simulator = connect_to_service::<spower::BatterySimulatorMarker>().unwrap();
        // Disconnect battery
        let res = battery_simulator.disconnect_real_battery();
        assert!(res.is_ok(), "Failed to disconnect");
        // Set Battery Percentage
        let res = set_battery_percentage("12.0", &battery_simulator);
        assert!(res.is_ok(), "Failed to set battery percentage");
        // Check Battery Percentage
        let battery_info = battery_simulator.get_battery_info().await;
        assert_eq!(battery_info.unwrap().level_percent.unwrap(), 12.0);
        // Reconnect battery
        let res = battery_simulator.reconnect_real_battery();
        assert!(res.is_ok(), "Failed to reconnect");
    }

    #[fasync::run_singlethreaded(test)]
    async fn test_set_battery_status() {
        // Connect to service
        let battery_simulator = connect_to_service::<spower::BatterySimulatorMarker>().unwrap();
        // Disconnect battery
        let res = battery_simulator.disconnect_real_battery();
        assert!(res.is_ok(), "Failed to disconnect");
        // Set Battery Status
        let res = set_battery_status("OK", &battery_simulator);
        assert!(res.is_ok(), "Failed to set battery status");
        // Check Battery Status
        let battery_info = battery_simulator.get_battery_info().await;
        assert_eq!(battery_info.unwrap().status.unwrap(), fpower::BatteryStatus::Ok);
        // Reconnect battery
        let res = battery_simulator.reconnect_real_battery();
        assert!(res.is_ok(), "Failed to reconnect");
    }

    #[fasync::run_singlethreaded(test)]
    async fn test_set_charge_status() {
        // Connect to service
        let battery_simulator = connect_to_service::<spower::BatterySimulatorMarker>().unwrap();
        // Disconnect battery
        let res = battery_simulator.disconnect_real_battery();
        assert!(res.is_ok(), "Failed to disconnect");
        // Set Charge Status
        let res = set_charge_status("NOT_CHARGING", &battery_simulator);
        assert!(res.is_ok(), "Failed to set charge status");
        // Check Charge Status
        let battery_info = battery_simulator.get_battery_info().await;
        assert_eq!(battery_info.unwrap().charge_status.unwrap(), fpower::ChargeStatus::NotCharging);
        // Reconnect battery
        let res = battery_simulator.reconnect_real_battery();
        assert!(res.is_ok(), "Failed to reconnect");
    }

    #[fasync::run_singlethreaded(test)]
    async fn test_set_charge_source() {
        // Connect to service
        let battery_simulator = connect_to_service::<spower::BatterySimulatorMarker>().unwrap();
        // Disconnect battery
        let res = battery_simulator.disconnect_real_battery();
        assert!(res.is_ok(), "Failed to disconnect");
        // Set Charge Status
        let res = set_charge_source("WIRELESS", &battery_simulator);
        assert!(res.is_ok(), "Failed to set charge source");
        // Check Charge Status
        let battery_info = battery_simulator.get_battery_info().await;
        assert_eq!(battery_info.unwrap().charge_source.unwrap(), fpower::ChargeSource::Wireless);
        // Reconnect battery
        let res = battery_simulator.reconnect_real_battery();
        assert!(res.is_ok(), "Failed to reconnect");
    }

    #[fasync::run_singlethreaded(test)]
    async fn test_set_level_status() {
        // Connect to service
        let battery_simulator = connect_to_service::<spower::BatterySimulatorMarker>().unwrap();
        // Disconnect battery
        let res = battery_simulator.disconnect_real_battery();
        assert!(res.is_ok(), "Failed to disconnect");
        // Set Level Status
        let res = set_level_status("CRITICAL", &battery_simulator);
        assert!(res.is_ok(), "Failed to set charge source");
        // Check Level Status
        let battery_info = battery_simulator.get_battery_info().await;
        assert_eq!(battery_info.unwrap().level_status.unwrap(), fpower::LevelStatus::Critical);
        // Reconnect battery
        let res = battery_simulator.reconnect_real_battery();
        assert!(res.is_ok(), "Failed to reconnect");
    }
}