// Copyright 2022 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::board_filesystem_config as bfc;
use crate::product_filesystem_config as pfc;
use anyhow::{anyhow, bail, Context, Result};
use bfc::{PostProcessingScript, VBMetaDescriptor, ZbiCompression};
use camino::Utf8PathBuf;
use pfc::BlobfsLayout;
use serde::{Deserialize, Serialize};

use std::fmt;
use std::io::Read;
use std::str::FromStr;

/// The configuration file specifying which images to generate and how.
#[derive(Serialize, Deserialize, Debug, Default, PartialEq)]
pub struct ImagesConfig {
    /// A list of images to generate.
    #[serde(default)]
    pub images: Vec<Image>,
}

/// An image to generate.
#[derive(Serialize, Deserialize, Debug, PartialEq)]
#[serde(tag = "type")]
pub enum Image {
    /// A FVM image.
    #[serde(rename = "fvm")]
    Fvm(Fvm),

    /// A ZBI image.
    #[serde(rename = "zbi")]
    Zbi(Zbi),

    /// A VBMeta image.
    #[serde(rename = "vbmeta")]
    VBMeta(VBMeta),

    /// An Fxfs image.
    #[serde(rename = "fxfs")]
    Fxfs(Fxfs),
}

/// Parameters describing how to generate the ZBI.
#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct Zbi {
    /// The name to give the image file.
    #[serde(default = "default_zbi_name")]
    pub name: String,

    /// The compression format for the ZBI.
    #[serde(default)]
    pub compression: ZbiCompression,

    /// An optional script to post-process the ZBI.
    /// This is often used to prepare the ZBI for flashing/updating.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub postprocessing_script: Option<PostProcessingScript>,
}

fn default_zbi_name() -> String {
    "fuchsia".into()
}

impl FromStr for ZbiCompression {
    type Err = anyhow::Error;
    fn from_str(s: &str) -> Result<Self> {
        zbi_compression_from_str(s)
    }
}

impl TryFrom<&str> for ZbiCompression {
    type Error = anyhow::Error;
    fn try_from(s: &str) -> Result<Self> {
        zbi_compression_from_str(s)
    }
}

impl fmt::Display for ZbiCompression {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}",
            match self {
                ZbiCompression::ZStd => "zstd",
                ZbiCompression::ZStdMax => "zstd.max",
            }
        )
    }
}

fn zbi_compression_from_str(s: &str) -> Result<ZbiCompression> {
    match s {
        "zstd" => Ok(ZbiCompression::ZStd),
        "zstd.max" => Ok(ZbiCompression::ZStdMax),
        invalid => Err(anyhow!("invalid zbi compression: {}", invalid)),
    }
}

/// The parameters describing how to create a VBMeta image.
#[derive(Serialize, Deserialize, Debug, PartialEq)]
pub struct VBMeta {
    /// The name to give the image file.
    #[serde(default = "default_vbmeta_name")]
    pub name: String,

    /// Path on host to the key for signing VBMeta.
    pub key: Utf8PathBuf,

    /// Path on host to the key metadata to add to the VBMeta.
    pub key_metadata: Utf8PathBuf,

    /// Optional descriptors to add to the VBMeta image.
    #[serde(default)]
    pub additional_descriptors: Vec<VBMetaDescriptor>,
}

fn default_vbmeta_name() -> String {
    "fuchsia".into()
}

/// The parameters describing how to create a FVM image.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct Fvm {
    /// The size of a slice within the FVM.
    #[serde(default = "default_fvm_slice_size")]
    pub slice_size: u64,

    /// The list of filesystems to generate that can be added to the outputs.
    pub filesystems: Vec<FvmFilesystem>,

    /// The FVM images to generate.
    pub outputs: Vec<FvmOutput>,
}

fn default_fvm_slice_size() -> u64 {
    8388608
}

/// A single FVM filesystem that can be added to multiple outputs.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(tag = "type")]
pub enum FvmFilesystem {
    /// A blobfs volume for holding blobs.
    #[serde(rename = "blobfs")]
    BlobFS(BlobFS),

    /// An empty data partition.
    /// This reserves the data volume, which will be formatted as fxfs/minfs on boot.
    // TODO(https://fxbug.dev/42166000): Remove empty-minfs alias after updating sdk-integration.
    #[serde(rename = "empty-data", alias = "empty-minfs")]
    EmptyData(EmptyData),

    /// Reserved slices in the FVM.
    #[serde(rename = "reserved")]
    Reserved(Reserved),
}

/// Configuration for building a BlobFS volume.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct BlobFS {
    /// The name of the volume in the FVM.
    #[serde(default = "default_blobfs_name")]
    pub name: String,

    /// Optional deprecated layout.
    #[serde(default)]
    pub layout: BlobfsLayout,

    /// Reserve |minimum_data_bytes| and |minimum_inodes| in the FVM, and ensure
    /// that the final reserved size does not exceed |maximum_bytes|.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maximum_bytes: Option<u64>,

    /// Reserve space for at least this many data bytes.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minimum_data_bytes: Option<u64>,

    /// Reserved space for this many inodes.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minimum_inodes: Option<u64>,

    /// Maximum amount of contents for an assembled blobfs.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maximum_contents_size: Option<u64>,
}

fn default_blobfs_name() -> String {
    "blob".into()
}

fn default_data_name() -> String {
    "data".into()
}

/// Configuration for building an EmptyData volume.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct EmptyData {
    /// The name of the volume in the FVM.
    #[serde(default = "default_data_name")]
    pub name: String,
}

/// Configuration for building a Reserved volume.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct Reserved {
    /// The name of the volume in the FVM.
    #[serde(default = "default_reserved_name")]
    pub name: String,

    /// The number of slices to reserve.
    pub slices: u64,
}

fn default_reserved_name() -> String {
    "internal".into()
}

impl FromStr for BlobfsLayout {
    type Err = anyhow::Error;
    fn from_str(s: &str) -> Result<Self> {
        blobfs_layout_from_str(s)
    }
}

impl TryFrom<&str> for BlobfsLayout {
    type Error = anyhow::Error;
    fn try_from(s: &str) -> Result<Self> {
        blobfs_layout_from_str(s)
    }
}

impl fmt::Display for BlobfsLayout {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(
            f,
            "{}",
            match self {
                BlobfsLayout::Compact => "compact",
                BlobfsLayout::DeprecatedPadded => "deprecated_padded",
            }
        )
    }
}

fn blobfs_layout_from_str(s: &str) -> Result<BlobfsLayout> {
    match s {
        "compact" => Ok(BlobfsLayout::Compact),
        "deprecated_padded" => Ok(BlobfsLayout::DeprecatedPadded),
        _ => Err(anyhow!("invalid blobfs layout")),
    }
}

/// A FVM image to generate with a list of filesystems.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
#[serde(tag = "type")]
pub enum FvmOutput {
    /// The default FVM type with no modifications.
    #[serde(rename = "standard")]
    Standard(StandardFvm),

    /// A FVM that is compressed sparse.
    #[serde(rename = "sparse")]
    Sparse(SparseFvm),

    /// A FVM prepared for a Nand partition.
    #[serde(rename = "nand")]
    Nand(NandFvm),
}

impl std::fmt::Display for FvmOutput {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let (fvm_type, name) = match self {
            FvmOutput::Standard(fvm) => ("Standard", &fvm.name),
            FvmOutput::Sparse(fvm) => ("Sparse", &fvm.name),
            FvmOutput::Nand(fvm) => ("Nand", &fvm.name),
        };
        f.write_fmt(format_args!("Fvm::{}(\"{}\")", fvm_type, name))
    }
}

/// The default FVM type with no modifications.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct StandardFvm {
    /// The name to give the file.
    pub name: String,

    /// The filesystems to include in the FVM.
    pub filesystems: Vec<String>,

    /// Whether to compress the FVM.
    #[serde(default)]
    pub compress: bool,

    /// Shrink the FVM to fit exactly the contents.
    #[serde(default)]
    pub resize_image_file_to_fit: bool,

    /// After the optional resize, truncate the file to this length.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub truncate_to_length: Option<u64>,
}

/// A FVM that is compressed sparse.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct SparseFvm {
    /// The name to give the file.
    pub name: String,

    /// The filesystems to include in the FVM.
    pub filesystems: Vec<String>,

    /// The maximum size the FVM can expand to at runtime.
    /// This sets the amount of slice metadata to allocate during construction,
    /// which cannot be modified at runtime.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_disk_size: Option<u64>,
}

/// A FVM prepared for a Nand partition.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct NandFvm {
    /// The name to give the file.
    pub name: String,

    /// The filesystems to include in the FVM.
    #[serde(default)]
    pub filesystems: Vec<String>,

    /// The maximum size the FVM can expand to at runtime.
    /// This sets the amount of slice metadata to allocate during construction,
    /// which cannot be modified at runtime.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_disk_size: Option<u64>,

    /// Whether to compress the FVM.
    #[serde(default)]
    pub compress: bool,

    /// The number of blocks.
    pub block_count: u64,

    /// The out of bound size.
    pub oob_size: u64,

    /// Page size as perceived by the FTL.
    pub page_size: u64,

    /// Number of pages per erase block unit.
    pub pages_per_block: u64,
}

/// The parameters describing how to create an Fxfs image.
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
pub struct Fxfs {
    /// The size of Fxfs image to generate.  The base system's contents must not exceed this size.
    /// If unset, there's no limit, and the image will be an arbitrary size greater than or equal to
    /// the space needed for the base system's contents.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size_bytes: Option<u64>,

    /// Maximum amount of contents for an assembled Fxfs image.  Must be no greater than
    /// `size_bytes`.
    #[serde(default)]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maximum_contents_size: Option<u64>,
}

impl ImagesConfig {
    /// Parse the config from a reader.
    pub fn from_reader<R>(reader: &mut R) -> Result<Self>
    where
        R: Read,
    {
        let mut data = String::default();
        reader.read_to_string(&mut data).context("Cannot read the config")?;
        serde_json5::from_str(&data).context("Cannot parse the config")
    }

    /// Merge a product and board to construct an ImagesConfig.
    pub fn from_product_and_board(
        product: &pfc::ProductFilesystemConfig,
        board: &bfc::BoardFilesystemConfig,
    ) -> Result<Self> {
        let mut images = vec![];

        // Add the zbi and optional vbmeta specified in the board.
        images.push(Image::Zbi(Zbi {
            name: product.image_name.0.clone(),
            compression: board.zbi.compression.clone(),
            postprocessing_script: board.zbi.postprocessing_script.clone(),
        }));
        if let Some(vbmeta) = &board.vbmeta {
            let bfc::VBMeta { key, key_metadata, additional_descriptors } = vbmeta.clone();
            images.push(Image::VBMeta(VBMeta {
                name: product.image_name.0.clone(),
                key: key.into(),
                key_metadata: key_metadata.into(),
                additional_descriptors,
            }));
        }

        // Add the filesystems specified in the product.
        if product.image_mode != pfc::FilesystemImageMode::NoImage {
            match &product.volume {
                pfc::VolumeConfig::Fxfs => {
                    let size_bytes = board.fxfs.size_bytes;
                    images.push(Image::Fxfs(Fxfs {
                        size_bytes,
                        maximum_contents_size: board.fxfs.size_checker_maximum_bytes,
                    }));
                }
                pfc::VolumeConfig::Fvm(fvm) => {
                    let slice_size = board.fvm.slice_size.0;

                    // Construct the list of FVM filesystems.
                    let mut filesystems = vec![];
                    let mut filesystem_names = vec![];
                    if let Some(_) = fvm.data {
                        filesystems.push(FvmFilesystem::EmptyData(EmptyData {
                            name: "empty-data".into(),
                        }));
                        filesystem_names.push("empty-data".to_string());
                    }
                    if let Some(pfc::BlobFvmVolumeConfig { blob_layout }) = &fvm.blob {
                        filesystems.push(FvmFilesystem::BlobFS(BlobFS {
                            name: "blob".into(),
                            layout: blob_layout.clone(),
                            maximum_bytes: board.fvm.blobfs.build_time_maximum_bytes,
                            minimum_data_bytes: board.fvm.blobfs.minimum_data_bytes,
                            minimum_inodes: board.fvm.blobfs.minimum_inodes,
                            maximum_contents_size: board.fvm.blobfs.size_checker_maximum_bytes,
                        }));
                        filesystem_names.push("blob".to_string());
                    }
                    if let Some(pfc::ReservedFvmVolumeConfig { reserved_slices }) = fvm.reserved {
                        filesystems.push(FvmFilesystem::Reserved(Reserved {
                            name: "internal".into(),
                            slices: reserved_slices,
                        }));
                        filesystem_names.push("internal".to_string());
                    }
                    // Construct the list of FVM outputs.
                    let mut outputs = vec![];
                    outputs.push(FvmOutput::Standard(StandardFvm {
                        name: "fvm".into(),
                        filesystems: filesystem_names.clone(),
                        compress: false,
                        resize_image_file_to_fit: false,
                        truncate_to_length: board.fvm.truncate_to_length.clone(),
                    }));
                    if let Some(sparse) = &board.fvm.sparse_output {
                        outputs.push(FvmOutput::Sparse(SparseFvm {
                            name: "fvm.sparse".into(),
                            filesystems: filesystem_names.clone(),
                            max_disk_size: sparse.max_disk_size.clone(),
                        }));
                    }
                    if board.fvm.fastboot_output.is_some() && board.fvm.nand_output.is_some() {
                        bail!("A board may only build either a fastboot or nand FVM but not both");
                    }
                    if let Some(fastboot) = &board.fvm.fastboot_output {
                        outputs.push(FvmOutput::Standard(StandardFvm {
                            name: "fvm.fastboot".into(),
                            filesystems: filesystem_names.clone(),
                            compress: fastboot.compress,
                            resize_image_file_to_fit: true,
                            truncate_to_length: fastboot.truncate_to_length.clone(),
                        }));
                    } else if let Some(nand) = &board.fvm.nand_output {
                        let bfc::NandFvmConfig {
                            max_disk_size,
                            compress,
                            block_count,
                            oob_size,
                            page_size,
                            pages_per_block,
                        } = nand.clone();
                        outputs.push(FvmOutput::Nand(NandFvm {
                            name: "fvm.fastboot".into(),
                            filesystems: filesystem_names.clone(),
                            max_disk_size,
                            compress,
                            block_count,
                            oob_size,
                            page_size,
                            pages_per_block,
                        }));
                    }

                    // Add the FVM images.
                    images.push(Image::Fvm(Fvm { slice_size, filesystems, outputs }));
                }
            }
        }

        Ok(Self { images })
    }
}

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

    fn test_board_config_fastboot() -> bfc::BoardFilesystemConfig {
        bfc::BoardFilesystemConfig {
            zbi: bfc::Zbi {
                compression: bfc::ZbiCompression::ZStd,
                postprocessing_script: Some(bfc::PostProcessingScript {
                    path: "path/to/script".into(),
                    args: vec!["arg1".into(), "arg2".into()],
                }),
            },
            vbmeta: Some(bfc::VBMeta {
                key: "path/to/key".into(),
                key_metadata: "path/to/metadata".into(),
                additional_descriptors: vec![],
            }),
            fxfs: bfc::Fxfs { size_bytes: Some(1234), size_checker_maximum_bytes: Some(5678) },
            fvm: bfc::Fvm {
                slice_size: bfc::FvmSliceSize(5678),
                truncate_to_length: None,
                blobfs: bfc::Blobfs {
                    size_checker_maximum_bytes: Some(12),
                    build_time_maximum_bytes: Some(34),
                    maximum_bytes: None,
                    minimum_inodes: Some(56),
                    minimum_data_bytes: Some(78),
                },
                minfs: bfc::Minfs { maximum_bytes: Some(90) },
                sparse_output: Some(bfc::SparseFvmConfig { max_disk_size: Some(2345) }),
                nand_output: None,
                fastboot_output: Some(bfc::FastbootFvmConfig {
                    compress: true,
                    truncate_to_length: Some(3456),
                }),
            },
            gpt_all: false,
        }
    }

    fn test_board_config_nand() -> bfc::BoardFilesystemConfig {
        bfc::BoardFilesystemConfig {
            zbi: bfc::Zbi {
                compression: bfc::ZbiCompression::ZStd,
                postprocessing_script: Some(bfc::PostProcessingScript {
                    path: "path/to/script".into(),
                    args: vec!["arg1".into(), "arg2".into()],
                }),
            },
            vbmeta: Some(bfc::VBMeta {
                key: "path/to/key".into(),
                key_metadata: "path/to/metadata".into(),
                additional_descriptors: vec![],
            }),
            fxfs: bfc::Fxfs { size_bytes: Some(1234), size_checker_maximum_bytes: Some(5678) },
            fvm: bfc::Fvm {
                slice_size: bfc::FvmSliceSize(5678),
                truncate_to_length: None,
                blobfs: bfc::Blobfs {
                    size_checker_maximum_bytes: Some(12),
                    build_time_maximum_bytes: Some(34),
                    maximum_bytes: None,
                    minimum_inodes: Some(56),
                    minimum_data_bytes: Some(78),
                },
                minfs: bfc::Minfs { maximum_bytes: Some(90) },
                sparse_output: Some(bfc::SparseFvmConfig { max_disk_size: Some(2345) }),
                nand_output: Some(bfc::NandFvmConfig {
                    max_disk_size: Some(3456),
                    compress: true,
                    block_count: 1,
                    oob_size: 2,
                    page_size: 3,
                    pages_per_block: 4,
                }),
                fastboot_output: None,
            },
            gpt_all: false,
        }
    }

    #[test]
    fn from_product_and_board_no_images() {
        let board = test_board_config_fastboot();
        let product = pfc::ProductFilesystemConfig {
            image_name: pfc::ImageName("a-product".into()),
            watch_for_nand: false,
            format_data_on_corruption: pfc::FormatDataOnCorruption(true),
            no_zxcrypt: false,
            image_mode: pfc::FilesystemImageMode::NoImage,
            volume: pfc::VolumeConfig::Fxfs,
        };

        let images = ImagesConfig::from_product_and_board(&product, &board).unwrap();
        assert_eq!(
            images,
            ImagesConfig {
                images: vec![
                    Image::Zbi(Zbi {
                        name: "a-product".into(),
                        compression: bfc::ZbiCompression::ZStd,
                        postprocessing_script: Some(bfc::PostProcessingScript {
                            path: "path/to/script".into(),
                            args: vec!["arg1".into(), "arg2".into()],
                        }),
                    }),
                    Image::VBMeta(VBMeta {
                        name: "a-product".into(),
                        key: "path/to/key".into(),
                        key_metadata: "path/to/metadata".into(),
                        additional_descriptors: vec![],
                    }),
                ],
            }
        );
    }

    #[test]
    fn from_product_and_board_fxfs() {
        let board = test_board_config_fastboot();
        let product = pfc::ProductFilesystemConfig {
            image_name: pfc::ImageName("a-product".into()),
            watch_for_nand: false,
            format_data_on_corruption: pfc::FormatDataOnCorruption(true),
            no_zxcrypt: false,
            image_mode: pfc::FilesystemImageMode::Partition,
            volume: pfc::VolumeConfig::Fxfs,
        };

        let images = ImagesConfig::from_product_and_board(&product, &board).unwrap();
        assert_eq!(
            images,
            ImagesConfig {
                images: vec![
                    Image::Zbi(Zbi {
                        name: "a-product".into(),
                        compression: bfc::ZbiCompression::ZStd,
                        postprocessing_script: Some(bfc::PostProcessingScript {
                            path: "path/to/script".into(),
                            args: vec!["arg1".into(), "arg2".into()],
                        }),
                    }),
                    Image::VBMeta(VBMeta {
                        name: "a-product".into(),
                        key: "path/to/key".into(),
                        key_metadata: "path/to/metadata".into(),
                        additional_descriptors: vec![],
                    }),
                    Image::Fxfs(Fxfs { size_bytes: Some(1234), maximum_contents_size: Some(5678) }),
                ],
            }
        );
    }

    #[test]
    fn from_product_and_board_fvm_fastboot() {
        let board = test_board_config_fastboot();
        let product = pfc::ProductFilesystemConfig {
            image_name: pfc::ImageName("a-product".into()),
            watch_for_nand: false,
            format_data_on_corruption: pfc::FormatDataOnCorruption(true),
            no_zxcrypt: false,
            image_mode: pfc::FilesystemImageMode::Partition,
            volume: pfc::VolumeConfig::Fvm(pfc::FvmVolumeConfig {
                data: Some(pfc::DataFvmVolumeConfig {
                    use_disk_based_minfs_migration: true,
                    data_filesystem_format: pfc::DataFilesystemFormat::Minfs,
                }),
                blob: Some(pfc::BlobFvmVolumeConfig { blob_layout: BlobfsLayout::Compact }),
                reserved: Some(pfc::ReservedFvmVolumeConfig { reserved_slices: 7 }),
            }),
        };

        let images = ImagesConfig::from_product_and_board(&product, &board).unwrap();
        assert_eq!(
            images,
            ImagesConfig {
                images: vec![
                    Image::Zbi(Zbi {
                        name: "a-product".into(),
                        compression: bfc::ZbiCompression::ZStd,
                        postprocessing_script: Some(bfc::PostProcessingScript {
                            path: "path/to/script".into(),
                            args: vec!["arg1".into(), "arg2".into()],
                        }),
                    }),
                    Image::VBMeta(VBMeta {
                        name: "a-product".into(),
                        key: "path/to/key".into(),
                        key_metadata: "path/to/metadata".into(),
                        additional_descriptors: vec![],
                    }),
                    Image::Fvm(Fvm {
                        slice_size: 5678,
                        filesystems: vec![
                            FvmFilesystem::EmptyData(EmptyData { name: "empty-data".into() }),
                            FvmFilesystem::BlobFS(BlobFS {
                                name: "blob".into(),
                                layout: BlobfsLayout::Compact,
                                maximum_bytes: Some(34),
                                minimum_inodes: Some(56),
                                minimum_data_bytes: Some(78),
                                maximum_contents_size: Some(12),
                            }),
                            FvmFilesystem::Reserved(Reserved {
                                name: "internal".into(),
                                slices: 7,
                            }),
                        ],
                        outputs: vec![
                            FvmOutput::Standard(StandardFvm {
                                name: "fvm".into(),
                                filesystems: vec![
                                    "empty-data".to_string(),
                                    "blob".to_string(),
                                    "internal".to_string(),
                                ],
                                compress: false,
                                resize_image_file_to_fit: false,
                                truncate_to_length: None,
                            }),
                            FvmOutput::Sparse(SparseFvm {
                                name: "fvm.sparse".into(),
                                filesystems: vec![
                                    "empty-data".to_string(),
                                    "blob".to_string(),
                                    "internal".to_string(),
                                ],
                                max_disk_size: Some(2345),
                            }),
                            FvmOutput::Standard(StandardFvm {
                                name: "fvm.fastboot".into(),
                                filesystems: vec![
                                    "empty-data".to_string(),
                                    "blob".to_string(),
                                    "internal".to_string(),
                                ],
                                compress: true,
                                resize_image_file_to_fit: true,
                                truncate_to_length: Some(3456),
                            }),
                        ],
                    }),
                ],
            }
        );
    }

    #[test]
    fn from_product_and_board_fvm_nand() {
        let board = test_board_config_nand();
        let product = pfc::ProductFilesystemConfig {
            image_name: pfc::ImageName("a-product".into()),
            watch_for_nand: false,
            format_data_on_corruption: pfc::FormatDataOnCorruption(true),
            no_zxcrypt: false,
            image_mode: pfc::FilesystemImageMode::Partition,
            volume: pfc::VolumeConfig::Fvm(pfc::FvmVolumeConfig {
                data: Some(pfc::DataFvmVolumeConfig {
                    use_disk_based_minfs_migration: true,
                    data_filesystem_format: pfc::DataFilesystemFormat::Minfs,
                }),
                blob: Some(pfc::BlobFvmVolumeConfig { blob_layout: BlobfsLayout::Compact }),
                reserved: Some(pfc::ReservedFvmVolumeConfig { reserved_slices: 7 }),
            }),
        };

        let images = ImagesConfig::from_product_and_board(&product, &board).unwrap();
        assert_eq!(
            images,
            ImagesConfig {
                images: vec![
                    Image::Zbi(Zbi {
                        name: "a-product".into(),
                        compression: bfc::ZbiCompression::ZStd,
                        postprocessing_script: Some(bfc::PostProcessingScript {
                            path: "path/to/script".into(),
                            args: vec!["arg1".into(), "arg2".into()],
                        }),
                    }),
                    Image::VBMeta(VBMeta {
                        name: "a-product".into(),
                        key: "path/to/key".into(),
                        key_metadata: "path/to/metadata".into(),
                        additional_descriptors: vec![],
                    }),
                    Image::Fvm(Fvm {
                        slice_size: 5678,
                        filesystems: vec![
                            FvmFilesystem::EmptyData(EmptyData { name: "empty-data".into() }),
                            FvmFilesystem::BlobFS(BlobFS {
                                name: "blob".into(),
                                layout: BlobfsLayout::Compact,
                                maximum_bytes: Some(34),
                                minimum_inodes: Some(56),
                                minimum_data_bytes: Some(78),
                                maximum_contents_size: Some(12),
                            }),
                            FvmFilesystem::Reserved(Reserved {
                                name: "internal".into(),
                                slices: 7,
                            }),
                        ],
                        outputs: vec![
                            FvmOutput::Standard(StandardFvm {
                                name: "fvm".into(),
                                filesystems: vec![
                                    "empty-data".to_string(),
                                    "blob".to_string(),
                                    "internal".to_string(),
                                ],
                                compress: false,
                                resize_image_file_to_fit: false,
                                truncate_to_length: None,
                            }),
                            FvmOutput::Sparse(SparseFvm {
                                name: "fvm.sparse".into(),
                                filesystems: vec![
                                    "empty-data".to_string(),
                                    "blob".to_string(),
                                    "internal".to_string(),
                                ],
                                max_disk_size: Some(2345),
                            }),
                            FvmOutput::Nand(NandFvm {
                                name: "fvm.fastboot".into(),
                                filesystems: vec![
                                    "empty-data".to_string(),
                                    "blob".to_string(),
                                    "internal".to_string(),
                                ],
                                max_disk_size: Some(3456),
                                compress: true,
                                block_count: 1,
                                oob_size: 2,
                                page_size: 3,
                                pages_per_block: 4,
                            }),
                        ],
                    }),
                ],
            }
        );
    }

    #[test]
    fn zbi_compression_try_from() {
        assert_eq!(ZbiCompression::ZStd, "zstd".try_into().unwrap());
        assert_eq!(ZbiCompression::ZStdMax, "zstd.max".try_into().unwrap());
        let compression: Result<ZbiCompression> = "else".try_into();
        assert!(compression.is_err());
    }

    #[test]
    fn zbi_compression_from_string() {
        assert_eq!(ZbiCompression::ZStd, ZbiCompression::from_str("zstd").unwrap());
        assert_eq!(ZbiCompression::ZStdMax, ZbiCompression::from_str("zstd.max").unwrap());
        let compression: Result<ZbiCompression> = ZbiCompression::from_str("else");
        assert!(compression.is_err());
    }

    #[test]
    fn zbi_compressoin_to_string() {
        assert_eq!("zstd".to_string(), ZbiCompression::ZStd.to_string());
        assert_eq!("zstd.max".to_string(), ZbiCompression::ZStdMax.to_string());
    }

    #[test]
    fn blobfs_layout_try_from() {
        assert_eq!(BlobfsLayout::Compact, "compact".try_into().unwrap());
        assert_eq!(BlobfsLayout::DeprecatedPadded, "deprecated_padded".try_into().unwrap());
        let layout: Result<BlobfsLayout> = "else".try_into();
        assert!(layout.is_err());
    }

    #[test]
    fn blobfs_layout_from_string() {
        assert_eq!(BlobfsLayout::Compact, BlobfsLayout::from_str("compact").unwrap());
        assert_eq!(
            BlobfsLayout::DeprecatedPadded,
            BlobfsLayout::from_str("deprecated_padded").unwrap()
        );
        let layout: Result<BlobfsLayout> = BlobfsLayout::from_str("else");
        assert!(layout.is_err());
    }

    #[test]
    fn blobfs_layout_to_string() {
        assert_eq!("compact".to_string(), BlobfsLayout::Compact.to_string());
        assert_eq!("deprecated_padded".to_string(), BlobfsLayout::DeprecatedPadded.to_string());
    }

    #[test]
    fn from_json() {
        let json = r#"
            {
                images: [
                    {
                        type: "zbi",
                        name: "fuchsia",
                        compression: "zstd.max",
                        postprocessing_script: {
                            path: "path/to/tool.sh",
                            args: [ "arg1", "arg2" ]
                        }
                    },
                    {
                        type: "vbmeta",
                        name: "fuchsia",
                        key: "path/to/key",
                        key_metadata: "path/to/key/metadata",
                        additional_descriptors: [
                            {
                                name: "zircon",
                                size: 12345,
                                flags: 1,
                                min_avb_version: "1.1"
                            }
                        ]
                    },
                    {
                        type: "fvm",
                        slice_size: 0,
                        filesystems: [
                            {
                                type: "blobfs",
                                name: "blob",
                                layout: "compact",
                                maximum_bytes: 0,
                                minimum_data_bytes: 0,
                                minimum_inodes: 0,
                            },
                            {
                                type: "reserved",
                                name: "internal",
                                slices: 0,
                            },
                        ],
                        outputs: [
                            {
                                type: "standard",
                                name: "fvm",
                                filesystems: [
                                    "blob",
                                    "data",
                                    "internal",
                                ],
                                resize_image_file_to_fit: true,
                                truncate_to_length: 0,
                            },
                            {
                                type: "sparse",
                                name: "fvm.sparse",
                                filesystems: [
                                    "blob",
                                    "data",
                                    "internal",
                                ],
                                max_disk_size: 0,
                            },
                            {
                                type: "nand",
                                name: "fvm.nand",
                                filesystems: [
                                    "blob",
                                    "data",
                                    "internal",
                                ],
                                compress: true,
                                max_disk_size: 0,
                                block_count: 0,
                                oob_size: 0,
                                page_size: 0,
                                pages_per_block: 0,
                            },
                        ],
                    },
                ],
            }
        "#;
        let mut cursor = std::io::Cursor::new(json);
        let config: ImagesConfig = ImagesConfig::from_reader(&mut cursor).unwrap();
        assert_eq!(config.images.len(), 3);

        let mut found_zbi = false;
        let mut found_vbmeta = false;
        let mut found_standard_fvm = false;
        let mut found_fxfs = false;
        for image in config.images {
            match image {
                Image::Zbi(zbi) => {
                    found_zbi = true;
                    assert_eq!(zbi.name, "fuchsia");
                    assert!(matches!(zbi.compression, ZbiCompression::ZStdMax));
                }
                Image::VBMeta(vbmeta) => {
                    found_vbmeta = true;
                    assert_eq!(vbmeta.name, "fuchsia");
                    assert_eq!(vbmeta.key, PathBuf::from("path/to/key"));
                }
                Image::Fvm(fvm) => {
                    assert_eq!(fvm.outputs.len(), 3);

                    for output in fvm.outputs {
                        match output {
                            FvmOutput::Standard(standard) => {
                                found_standard_fvm = true;
                                assert_eq!(standard.name, "fvm");
                                assert_eq!(standard.filesystems.len(), 3);
                            }
                            _ => {}
                        }
                    }
                }
                Image::Fxfs(_) => {
                    found_fxfs = true;
                }
            }
        }
        assert!(found_zbi);
        assert!(found_vbmeta);
        assert!(found_standard_fvm);
        assert!(!found_fxfs);
    }

    #[test]
    fn using_defaults() {
        let json = r#"
            {
                images: [
                    {
                        type: "zbi",
                    },
                    {
                        type: "vbmeta",
                        key: "path/to/key",
                        key_metadata: "path/to/key/metadata",
                    },
                    {
                        type: "fvm",
                        filesystems: [
                            {
                                type: "blobfs",
                                name: "blob",
                            },
                            {
                                type: "reserved",
                                name: "internal",
                                slices: 0,
                            },
                        ],
                        outputs: [
                            {
                                type: "standard",
                                name: "fvm.blk",
                                filesystems: [
                                    "blob",
                                    "data",
                                    "internal",
                                ],
                            },
                            {
                                type: "sparse",
                                name: "fvm.sparse.blk",
                                filesystems: [
                                    "blob",
                                    "data",
                                    "internal",
                                ],
                            },
                            {
                                type: "nand",
                                name: "fvm.fastboot.blk",
                                filesystems: [
                                    "blob",
                                    "data",
                                    "internal",
                                ],
                                block_count: 0,
                                oob_size: 0,
                                page_size: 0,
                                pages_per_block: 0,
                            },
                        ],
                    },
                ],
            }
        "#;
        let mut cursor = std::io::Cursor::new(json);
        let config: ImagesConfig = ImagesConfig::from_reader(&mut cursor).unwrap();
        assert_eq!(config.images.len(), 3);
    }
}