#![deny(unsafe_code)]

extern crate chrono;
#[macro_use]
extern crate clap;
#[macro_use]
extern crate lazy_static;
extern crate http;
extern crate marionette as marionette_rs;
extern crate mozdevice;
extern crate mozprofile;
extern crate mozrunner;
extern crate mozversion;
extern crate regex;
extern crate serde;
#[macro_use]
extern crate serde_derive;
extern crate serde_json;
extern crate tempfile;
extern crate url;
extern crate uuid;
extern crate webdriver;
extern crate yaml_rust;
extern crate zip;

#[macro_use]
extern crate log;

use std::env;
use std::net::{IpAddr, SocketAddr, ToSocketAddrs};
use std::path::PathBuf;
use std::process::ExitCode;

use std::str::FromStr;

use clap::{Arg, ArgAction, Command};

macro_rules! try_opt {
    ($expr:expr, $err_type:expr, $err_msg:expr) => {{
        match $expr {
            Some(x) => x,
            None => return Err(WebDriverError::new($err_type, $err_msg)),
        }
    }};
}

mod android;
mod browser;
mod build;
mod capabilities;
mod command;
mod logging;
mod marionette;
mod prefs;

#[cfg(test)]
pub mod test;

use crate::command::extension_routes;
use crate::logging::Level;
use crate::marionette::{MarionetteHandler, MarionetteSettings};
use anyhow::{bail, Result as ProgramResult};
use clap::ArgMatches;
use mozdevice::AndroidStorageInput;
use url::{Host, Url};

const EXIT_USAGE: u8 = 64;
const EXIT_UNAVAILABLE: u8 = 69;

#[allow(clippy::large_enum_variant)]
enum Operation {
    Help,
    Version,
    Server {
        log_level: Option<Level>,
        log_truncate: bool,
        address: SocketAddr,
        allow_hosts: Vec<Host>,
        allow_origins: Vec<Url>,
        settings: MarionetteSettings,
        deprecated_storage_arg: bool,
    },
}

/// Get a socket address from the provided host and port
///
/// # Arguments
/// * `webdriver_host` - The hostname on which the server will listen
/// * `webdriver_port` - The port on which the server will listen
///
/// When the host and port resolve to multiple addresses, prefer
/// IPv4 addresses vs IPv6.
fn server_address(webdriver_host: &str, webdriver_port: u16) -> ProgramResult<SocketAddr> {
    let mut socket_addrs = match format!("{}:{}", webdriver_host, webdriver_port).to_socket_addrs()
    {
        Ok(addrs) => addrs.collect::<Vec<_>>(),
        Err(e) => bail!("{}: {}:{}", e, webdriver_host, webdriver_port),
    };
    if socket_addrs.is_empty() {
        bail!(
            "Unable to resolve host: {}:{}",
            webdriver_host,
            webdriver_port
        )
    }
    // Prefer ipv4 address
    socket_addrs.sort_by(|a, b| {
        let a_val = i32::from(!a.ip().is_ipv4());
        let b_val = i32::from(!b.ip().is_ipv4());
        a_val.partial_cmp(&b_val).expect("Comparison failed")
    });
    Ok(socket_addrs.remove(0))
}

/// Parse a given string into a Host
fn parse_hostname(webdriver_host: &str) -> Result<Host, url::ParseError> {
    let host_str = if let Ok(ip_addr) = IpAddr::from_str(webdriver_host) {
        // In this case we have an IP address as the host
        if ip_addr.is_ipv6() {
            // Convert to quoted form
            format!("[{}]", &webdriver_host)
        } else {
            webdriver_host.into()
        }
    } else {
        webdriver_host.into()
    };

    Host::parse(&host_str)
}

/// Get a list of default hostnames to allow
///
/// This only covers domain names, not IP addresses, since IP adresses
/// are always accepted.
fn get_default_allowed_hosts(ip: IpAddr) -> Vec<Host> {
    let localhost_is_loopback = ("localhost".to_string(), 80)
        .to_socket_addrs()
        .map(|addr_iter| {
            addr_iter
                .map(|addr| addr.ip())
                .filter(|ip| ip.is_loopback())
        })
        .iter()
        .len()
        > 0;
    if ip.is_loopback() && localhost_is_loopback {
        vec![Host::parse("localhost").unwrap()]
    } else {
        vec![]
    }
}

fn get_allowed_hosts(host: Host, allow_hosts: Option<clap::parser::ValuesRef<Host>>) -> Vec<Host> {
    allow_hosts
        .map(|hosts| hosts.cloned().collect())
        .unwrap_or_else(|| match host {
            Host::Domain(_) => {
                vec![host.clone()]
            }
            Host::Ipv4(ip) => get_default_allowed_hosts(IpAddr::V4(ip)),
            Host::Ipv6(ip) => get_default_allowed_hosts(IpAddr::V6(ip)),
        })
}

fn get_allowed_origins(allow_origins: Option<clap::parser::ValuesRef<Url>>) -> Vec<Url> {
    allow_origins.into_iter().flatten().cloned().collect()
}

fn parse_args(args: &ArgMatches) -> ProgramResult<Operation> {
    if args.get_flag("help") {
        return Ok(Operation::Help);
    } else if args.get_flag("version") {
        return Ok(Operation::Version);
    }

    let log_level = if let Some(log_level) = args.get_one::<String>("log_level") {
        Level::from_str(log_level).ok()
    } else {
        Some(match args.get_count("verbosity") {
            0 => Level::Info,
            1 => Level::Debug,
            _ => Level::Trace,
        })
    };

    let webdriver_host = args.get_one::<String>("webdriver_host").unwrap();
    let webdriver_port = {
        let s = args.get_one::<String>("webdriver_port").unwrap();
        match u16::from_str(s) {
            Ok(n) => n,
            Err(e) => bail!("invalid --port: {}: {}", e, s),
        }
    };

    let android_storage = args
        .get_one::<String>("android_storage")
        .and_then(|arg| AndroidStorageInput::from_str(arg).ok())
        .unwrap_or(AndroidStorageInput::Auto);

    let binary = args.get_one::<String>("binary").map(PathBuf::from);

    let profile_root = args.get_one::<String>("profile_root").map(PathBuf::from);

    // Try to create a temporary directory on startup to check that the directory exists and is writable
    {
        let tmp_dir = if let Some(ref tmp_root) = profile_root {
            tempfile::tempdir_in(tmp_root)
        } else {
            tempfile::tempdir()
        };
        if tmp_dir.is_err() {
            bail!(
                "Unable to write to temporary directory; consider --profile-root with a writeable directory"
            )
        }
    }

    let marionette_host = args.get_one::<String>("marionette_host").unwrap();
    let marionette_port = match args.get_one::<String>("marionette_port") {
        Some(s) => match u16::from_str(s) {
            Ok(n) => Some(n),
            Err(e) => bail!("invalid --marionette-port: {}", e),
        },
        None => None,
    };

    // For Android the port on the device must be the same as the one on the
    // host. For now default to 9222, which is the default for --remote-debugging-port.
    let websocket_port = match args.get_one::<String>("websocket_port") {
        Some(s) => match u16::from_str(s) {
            Ok(n) => n,
            Err(e) => bail!("invalid --websocket-port: {}", e),
        },
        None => 9222,
    };

    let host = match parse_hostname(webdriver_host) {
        Ok(name) => name,
        Err(e) => bail!("invalid --host {}: {}", webdriver_host, e),
    };

    let allow_hosts = get_allowed_hosts(host, args.get_many("allow_hosts"));

    let allow_origins = get_allowed_origins(args.get_many("allow_origins"));

    let address = server_address(webdriver_host, webdriver_port)?;

    let settings = MarionetteSettings {
        binary,
        profile_root,
        connect_existing: args.get_flag("connect_existing"),
        host: marionette_host.into(),
        port: marionette_port,
        websocket_port,
        allow_hosts: allow_hosts.clone(),
        allow_origins: allow_origins.clone(),
        jsdebugger: args.get_flag("jsdebugger"),
        android_storage,
        system_access: args.get_flag("allow_system_access"),
    };
    Ok(Operation::Server {
        log_level,
        log_truncate: !args.get_flag("log_no_truncate"),
        allow_hosts,
        allow_origins,
        address,
        settings,
        deprecated_storage_arg: args.contains_id("android_storage"),
    })
}

fn inner_main(operation: Operation, cmd: &mut Command) -> ProgramResult<()> {
    match operation {
        Operation::Help => print_help(cmd),
        Operation::Version => print_version(),

        Operation::Server {
            log_level,
            log_truncate,
            address,
            allow_hosts,
            allow_origins,
            settings,
            deprecated_storage_arg,
        } => {
            if let Some(ref level) = log_level {
                logging::init_with_level(*level, log_truncate).unwrap();
            } else {
                logging::init(log_truncate).unwrap();
            }

            if deprecated_storage_arg {
                warn!("--android-storage argument is deprecated and will be removed soon.");
            };

            let handler = MarionetteHandler::new(settings);
            let listening = webdriver::server::start(
                address,
                allow_hosts,
                allow_origins,
                handler,
                extension_routes(),
            )?;
            info!("Listening on {}", listening.socket);
        }
    }

    Ok(())
}

fn main() -> ExitCode {
    let mut cmd = make_command();

    let args = match cmd.try_get_matches_from_mut(env::args()) {
        Ok(args) => args,
        Err(e) => {
            // Clap already says "error:" and don't repeat help.
            eprintln!("{}: {}", get_program_name(), e);
            return ExitCode::from(EXIT_USAGE);
        }
    };

    let operation = match parse_args(&args) {
        Ok(op) => op,
        Err(e) => {
            eprintln!("{}: error: {}", get_program_name(), e);
            print_help(&mut cmd);
            return ExitCode::from(EXIT_USAGE);
        }
    };

    if let Err(e) = inner_main(operation, &mut cmd) {
        eprintln!("{}: error: {}", get_program_name(), e);
        print_help(&mut cmd);
        return ExitCode::from(EXIT_UNAVAILABLE);
    }

    ExitCode::SUCCESS
}

fn make_command() -> Command {
    Command::new(format!("geckodriver {}", build::build_info()))
        .disable_help_flag(true)
        .disable_version_flag(true)
        .about("WebDriver implementation for Firefox")
        .arg(
            Arg::new("allow_hosts")
                .long("allow-hosts")
                .num_args(1..)
                .value_parser(clap::builder::ValueParser::new(Host::parse))
                .value_name("ALLOW_HOSTS")
                .help("List of hostnames to allow. By default the value of --host is allowed, and in addition if that's a well known local address, other variations on well known local addresses are allowed. If --allow-hosts is provided only exactly those hosts are allowed."),
        )
        .arg(
            Arg::new("allow_origins")
                .long("allow-origins")
                .num_args(1..)
                .value_parser(clap::builder::ValueParser::new(Url::parse))
                .value_name("ALLOW_ORIGINS")
                .help("List of request origins to allow. These must be formatted as scheme://host:port. By default any request with an origin header is rejected. If --allow-origins is provided then only exactly those origins are allowed."),
        )
        .arg(
            Arg::new("allow_system_access")
                .long("allow-system-access")
                .action(ArgAction::SetTrue)
                .help("Enable privileged access to the application's parent process"),
        )
        .arg(
            Arg::new("android_storage")
                .long("android-storage")
                .value_parser(["auto", "app", "internal", "sdcard"])
                .value_name("ANDROID_STORAGE")
                .help("Selects storage location to be used for test data (deprecated)."),
        )
        .arg(
            Arg::new("binary")
                .short('b')
                .long("binary")
                .num_args(1)
                .value_name("BINARY")
                .help("Path to the Firefox binary"),
        )
        .arg(
            Arg::new("connect_existing")
                .long("connect-existing")
                .requires("marionette_port")
                .action(ArgAction::SetTrue)
                .help("Connect to an existing Firefox instance"),
        )
        .arg(
            Arg::new("help")
                .short('h')
                .long("help")
                .action(ArgAction::SetTrue)
                .help("Prints this message"),
        )
        .arg(
            Arg::new("webdriver_host")
                .long("host")
                .num_args(1)
                .value_name("HOST")
                .default_value("127.0.0.1")
                .help("Host IP to use for WebDriver server"),
        )
        .arg(
            Arg::new("jsdebugger")
                .long("jsdebugger")
                .action(ArgAction::SetTrue)
                .help("Attach browser toolbox debugger for Firefox"),
        )
        .arg(
            Arg::new("log_level")
                .long("log")
                .num_args(1)
                .value_name("LEVEL")
                .value_parser(["fatal", "error", "warn", "info", "config", "debug", "trace"])
                .help("Set Gecko log level"),
        )
        .arg(
            Arg::new("log_no_truncate")
                .long("log-no-truncate")
                .action(ArgAction::SetTrue)
                .help("Disable truncation of long log lines"),
        )
        .arg(
            Arg::new("marionette_host")
                .long("marionette-host")
                .num_args(1)
                .value_name("HOST")
                .default_value("127.0.0.1")
                .help("Host to use to connect to Gecko"),
        )
        .arg(
            Arg::new("marionette_port")
                .long("marionette-port")
                .num_args(1)
                .value_name("PORT")
                .help("Port to use to connect to Gecko [default: system-allocated port]"),
        )
        .arg(
            Arg::new("webdriver_port")
                .short('p')
                .long("port")
                .num_args(1)
                .value_name("PORT")
                .default_value("4444")
                .help("Port to use for WebDriver server"),
        )
        .arg(
            Arg::new("profile_root")
                .long("profile-root")
                .num_args(1)
                .value_name("PROFILE_ROOT")
                .help("Directory in which to create profiles. Defaults to the system temporary directory."),
        )
        .arg(
            Arg::new("verbosity")
                .conflicts_with("log_level")
                .short('v')
                .action(ArgAction::Count)
                .help("Log level verbosity (-v for debug and -vv for trace level)"),
        )
        .arg(
            Arg::new("version")
                .short('V')
                .long("version")
                .action(ArgAction::SetTrue)
                .help("Prints version and copying information"),
        )
        .arg(
            Arg::new("websocket_port")
                .long("websocket-port")
                .num_args(1)
                .value_name("PORT")
                .conflicts_with("connect_existing")
                .help("Port to use to connect to WebDriver BiDi [default: 9222]"),
        )
}

fn get_program_name() -> String {
    env::args().next().unwrap()
}

fn print_help(cmd: &mut Command) {
    cmd.print_help().ok();
    println!();
}

fn print_version() {
    println!("geckodriver {}", build::build_info());
    println!();
    println!("The source code of this program is available from");
    println!("testing/geckodriver in https://hg.mozilla.org/mozilla-central.");
    println!();
    println!("This program is subject to the terms of the Mozilla Public License 2.0.");
    println!("You can obtain a copy of the license at https://mozilla.org/MPL/2.0/.");
}
