// Copyright 2021 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.
use crate::cipd;
use crate::types::{
    get_fuchsia_sdk_dir, get_fuchsia_sdk_tools_dir, get_sdk_data_dir, read_env_path, FuchsiaPaths,
};
use {
    ansi_term::Colour::{Red, Yellow},
    anyhow::{anyhow, format_err, Result},
    errors::ffx_error,
    fuchsia_async::LocalExecutor,
    hyper::{StatusCode, Uri},
    serde::Deserialize,
    std::{
        env, fmt, fs,
        fs::{create_dir_all, read_to_string, remove_dir_all, remove_file},
        io::BufReader,
        path::PathBuf,
    },
    walkdir::WalkDir,
};

#[derive(Default, Deserialize)]
pub struct Tools(Vec<Tool>);

#[derive(Default, Deserialize)]
pub struct Tool {
    pub cpu: String,
    pub label: String,
    pub name: String,
    pub os: String,
    pub path: String,
}

impl Tools {
    pub fn from_build_dir(path: std::path::PathBuf) -> Result<Self> {
        let manifest_path = path.join("tool_paths.json");
        fs::File::open(manifest_path.clone())
            .map_err(|e| ffx_error!("Cannot open file {:?} \nerror: {:?}", manifest_path, e))
            .map(BufReader::new)
            .map(serde_json::from_reader)?
            .map_err(|e| anyhow!("json parsing errored {}", e))
    }

    #[cfg(test)]
    pub fn from_string(content: &str) -> Result<Self> {
        serde_json::from_str(content).map_err(|e| anyhow!("json parsing errored {}", e))
    }

    pub fn find_path(&self, name: &str) -> Result<String> {
        self.find_path_with_arch(
            name,
            match std::env::consts::ARCH {
                "x86_64" => "x64",
                "aarch64" => "arm64",
                _ => "unsupported",
            },
        )
    }

    pub fn find_path_with_arch(&self, name: &str, host_cpu: &str) -> Result<String> {
        self.0
            .iter()
            .find(|x| x.name == name && x.cpu == host_cpu)
            .map(|i| i.path.clone())
            .ok_or(anyhow!("cannot find matching tool for name {}, arch {}", name, host_cpu))
    }
}

#[derive(Clone)]
pub struct HostTools {
    pub aemu: PathBuf,
    pub far: Option<PathBuf>,
    pub ffx: Option<PathBuf>,
    pub fvm: Option<PathBuf>,
    pub grpcwebproxy: PathBuf,
    pub pm: Option<PathBuf>,
    pub vdl: PathBuf,
    pub zbi: PathBuf,
    pub is_sdk: bool,
}

impl fmt::Debug for HostTools {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        writeln!(f, "[fvdl] tool aemu {:?}", self.aemu)?;
        writeln!(f, "[fvdl] tool far {:?}", self.far)?;
        writeln!(f, "[fvdl] tool ffx {:?}", self.ffx)?;
        writeln!(f, "[fvdl] tool fvm {:?}", self.fvm)?;
        writeln!(f, "[fvdl] tool grpcwebproxy {:?}", self.grpcwebproxy)?;
        writeln!(f, "[fvdl] tool pm {:?}", self.pm)?;
        writeln!(f, "[fvdl] tool vdl {:?}", self.vdl)?;
        write!(f, "[fvdl] tool zbi {:?}", self.zbi)
    }
}

impl HostTools {
    /// Initialize host tools for in-tree usage via fx vdl.
    ///
    /// Environment variable HOST_OUT_DIR, PREBUILT_AEMU_DIR,
    /// REBUILT_GRPCWEBPROXY_DIR, and PREBUILT_VDL_DIR are optional.
    pub fn from_tree_env(f: &mut impl FuchsiaPaths) -> Result<Self> {
        Ok(Self {
            // prebuilt binaries that can be optionally fetched from cipd.
            aemu: match read_env_path("PREBUILT_AEMU_DIR") {
                Ok(val) => val.join("emulator"),
                _ => {
                    let fuchsia_root = f.find_fuchsia_root()?;
                    WalkDir::new(fuchsia_root.join("prebuilt/third_party/android/aemu/release"))
                        .into_iter()
                        .filter_map(|e| e.ok())
                        .find(|e| e.file_name() == "emulator")
                        .ok_or(anyhow!(
                            "Cannot find emulator executable from {:?}",
                            fuchsia_root
                                .join("prebuilt/third_party/android/aemu/release")
                                .display()
                        ))?
                        .path()
                        .to_path_buf()
                }
            },
            grpcwebproxy: match read_env_path("PREBUILT_GRPCWEBPROXY_DIR") {
                Ok(val) => val.join("grpcwebproxy"),
                _ => {
                    let fuchsia_root = f.find_fuchsia_root()?;
                    WalkDir::new(fuchsia_root.join("prebuilt/third_party/grpcwebproxy"))
                        .into_iter()
                        .filter_map(|e| e.ok())
                        .find(|e| e.file_name() == "grpcwebproxy" && e.file_type().is_file())
                        .ok_or(anyhow!(
                            "Cannot find grpcwebproxy executable from {:?}",
                            fuchsia_root.join("prebuilt/third_party/grpcwebproxy").display()
                        ))?
                        .path()
                        .to_path_buf()
                }
            },
            vdl: match read_env_path("PREBUILT_VDL_DIR") {
                Ok(val) => val.join("device_launcher"),
                _ => f.find_fuchsia_root()?.join("prebuilt/vdl/device_launcher"),
            },
            far: match read_env_path("HOST_OUT_DIR") {
                Ok(val) => Some(val.join("far")),
                _ => f.get_tool_path("far").ok(),
            },
            ffx: match read_env_path("HOST_OUT_DIR") {
                Ok(val) => Some(val.join("ffx")),
                _ => f.get_tool_path("ffx").ok(),
            },
            fvm: match read_env_path("HOST_OUT_DIR") {
                Ok(val) => Some(val.join("fvm")),
                _ => f.get_tool_path("fvm").ok(),
            },
            pm: match read_env_path("HOST_OUT_DIR") {
                Ok(val) => Some(val.join("pm")),
                _ => f.get_tool_path("pm").ok(),
            },
            zbi: match read_env_path("HOST_OUT_DIR") {
                Ok(val) => val.join("zbi"),
                _ => f.get_tool_path("zbi")?,
            },
            is_sdk: false,
        })
    }

    /// Initialize host tools for GN SDK usage.
    ///
    /// First check the existence of environment variable TOOL_DIR, if not specified
    /// look for host tools in the program's containing directory.
    pub fn from_sdk_env() -> Result<Self> {
        let sdk_tool_dir = match read_env_path("TOOL_DIR") {
            Ok(dir) => dir,
            _ => get_fuchsia_sdk_tools_dir()?,
        };

        Ok(Self {
            // prebuilt binaries that can be optionally fetched from cipd.
            aemu: PathBuf::new(),
            grpcwebproxy: PathBuf::new(),
            vdl: PathBuf::new(),
            // in-tree tools that are packaged with GN SDK.
            far: Some(sdk_tool_dir.join("far")),
            ffx: Some(sdk_tool_dir.join("ffx")),
            fvm: Some(sdk_tool_dir.join("fvm")),
            pm: Some(sdk_tool_dir.join("pm")),
            zbi: sdk_tool_dir.join("zbi"),
            is_sdk: true,
        })
    }

    /// Reads the <prebuild>.version file stored in <sdk_root>/bin/<prebuild>.version
    ///
    /// # Arguments
    ///
    /// * `file_name` - <prebuild>.version file name.
    ///     ex: 'aemu.version', this file is expected to be found under <sdk_root>/bin
    pub fn read_prebuild_version(&self, file_name: &str) -> Result<String> {
        if self.is_sdk {
            let version_file = get_fuchsia_sdk_dir()?.join("bin").join(file_name);
            if version_file.exists() {
                println!(
                    "{}",
                    Yellow.paint(format!(
                        "[fvdl] reading prebuild version file from: {}",
                        version_file.display()
                    ))
                );
                return Ok(read_to_string(version_file)?);
            };
            println!(
                "{}",
                Red.paint(format!(
                    "[fvdl] prebuild version file: {} does not exist.",
                    version_file.display()
                ))
            );
            return Err(format_err!(
                "reading prebuilt version errored: file {:?} does not exist.",
                version_file
            ));
        }
        return Err(format_err!("reading prebuild version file is only support with --sdk flag."));
    }

    /// Downloads & extract aemu.zip from CIPD, and returns the path containing the emulator executable.
    ///
    /// # Arguments
    ///
    /// * `label` - cipd label that specified a particular aemu version
    /// * `cipd_pkg` - this is appended to cipd url https://chrome-infra-packages.appspot.com/dl/fuchsia/third_party/.
    pub fn download_and_extract(&self, label: String, cipd_pkg: String) -> Result<PathBuf> {
        let mut executor = LocalExecutor::new().unwrap();
        executor.run_singlethreaded(async move {
            let root_path = match read_env_path("FEMU_DOWNLOAD_DIR") {
                Ok(path) => path,
                _ => {
                    let default_path = get_sdk_data_dir()?.join("femu");
                    if !default_path.exists() {
                        create_dir_all(&default_path)?;
                    }
                    default_path
                }
            };
            let arch = match env::consts::OS {
                "macos" => "mac-amd64",
                _ => "linux-amd64",
            };
            let url = format!(
                "https://chrome-infra-packages.appspot.com/dl/fuchsia/{}/{}/+/{}",
                cipd_pkg, arch, label
            )
            .parse::<Uri>()?;
            let name = cipd_pkg
                .split('/')
                .last()
                .ok_or(anyhow!("Cannot identify filename from {}", cipd_pkg))?;
            let cipd_zip = root_path.join(format!("{}-{}.zip", name, label.replace(":", "-")));
            let unzipped_root = root_path.join(format!("{}-{}", name, label.replace(":", "-")));

            match label.as_str() {
                // "latest" and "integration" labels always point to the newest release.
                // We cannot assume that the binary is the same as last fetched. Therefore
                // we will always re-download and unzip when used.
                //
                // TODO(yuanzhi) When using fuchsia/third_party/android/aemu/release/...
                // we no longer add "integration" ref to any cipd instances. Keeping the "integration" check
                // for now for any backward compatibility we may have to support.
                "latest" | "integration" => {
                    if cipd_zip.exists() {
                        remove_file(&cipd_zip)?;
                    }
                    if unzipped_root.exists() {
                        remove_dir_all(&unzipped_root)?;
                    }
                }
                _ => {
                    if unzipped_root.exists() {
                        return Ok(unzipped_root);
                    }
                }
            };
            let status = cipd::download(url.clone(), &cipd_zip).await?;
            if status == StatusCode::OK {
                cipd::extract_zip(&cipd_zip, &unzipped_root, false /* debug */)?;
                Ok(unzipped_root)
            } else {
                Err(format_err!(
                    "Cannot download file from cipd path {}. Got status code {}",
                    url,
                    status.as_str(),
                ))
            }
        })
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::types::InTreePaths;
    use crate::types::MockFuchsiaPaths;
    use serial_test::serial;
    use std::fs::{read_dir, File};
    use std::io::Write;
    use tempfile::Builder;

    const TOOLS_JSON: &str = r#"[
        {
          "cpu": "x64",
          "label": "//:tool_paths.llvm-tools(//build/toolchain/fuchsia:x64)",
          "name": "clang-doc",
          "os": "linux",
          "path": "../../prebuilt/third_party/clang/linux-x64/bin/clang-doc"
        },
        {
          "cpu": "x64",
          "label": "//src/developer/ffx:ffx_bin(//build/toolchain:host_x64)",
          "name": "ffx",
          "os": "linux",
          "path": "host_x64/ffx"
        },
        {
          "cpu": "x64",
          "label": "//zircon/tools/zbi:zbi(//build/toolchain:host_x64)",
          "name": "zbi",
          "os": "linux",
          "path": "host_x64/zbi"
        },
        {
          "cpu": "arm64",
          "label": "//src/storage/bin/fvm:fvm(//build/toolchain:host_arm64)",
          "name": "fvm",
          "os": "linux",
          "path": "host_arm64/fvm"
        },
        {
          "cpu": "x64",
          "label": "//src/storage/bin/fvm:fvm(//build/toolchain:host_x64)",
          "name": "fvm",
          "os": "linux",
          "path": "host_x64/fvm"
        },
        {
          "cpu": "x64",
          "label": "//:tool_paths.llvm-tools(//build/toolchain/fuchsia:x64)",
          "name": "clang-tidy",
          "os": "linux",
          "path": "../../prebuilt/third_party/clang/linux-x64/bin/clang-tidy"
        },
        {
          "cpu": "x64",
          "label": "//:tool_paths.llvm-tools(//build/toolchain/fuchsia:x64)",
          "name": "clangd",
          "os": "linux",
          "path": "../../prebuilt/third_party/clang/linux-x64/bin/clangd"
        }
      ]"#;

    #[test]
    fn test_tools_parse() -> Result<()> {
        let tools = Tools::from_string(TOOLS_JSON)?;
        assert_eq!(tools.find_path_with_arch("ffx", "x64")?, "host_x64/ffx");
        assert_eq!(tools.find_path_with_arch("zbi", "x64")?, "host_x64/zbi");
        assert_eq!(tools.find_path_with_arch("fvm", "x64")?, "host_x64/fvm");
        Ok(())
    }

    #[test]
    #[serial]
    fn test_host_tools() -> Result<()> {
        env::set_var("HOST_OUT_DIR", "/host/out");
        env::set_var("PREBUILT_AEMU_DIR", "/host/out/aemu");
        env::set_var("PREBUILT_VDL_DIR", "/host/out/vdl");
        env::set_var("PREBUILT_GRPCWEBPROXY_DIR", "/host/out/grpcwebproxy");

        let host_tools =
            HostTools::from_tree_env(&mut InTreePaths { root_dir: None, build_dir: None })?;
        assert_eq!(host_tools.aemu.to_str().unwrap(), "/host/out/aemu/emulator");
        assert_eq!(host_tools.vdl.to_str().unwrap(), "/host/out/vdl/device_launcher");
        assert_eq!(host_tools.far.as_ref().unwrap().to_str().unwrap(), "/host/out/far");
        assert_eq!(host_tools.ffx.as_ref().unwrap().to_str().unwrap(), "/host/out/ffx");
        assert_eq!(host_tools.fvm.as_ref().unwrap().to_str().unwrap(), "/host/out/fvm");
        assert_eq!(host_tools.pm.as_ref().unwrap().to_str().unwrap(), "/host/out/pm");
        assert_eq!(host_tools.zbi.to_str().unwrap(), "/host/out/zbi");
        Ok(())
    }

    #[test]
    #[serial]
    fn test_host_tools_no_env_var() -> Result<()> {
        env::remove_var("HOST_OUT_DIR");
        env::remove_var("PREBUILT_AEMU_DIR");
        env::remove_var("PREBUILT_VDL_DIR");
        env::remove_var("PREBUILT_GRPCWEBPROXY_DIR");

        let mut mock = MockFuchsiaPaths::new();
        let tmp_dir = Builder::new().tempdir()?;
        let a = tmp_dir.into_path();

        create_dir_all(a.join("prebuilt/third_party/android/aemu/release"))?;
        File::create(a.join("prebuilt/third_party/android/aemu/release/emulator"))?
            .write_all("foo bar".as_bytes())?;

        create_dir_all(a.join("prebuilt/third_party/grpcwebproxy"))?;
        File::create(a.join("prebuilt/third_party/grpcwebproxy/grpcwebproxy"))?
            .write_all("apple banana".as_bytes())?;

        create_dir_all(a.join("prebuilt/vdl"))?;
        File::create(a.join("prebuilt/vdl/device_launcher"))?.write_all("deadbeef".as_bytes())?;

        mock.expect_find_fuchsia_root().returning(move || Ok(a.clone()));
        mock.expect_get_tool_path().returning(|x: &str| {
            let mut p = PathBuf::from("/host/out");
            p.push(x);
            Ok(p)
        });

        let host_tools = HostTools::from_tree_env(&mut mock)?;
        assert!(!host_tools.aemu.as_os_str().is_empty());
        assert!(!host_tools.vdl.as_os_str().is_empty());
        assert!(!host_tools.grpcwebproxy.as_os_str().is_empty());
        assert_eq!(host_tools.far.as_ref().unwrap().to_str().unwrap(), "/host/out/far");
        assert_eq!(host_tools.ffx.as_ref().unwrap().to_str().unwrap(), "/host/out/ffx");
        assert_eq!(host_tools.fvm.as_ref().unwrap().to_str().unwrap(), "/host/out/fvm");
        assert_eq!(host_tools.pm.as_ref().unwrap().to_str().unwrap(), "/host/out/pm");
        assert_eq!(host_tools.zbi.to_str().unwrap(), "/host/out/zbi");
        Ok(())
    }

    #[test]
    #[serial]
    fn test_download_and_extract() -> Result<()> {
        let tmp_dir = Builder::new().prefix("fvdl_test_download_").tempdir()?;
        env::set_var("FEMU_DOWNLOAD_DIR", tmp_dir.path());
        let host_tools = HostTools::from_sdk_env()?;
        let mut unzipped_root =
            host_tools.download_and_extract("latest".to_string(), "vdl".to_string())?;

        let mut has_extract = false;
        for path in read_dir(&unzipped_root)? {
            let entry = path?;
            let p = entry.path();
            println!("Found path {}", p.display());
            if p.ends_with("device_launcher") {
                has_extract = true;
            }
        }
        assert!(has_extract);

        // Download "latest" again should trigger a cleanup and re-download
        unzipped_root = host_tools.download_and_extract("latest".to_string(), "vdl".to_string())?;
        has_extract = false;
        for path in read_dir(&unzipped_root)? {
            let entry = path?;
            let p = entry.path();
            println!("Found path {}", p.display());
            if p.ends_with("device_launcher") {
                has_extract = true;
            }
        }
        assert!(has_extract);
        Ok(())
    }
}