// Copyright 2019 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::cml::{self, CapabilityClause};
use crate::validate;
use cm_json::{self, cm, Error};
use serde::ser::Serialize;
use serde_json;
use serde_json::ser::{CompactFormatter, PrettyFormatter, Serializer};
use std::collections::HashSet;
use std::fs::{self, File};
use std::io::{Read, Write};
use std::path::PathBuf;
use std::str::from_utf8;

/// Read in a CML file and produce the equivalent CM.
pub fn compile(file: &PathBuf, pretty: bool, output: Option<PathBuf>) -> Result<(), Error> {
    const BAD_IN_EXTENSION: &str = "Input file does not have the component manifest language \
                                    extension (.cml)";
    match file.extension().and_then(|e| e.to_str()) {
        Some("cml") => Ok(()),
        _ => Err(Error::invalid_args(BAD_IN_EXTENSION)),
    }?;
    const BAD_OUT_EXTENSION: &str =
        "Output file does not have the component manifest extension (.cm)";
    if let Some(ref path) = output {
        match path.extension().and_then(|e| e.to_str()) {
            Some("cm") => Ok(()),
            _ => Err(Error::invalid_args(BAD_OUT_EXTENSION)),
        }?;
    }

    let mut buffer = String::new();
    File::open(&file.as_path())?.read_to_string(&mut buffer)?;
    let value = cm_json::from_json5_str(&buffer)?;
    let document = validate::parse_cml(value)?;
    let out = compile_cml(document)?;

    let mut res = Vec::new();
    if pretty {
        let mut ser = Serializer::with_formatter(&mut res, PrettyFormatter::with_indent(b"    "));
        out.serialize(&mut ser)
            .map_err(|e| Error::parse(format!("Couldn't serialize JSON: {}", e)))?;
    } else {
        let mut ser = Serializer::with_formatter(&mut res, CompactFormatter {});
        out.serialize(&mut ser)
            .map_err(|e| Error::parse(format!("Couldn't serialize JSON: {}", e)))?;
    }
    if let Some(output_path) = output {
        fs::OpenOptions::new()
            .create(true)
            .truncate(true)
            .write(true)
            .open(output_path)?
            .write_all(&res)?;
    } else {
        println!("{}", from_utf8(&res)?);
    }
    // Sanity check that output conforms to CM schema.
    serde_json::from_slice::<cm::Document>(&res)
        .map_err(|e| Error::parse(format!("Couldn't read output as JSON: {}", e)))?;
    Ok(())
}

fn compile_cml(document: cml::Document) -> Result<cm::Document, Error> {
    let mut out = cm::Document::default();
    if let Some(program) = document.program.as_ref() {
        out.program = Some(program.clone());
    }
    if let Some(r#use) = document.r#use.as_ref() {
        out.uses = Some(translate_use(r#use)?);
    }
    if let Some(expose) = document.expose.as_ref() {
        out.exposes = Some(translate_expose(expose)?);
    }
    if let Some(offer) = document.offer.as_ref() {
        let all_children = document.all_children_names().into_iter().collect();
        let all_collections = document.all_collection_names().into_iter().collect();
        out.offers = Some(translate_offer(offer, &all_children, &all_collections)?);
    }
    if let Some(children) = document.children.as_ref() {
        out.children = Some(translate_children(children)?);
    }
    if let Some(collections) = document.collections.as_ref() {
        out.collections = Some(translate_collections(collections)?);
    }
    if let Some(storage) = document.storage.as_ref() {
        out.storage = Some(translate_storage(storage)?);
    }
    if let Some(facets) = document.facets.as_ref() {
        out.facets = Some(facets.clone());
    }
    Ok(out)
}

fn translate_use(use_in: &Vec<cml::Use>) -> Result<Vec<cm::Use>, Error> {
    let mut out_uses = vec![];
    for use_ in use_in {
        let target_path = extract_target_path(use_, use_);
        let out = if let Some(p) = use_.service() {
            let source = extract_use_source(use_)?;
            let target_path = target_path.ok_or(Error::internal(format!("no capability")))?;
            Ok(cm::Use::Service(cm::UseService {
                source,
                source_path: cm::Path::new(p.clone())?,
                target_path: cm::Path::new(target_path)?,
            }))
        } else if let Some(p) = use_.legacy_service() {
            let source = extract_use_source(use_)?;
            let target_path = target_path.ok_or(Error::internal(format!("no capability")))?;
            Ok(cm::Use::LegacyService(cm::UseLegacyService {
                source,
                source_path: cm::Path::new(p.clone())?,
                target_path: cm::Path::new(target_path)?,
            }))
        } else if let Some(p) = use_.directory() {
            let source = extract_use_source(use_)?;
            let target_path = target_path.ok_or(Error::internal(format!("no capability")))?;
            Ok(cm::Use::Directory(cm::UseDirectory {
                source,
                source_path: cm::Path::new(p.clone())?,
                target_path: cm::Path::new(target_path)?,
            }))
        } else if let Some(p) = use_.storage() {
            Ok(cm::Use::Storage(cm::UseStorage {
                type_: str_to_storage_type(p.as_str())?,
                target_path: target_path.map(cm::Path::new).transpose()?,
            }))
        } else {
            Err(Error::internal(format!("no capability")))
        }?;
        out_uses.push(out);
    }
    Ok(out_uses)
}

fn translate_expose(expose_in: &Vec<cml::Expose>) -> Result<Vec<cm::Expose>, Error> {
    let mut out_exposes = vec![];
    for expose in expose_in.iter() {
        let source = extract_expose_source(expose)?;
        let target_path =
            extract_target_path(expose, expose).ok_or(Error::internal(format!("no capability")))?;
        let out = if let Some(p) = expose.service() {
            Ok(cm::Expose::Service(cm::ExposeService {
                source,
                source_path: cm::Path::new(p.clone())?,
                target_path: cm::Path::new(target_path)?,
            }))
        } else if let Some(p) = expose.legacy_service() {
            Ok(cm::Expose::LegacyService(cm::ExposeLegacyService {
                source,
                source_path: cm::Path::new(p.clone())?,
                target_path: cm::Path::new(target_path)?,
            }))
        } else if let Some(p) = expose.directory() {
            Ok(cm::Expose::Directory(cm::ExposeDirectory {
                source,
                source_path: cm::Path::new(p.clone())?,
                target_path: cm::Path::new(target_path)?,
            }))
        } else {
            Err(Error::internal(format!("no capability")))
        }?;
        out_exposes.push(out);
    }
    Ok(out_exposes)
}

fn translate_offer(
    offer_in: &Vec<cml::Offer>,
    all_children: &HashSet<&str>,
    all_collections: &HashSet<&str>,
) -> Result<Vec<cm::Offer>, Error> {
    let mut out_offers = vec![];
    for offer in offer_in.iter() {
        if let Some(p) = offer.service() {
            let source = extract_offer_source(offer)?;
            let targets = extract_targets(offer, all_children, all_collections)?;
            for (target, target_path) in targets {
                out_offers.push(cm::Offer::Service(cm::OfferService {
                    source_path: cm::Path::new(p.clone())?,
                    source: source.clone(),
                    target,
                    target_path: cm::Path::new(target_path)?,
                }));
            }
        } else if let Some(p) = offer.legacy_service() {
            let source = extract_offer_source(offer)?;
            let targets = extract_targets(offer, all_children, all_collections)?;
            for (target, target_path) in targets {
                out_offers.push(cm::Offer::LegacyService(cm::OfferLegacyService {
                    source_path: cm::Path::new(p.clone())?,
                    source: source.clone(),
                    target,
                    target_path: cm::Path::new(target_path)?,
                }));
            }
        } else if let Some(p) = offer.directory() {
            let source = extract_offer_source(offer)?;
            let targets = extract_targets(offer, all_children, all_collections)?;
            for (target, target_path) in targets {
                out_offers.push(cm::Offer::Directory(cm::OfferDirectory {
                    source_path: cm::Path::new(p.clone())?,
                    source: source.clone(),
                    target,
                    target_path: cm::Path::new(target_path)?,
                }));
            }
        } else if let Some(p) = offer.storage() {
            let type_ = str_to_storage_type(p.as_str())?;
            let source = extract_offer_storage_source(offer)?;
            let targets = extract_storage_targets(offer, all_children, all_collections)?;
            for target in targets {
                out_offers.push(cm::Offer::Storage(cm::OfferStorage {
                    type_: type_.clone(),
                    source: source.clone(),
                    target,
                }));
            }
        } else {
            return Err(Error::internal(format!("no capability")));
        }
    }
    Ok(out_offers)
}

fn translate_children(children_in: &Vec<cml::Child>) -> Result<Vec<cm::Child>, Error> {
    let mut out_children = vec![];
    for child in children_in.iter() {
        let startup = match child.startup.as_ref().map(|s| s as &str) {
            Some(cml::LAZY) | None => cm::StartupMode::Lazy,
            Some(cml::EAGER) => cm::StartupMode::Eager,
            Some(_) => {
                return Err(Error::internal(format!("invalid startup")));
            }
        };
        out_children.push(cm::Child {
            name: cm::Name::new(child.name.clone())?,
            url: cm::Url::new(child.url.clone())?,
            startup,
        });
    }
    Ok(out_children)
}

fn translate_collections(
    collections_in: &Vec<cml::Collection>,
) -> Result<Vec<cm::Collection>, Error> {
    let mut out_collections = vec![];
    for collection in collections_in.iter() {
        let durability = match &collection.durability as &str {
            cml::PERSISTENT => cm::Durability::Persistent,
            cml::TRANSIENT => cm::Durability::Transient,
            _ => {
                return Err(Error::internal(format!("invalid durability")));
            }
        };
        out_collections
            .push(cm::Collection { name: cm::Name::new(collection.name.clone())?, durability });
    }
    Ok(out_collections)
}

fn translate_storage(storage_in: &Vec<cml::Storage>) -> Result<Vec<cm::Storage>, Error> {
    storage_in
        .iter()
        .map(|storage| {
            Ok(cm::Storage {
                name: cm::Name::new(storage.name.clone())?,
                source_path: cm::Path::new(storage.path.clone())?,
                source: extract_offer_source(storage)?,
            })
        })
        .collect()
}

fn extract_use_source(in_obj: &cml::Use) -> Result<cm::Ref, Error> {
    match in_obj.from.as_ref() {
        Some(from) => match from as &str {
            "realm" => Ok(cm::Ref::Realm(cm::RealmRef {})),
            "framework" => Ok(cm::Ref::Framework(cm::FrameworkRef {})),
            _ => Err(Error::internal(format!("invalid \"from\" for \"use\": {}", from))),
        },
        None => Ok(cm::Ref::Realm(cm::RealmRef {})),
    }
}

fn extract_expose_source<T>(in_obj: &T) -> Result<cm::Ref, Error>
where
    T: cml::FromClause,
{
    let from = in_obj.from().to_string();
    if !cml::FROM_RE.is_match(&from) {
        return Err(Error::internal(format!("invalid \"from\": {}", from)));
    }
    let ret = if from.starts_with("#") {
        let (_, child_name) = from.split_at(1);
        cm::Ref::Child(cm::ChildRef { name: cm::Name::new(child_name.to_string())? })
    } else if from == "framework" {
        cm::Ref::Framework(cm::FrameworkRef {})
    } else if from == "self" {
        cm::Ref::Self_(cm::SelfRef {})
    } else {
        return Err(Error::internal(format!("invalid \"from\" for \"expose\": {}", from)));
    };
    Ok(ret)
}

fn extract_offer_source<T>(in_obj: &T) -> Result<cm::Ref, Error>
where
    T: cml::FromClause,
{
    let from = in_obj.from().to_string();
    if !cml::FROM_RE.is_match(&from) {
        return Err(Error::internal(format!("invalid \"from\": {}", from)));
    }
    let ret = if from.starts_with("#") {
        let (_, child_name) = from.split_at(1);
        cm::Ref::Child(cm::ChildRef { name: cm::Name::new(child_name.to_string())? })
    } else if from == "framework" {
        cm::Ref::Framework(cm::FrameworkRef {})
    } else if from == "realm" {
        cm::Ref::Realm(cm::RealmRef {})
    } else if from == "self" {
        cm::Ref::Self_(cm::SelfRef {})
    } else {
        return Err(Error::internal(format!("invalid \"from\" for \"offer\": {}", from)));
    };
    Ok(ret)
}

fn extract_offer_storage_source<T>(in_obj: &T) -> Result<cm::Ref, Error>
where
    T: cml::FromClause,
{
    let from = in_obj.from().to_string();
    if !cml::FROM_RE.is_match(&from) {
        return Err(Error::internal(format!("invalid \"from\": {}", from)));
    }
    let ret = if from.starts_with("#") {
        let (_, storage_name) = from.split_at(1);
        cm::Ref::Storage(cm::StorageRef { name: cm::Name::new(storage_name.to_string())? })
    } else if from == "realm" {
        cm::Ref::Realm(cm::RealmRef {})
    } else {
        return Err(Error::internal(format!("invalid \"from\" for \"offer\": {}", from)));
    };
    Ok(ret)
}

fn extract_storage_targets(
    in_obj: &cml::Offer,
    all_children: &HashSet<&str>,
    all_collections: &HashSet<&str>,
) -> Result<Vec<cm::Ref>, Error> {
    in_obj
        .to
        .iter()
        .map(|to| {
            let caps = match cml::REFERENCE_RE.captures(&to.dest) {
                Some(c) => Ok(c),
                None => Err(Error::internal(format!("invalid \"dest\": {}", to.dest))),
            }?;
            let name = caps[1].to_string();

            if all_children.contains(&name as &str) {
                Ok(cm::Ref::Child(cm::ChildRef { name: cm::Name::new(name.to_string())? }))
            } else if all_collections.contains(&name as &str) {
                Ok(cm::Ref::Collection(cm::CollectionRef {
                    name: cm::Name::new(name.to_string())?,
                }))
            } else {
                Err(Error::internal(format!("dangling reference: \"{}\"", name)))
            }
        })
        .collect()
}

fn extract_targets(
    in_obj: &cml::Offer,
    all_children: &HashSet<&str>,
    all_collections: &HashSet<&str>,
) -> Result<Vec<(cm::Ref, String)>, Error> {
    let mut out_targets = vec![];
    for to in in_obj.to.iter() {
        let target_path =
            extract_target_path(in_obj, to).ok_or(Error::internal("no capability".to_string()))?;
        let caps = match cml::REFERENCE_RE.captures(&to.dest) {
            Some(c) => Ok(c),
            None => Err(Error::internal(format!("invalid \"dest\": {}", to.dest))),
        }?;
        let name = caps[1].to_string();
        let target = if all_children.contains(&name as &str) {
            cm::Ref::Child(cm::ChildRef { name: cm::Name::new(name.to_string())? })
        } else if all_collections.contains(&name as &str) {
            cm::Ref::Collection(cm::CollectionRef { name: cm::Name::new(name.to_string())? })
        } else {
            return Err(Error::internal(format!("dangling reference: \"{}\"", name)));
        };
        out_targets.push((target, target_path));
    }
    Ok(out_targets)
}

fn extract_target_path<T, U>(in_obj: &T, to_obj: &U) -> Option<String>
where
    T: cml::CapabilityClause,
    U: cml::AsClause,
{
    if let Some(as_) = to_obj.r#as() {
        Some(as_.clone())
    } else {
        if let Some(p) = in_obj.service() {
            Some(p.clone())
        } else if let Some(p) = in_obj.legacy_service() {
            Some(p.clone())
        } else if let Some(p) = in_obj.directory() {
            Some(p.clone())
        } else if let Some(type_) = in_obj.storage() {
            match type_.as_str() {
                "data" => Some("/data".to_string()),
                "cache" => Some("/cache".to_string()),
                _ => None,
            }
        } else {
            None
        }
    }
}

fn str_to_storage_type(s: &str) -> Result<cm::StorageType, Error> {
    match s {
        "data" => Ok(cm::StorageType::Data),
        "cache" => Ok(cm::StorageType::Cache),
        "meta" => Ok(cm::StorageType::Meta),
        t => Err(Error::internal(format!("unknown storage type: {}", t))),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;
    use std::fs::File;
    use std::io;
    use std::io::{Read, Write};
    use tempfile::TempDir;

    macro_rules! test_compile {
        (
            $(
                $(#[$m:meta])*
                $test_name:ident => {
                    input = $input:expr,
                    output = $result:expr,
                },
            )+
        ) => {
            $(
                $(#[$m])*
                #[test]
                fn $test_name() {
                    compile_test($input, $result, true);
                }
            )+
        }
    }

    fn compile_test(input: serde_json::value::Value, expected_output: &str, pretty: bool) {
        let tmp_dir = TempDir::new().unwrap();
        let tmp_in_path = tmp_dir.path().join("test.cml");
        let tmp_out_path = tmp_dir.path().join("test.cm");

        File::create(&tmp_in_path).unwrap().write_all(format!("{}", input).as_bytes()).unwrap();

        compile(&tmp_in_path, pretty, Some(tmp_out_path.clone())).expect("compilation failed");
        let mut buffer = String::new();
        fs::File::open(&tmp_out_path).unwrap().read_to_string(&mut buffer).unwrap();
        assert_eq!(buffer, expected_output);
    }

    // TODO: Consider converting these to a golden test
    test_compile! {
        test_compile_empty => {
            input = json!({}),
            output = "{}",
        },

        test_compile_program => {
            input = json!({
                "program": {
                    "binary": "bin/app"
                }
            }),
            output = r#"{
    "program": {
        "binary": "bin/app"
    }
}"#,
        },

        test_compile_use => {
            input = json!({
                "use": [
                    { "service": "/fonts/CoolFonts", "as": "/svc/fuchsia.fonts.Provider" },
                    { "service": "/svc/fuchsia.sys2.Realm", "from": "framework" },
                    { "legacy_service": "/fonts/LegacyCoolFonts", "as": "/svc/fuchsia.fonts.LegacyProvider" },
                    { "legacy_service": "/svc/fuchsia.sys2.LegacyRealm", "from": "framework" },
                    { "directory": "/data/assets" },
                    { "directory": "/data/config", "from": "realm" },
                    { "storage": "meta" },
                    { "storage": "cache", "as": "/tmp" },
                ],
            }),
            output = r#"{
    "uses": [
        {
            "service": {
                "source": {
                    "realm": {}
                },
                "source_path": "/fonts/CoolFonts",
                "target_path": "/svc/fuchsia.fonts.Provider"
            }
        },
        {
            "service": {
                "source": {
                    "framework": {}
                },
                "source_path": "/svc/fuchsia.sys2.Realm",
                "target_path": "/svc/fuchsia.sys2.Realm"
            }
        },
        {
            "legacy_service": {
                "source": {
                    "realm": {}
                },
                "source_path": "/fonts/LegacyCoolFonts",
                "target_path": "/svc/fuchsia.fonts.LegacyProvider"
            }
        },
        {
            "legacy_service": {
                "source": {
                    "framework": {}
                },
                "source_path": "/svc/fuchsia.sys2.LegacyRealm",
                "target_path": "/svc/fuchsia.sys2.LegacyRealm"
            }
        },
        {
            "directory": {
                "source": {
                    "realm": {}
                },
                "source_path": "/data/assets",
                "target_path": "/data/assets"
            }
        },
        {
            "directory": {
                "source": {
                    "realm": {}
                },
                "source_path": "/data/config",
                "target_path": "/data/config"
            }
        },
        {
            "storage": {
                "type": "meta"
            }
        },
        {
            "storage": {
                "type": "cache",
                "target_path": "/tmp"
            }
        }
    ]
}"#,
        },

        test_compile_expose => {
            input = json!({
                "expose": [
                    {
                      "service": "/loggers/fuchsia.logger.Log",
                      "from": "#logger",
                      "as": "/svc/fuchsia.logger.Log"
                    },
                    {
                      "legacy_service": "/loggers/fuchsia.logger.LegacyLog",
                      "from": "#logger",
                      "as": "/svc/fuchsia.logger.LegacyLog"
                    },
                    { "directory": "/volumes/blobfs", "from": "self" },
                    { "directory": "/hub", "from": "framework" }
                ],
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm"
                    },
                ]
            }),
            output = r#"{
    "exposes": [
        {
            "service": {
                "source": {
                    "child": {
                        "name": "logger"
                    }
                },
                "source_path": "/loggers/fuchsia.logger.Log",
                "target_path": "/svc/fuchsia.logger.Log"
            }
        },
        {
            "legacy_service": {
                "source": {
                    "child": {
                        "name": "logger"
                    }
                },
                "source_path": "/loggers/fuchsia.logger.LegacyLog",
                "target_path": "/svc/fuchsia.logger.LegacyLog"
            }
        },
        {
            "directory": {
                "source": {
                    "self": {}
                },
                "source_path": "/volumes/blobfs",
                "target_path": "/volumes/blobfs"
            }
        },
        {
            "directory": {
                "source": {
                    "framework": {}
                },
                "source_path": "/hub",
                "target_path": "/hub"
            }
        }
    ],
    "children": [
        {
            "name": "logger",
            "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
            "startup": "lazy"
        }
    ]
}"#,
        },

        test_compile_offer => {
            input = json!({
                "offer": [
                    {
                        "service": "/svc/fuchsia.logger.Log",
                        "from": "#logger",
                        "to": [
                            { "dest": "#netstack" },
                            { "dest": "#modular", "as": "/svc/fuchsia.logger.SysLog" },
                        ]
                    },
                    {
                        "legacy_service": "/svc/fuchsia.logger.LegacyLog",
                        "from": "#logger",
                        "to": [
                            { "dest": "#netstack" },
                            { "dest": "#modular", "as": "/svc/fuchsia.logger.LegacySysLog" },
                        ]
                    },
                    {
                        "directory": "/data/assets",
                        "from": "realm",
                        "to": [
                            { "dest": "#netstack" },
                            { "dest": "#modular", "as": "/data" }
                        ]
                    },
                    {
                        "directory": "/hub",
                        "from": "framework",
                        "to": [
                            { "dest": "#modular", "as": "/hub" }
                        ]
                    },
                    {
                        "storage": "data",
                        "from": "#logger-storage",
                        "to": [
                            { "dest": "#netstack" },
                            { "dest": "#modular" }
                        ]
                    },
                ],
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm"
                    },
                    {
                        "name": "netstack",
                        "url": "fuchsia-pkg://fuchsia.com/netstack/stable#meta/netstack.cm"
                    },
                ],
                "collections": [
                    {
                        "name": "modular",
                        "durability": "persistent",
                    },
                ],
                "storage": [
                    {
                        "name": "logger-storage",
                        "path": "/minfs",
                        "from": "#logger",
                    },
                ],
            }),
            output = r#"{
    "offers": [
        {
            "service": {
                "source": {
                    "child": {
                        "name": "logger"
                    }
                },
                "source_path": "/svc/fuchsia.logger.Log",
                "target": {
                    "child": {
                        "name": "netstack"
                    }
                },
                "target_path": "/svc/fuchsia.logger.Log"
            }
        },
        {
            "service": {
                "source": {
                    "child": {
                        "name": "logger"
                    }
                },
                "source_path": "/svc/fuchsia.logger.Log",
                "target": {
                    "collection": {
                        "name": "modular"
                    }
                },
                "target_path": "/svc/fuchsia.logger.SysLog"
            }
        },
        {
            "legacy_service": {
                "source": {
                    "child": {
                        "name": "logger"
                    }
                },
                "source_path": "/svc/fuchsia.logger.LegacyLog",
                "target": {
                    "child": {
                        "name": "netstack"
                    }
                },
                "target_path": "/svc/fuchsia.logger.LegacyLog"
            }
        },
        {
            "legacy_service": {
                "source": {
                    "child": {
                        "name": "logger"
                    }
                },
                "source_path": "/svc/fuchsia.logger.LegacyLog",
                "target": {
                    "collection": {
                        "name": "modular"
                    }
                },
                "target_path": "/svc/fuchsia.logger.LegacySysLog"
            }
        },
        {
            "directory": {
                "source": {
                    "realm": {}
                },
                "source_path": "/data/assets",
                "target": {
                    "child": {
                        "name": "netstack"
                    }
                },
                "target_path": "/data/assets"
            }
        },
        {
            "directory": {
                "source": {
                    "realm": {}
                },
                "source_path": "/data/assets",
                "target": {
                    "collection": {
                        "name": "modular"
                    }
                },
                "target_path": "/data"
            }
        },
        {
            "directory": {
                "source": {
                    "framework": {}
                },
                "source_path": "/hub",
                "target": {
                    "collection": {
                        "name": "modular"
                    }
                },
                "target_path": "/hub"
            }
        },
        {
            "storage": {
                "type": "data",
                "source": {
                    "storage": {
                        "name": "logger-storage"
                    }
                },
                "target": {
                    "child": {
                        "name": "netstack"
                    }
                }
            }
        },
        {
            "storage": {
                "type": "data",
                "source": {
                    "storage": {
                        "name": "logger-storage"
                    }
                },
                "target": {
                    "collection": {
                        "name": "modular"
                    }
                }
            }
        }
    ],
    "children": [
        {
            "name": "logger",
            "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
            "startup": "lazy"
        },
        {
            "name": "netstack",
            "url": "fuchsia-pkg://fuchsia.com/netstack/stable#meta/netstack.cm",
            "startup": "lazy"
        }
    ],
    "collections": [
        {
            "name": "modular",
            "durability": "persistent"
        }
    ],
    "storage": [
        {
            "name": "logger-storage",
            "source_path": "/minfs",
            "source": {
                "child": {
                    "name": "logger"
                }
            }
        }
    ]
}"#,
        },

        test_compile_children => {
            input = json!({
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                    },
                    {
                        "name": "gmail",
                        "url": "https://www.google.com/gmail",
                        "startup": "eager",
                    },
                    {
                        "name": "echo",
                        "url": "fuchsia-pkg://fuchsia.com/echo/stable#meta/echo.cm",
                        "startup": "lazy",
                    },
                ]
            }),
            output = r#"{
    "children": [
        {
            "name": "logger",
            "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
            "startup": "lazy"
        },
        {
            "name": "gmail",
            "url": "https://www.google.com/gmail",
            "startup": "eager"
        },
        {
            "name": "echo",
            "url": "fuchsia-pkg://fuchsia.com/echo/stable#meta/echo.cm",
            "startup": "lazy"
        }
    ]
}"#,
        },

        test_compile_collections => {
            input = json!({
                "collections": [
                    {
                        "name": "modular",
                        "durability": "persistent",
                    },
                    {
                        "name": "tests",
                        "durability": "transient",
                    },
                ]
            }),
            output = r#"{
    "collections": [
        {
            "name": "modular",
            "durability": "persistent"
        },
        {
            "name": "tests",
            "durability": "transient"
        }
    ]
}"#,
        },

        test_compile_storage => {
            input = json!({
                "storage": [
                    {
                        "name": "mystorage",
                        "path": "/storage",
                        "from": "#minfs",
                    }
                ],
                "children": [
                    {
                        "name": "minfs",
                        "url": "fuchsia-pkg://fuchsia.com/minfs/stable#meta/minfs.cm",
                    },
                ]
            }),
            output = r#"{
    "children": [
        {
            "name": "minfs",
            "url": "fuchsia-pkg://fuchsia.com/minfs/stable#meta/minfs.cm",
            "startup": "lazy"
        }
    ],
    "storage": [
        {
            "name": "mystorage",
            "source_path": "/storage",
            "source": {
                "child": {
                    "name": "minfs"
                }
            }
        }
    ]
}"#,
        },

        test_compile_facets => {
            input = json!({
                "facets": {
                    "metadata": {
                        "title": "foo",
                        "authors": [ "me", "you" ],
                        "year": 2018
                    }
                }
            }),
            output = r#"{
    "facets": {
        "metadata": {
            "authors": [
                "me",
                "you"
            ],
            "title": "foo",
            "year": 2018
        }
    }
}"#,
        },

        test_compile_all_sections => {
            input = json!({
                "program": {
                    "binary": "bin/app",
                },
                "use": [
                    { "service": "/fonts/CoolFonts", "as": "/svc/fuchsia.fonts.Provider" },
                    { "legacy_service": "/fonts/LegacyCoolFonts", "as": "/svc/fuchsia.fonts.LegacyProvider" },
                ],
                "expose": [
                    { "directory": "/volumes/blobfs", "from": "self" },
                ],
                "offer": [
                    {
                        "service": "/svc/fuchsia.logger.Log",
                        "from": "#logger",
                        "to": [
                            { "dest": "#netstack" },
                            { "dest": "#modular" },
                        ],
                    },
                    {
                        "legacy_service": "/svc/fuchsia.logger.LegacyLog",
                        "from": "#logger",
                        "to": [
                            { "dest": "#netstack" },
                            { "dest": "#modular" },
                        ],
                    },
                ],
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
                    },
                    {
                        "name": "netstack",
                        "url": "fuchsia-pkg://fuchsia.com/netstack/stable#meta/netstack.cm",
                    },
                ],
                "collections": [
                    {
                        "name": "modular",
                        "durability": "persistent",
                    },
                ],
                "facets": {
                    "author": "Fuchsia",
                    "year": 2018,
                },
            }),
            output = r#"{
    "program": {
        "binary": "bin/app"
    },
    "uses": [
        {
            "service": {
                "source": {
                    "realm": {}
                },
                "source_path": "/fonts/CoolFonts",
                "target_path": "/svc/fuchsia.fonts.Provider"
            }
        },
        {
            "legacy_service": {
                "source": {
                    "realm": {}
                },
                "source_path": "/fonts/LegacyCoolFonts",
                "target_path": "/svc/fuchsia.fonts.LegacyProvider"
            }
        }
    ],
    "exposes": [
        {
            "directory": {
                "source": {
                    "self": {}
                },
                "source_path": "/volumes/blobfs",
                "target_path": "/volumes/blobfs"
            }
        }
    ],
    "offers": [
        {
            "service": {
                "source": {
                    "child": {
                        "name": "logger"
                    }
                },
                "source_path": "/svc/fuchsia.logger.Log",
                "target": {
                    "child": {
                        "name": "netstack"
                    }
                },
                "target_path": "/svc/fuchsia.logger.Log"
            }
        },
        {
            "service": {
                "source": {
                    "child": {
                        "name": "logger"
                    }
                },
                "source_path": "/svc/fuchsia.logger.Log",
                "target": {
                    "collection": {
                        "name": "modular"
                    }
                },
                "target_path": "/svc/fuchsia.logger.Log"
            }
        },
        {
            "legacy_service": {
                "source": {
                    "child": {
                        "name": "logger"
                    }
                },
                "source_path": "/svc/fuchsia.logger.LegacyLog",
                "target": {
                    "child": {
                        "name": "netstack"
                    }
                },
                "target_path": "/svc/fuchsia.logger.LegacyLog"
            }
        },
        {
            "legacy_service": {
                "source": {
                    "child": {
                        "name": "logger"
                    }
                },
                "source_path": "/svc/fuchsia.logger.LegacyLog",
                "target": {
                    "collection": {
                        "name": "modular"
                    }
                },
                "target_path": "/svc/fuchsia.logger.LegacyLog"
            }
        }
    ],
    "children": [
        {
            "name": "logger",
            "url": "fuchsia-pkg://fuchsia.com/logger/stable#meta/logger.cm",
            "startup": "lazy"
        },
        {
            "name": "netstack",
            "url": "fuchsia-pkg://fuchsia.com/netstack/stable#meta/netstack.cm",
            "startup": "lazy"
        }
    ],
    "collections": [
        {
            "name": "modular",
            "durability": "persistent"
        }
    ],
    "facets": {
        "author": "Fuchsia",
        "year": 2018
    }
}"#,
        },
    }

    #[test]
    fn test_compile_compact() {
        let input = json!({
            "use": [
                { "service": "/fonts/CoolFonts", "as": "/svc/fuchsia.fonts.Provider" },
                { "legacy_service": "/fonts/LegacyCoolFonts", "as": "/svc/fuchsia.fonts.LegacyProvider" },
                { "directory": "/data/assets" }
            ]
        });
        let output = r#"{"uses":[{"service":{"source":{"realm":{}},"source_path":"/fonts/CoolFonts","target_path":"/svc/fuchsia.fonts.Provider"}},{"legacy_service":{"source":{"realm":{}},"source_path":"/fonts/LegacyCoolFonts","target_path":"/svc/fuchsia.fonts.LegacyProvider"}},{"directory":{"source":{"realm":{}},"source_path":"/data/assets","target_path":"/data/assets"}}]}"#;
        compile_test(input, &output, false);
    }

    #[test]
    fn test_invalid_json() {
        use cm_json::CML_SCHEMA;

        let tmp_dir = TempDir::new().unwrap();
        let tmp_in_path = tmp_dir.path().join("test.cml");
        let tmp_out_path = tmp_dir.path().join("test.cm");

        let input = json!({
            "expose": [
                { "directory": "/volumes/blobfs", "from": "realm" }
            ]
        });
        File::create(&tmp_in_path).unwrap().write_all(format!("{}", input).as_bytes()).unwrap();
        {
            let result = compile(&tmp_in_path, false, Some(tmp_out_path.clone()));
            let expected_result: Result<(), Error> = Err(Error::validate_schema(
                CML_SCHEMA,
                "Pattern condition is not met at /expose/0/from",
            ));
            assert_eq!(format!("{:?}", result), format!("{:?}", expected_result));
        }
        // Compilation failed so output should not exist.
        {
            let result = fs::File::open(&tmp_out_path);
            assert_eq!(result.unwrap_err().kind(), io::ErrorKind::NotFound);
        }
    }
}