// 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 {
    cm_fidl_validator, cm_types, fidl_fuchsia_data as fdata, fidl_fuchsia_io2 as fio2,
    fidl_fuchsia_sys2 as fsys,
    lazy_static::lazy_static,
    std::collections::HashMap,
    std::convert::{From, TryFrom, TryInto},
    std::fmt,
    std::path::PathBuf,
    std::str::FromStr,
    thiserror::Error,
};

pub mod data;

lazy_static! {
    static ref DATA_TYPENAME: CapabilityName = CapabilityName("Data".to_string());
    static ref CACHE_TYPENAME: CapabilityName = CapabilityName("Cache".to_string());
    static ref META_TYPENAME: CapabilityName = CapabilityName("Meta".to_string());
}

/// Converts a fidl object into its corresponding native representation.
pub trait FidlIntoNative<T> {
    fn fidl_into_native(self) -> T;
}

pub trait NativeIntoFidl<T> {
    fn native_into_fidl(self) -> T;
}

/// Generates `FidlIntoNative` and `NativeIntoFidl` implementations for a basic type from
/// `Option<type>` that respectively unwraps the Option and wraps the internal value in a `Some()`.
macro_rules! fidl_translations_opt_type {
    ($into_type:ty) => {
        impl FidlIntoNative<$into_type> for Option<$into_type> {
            fn fidl_into_native(self) -> $into_type {
                self.unwrap()
            }
        }
        impl NativeIntoFidl<Option<$into_type>> for $into_type {
            fn native_into_fidl(self) -> Option<$into_type> {
                Some(self)
            }
        }
    };
}

/// Generates `FidlIntoNative` and `NativeIntoFidl` implementations that leaves the input unchanged.
macro_rules! fidl_translations_identical {
    ($into_type:ty) => {
        impl FidlIntoNative<$into_type> for $into_type {
            fn fidl_into_native(self) -> $into_type {
                self
            }
        }
        impl NativeIntoFidl<$into_type> for $into_type {
            fn native_into_fidl(self) -> Self {
                self
            }
        }
    };
}

/// Generates a struct with a `FidlIntoNative` implementation that calls `fidl_into_native()` on
/// each field. The `from_type` must be a FIDL table, not a FIDL struct.
/// - `into_type` is the name of the struct and the into type for the conversion.
/// - `into_ident` must be identical to `into_type`.
/// - `from_type` is the from type for the conversion.
/// - `from_path` must be identical to `from_type`.
/// - `field: type` form a list of fields and their types for the generated struct.
macro_rules! fidl_into_struct {
    ($into_type:ty, $into_ident:ident, $from_type:ty, $from_path:path,
     { $( $field:ident: $type:ty, )+ } ) => {
        #[derive(Debug, Clone, PartialEq, Eq)]
        pub struct $into_ident {
            $(
                pub $field: $type,
            )+
        }

        impl FidlIntoNative<$into_type> for $from_type {
            fn fidl_into_native(self) -> $into_type {
                $into_ident { $( $field: self.$field.fidl_into_native(), )+ }
            }
        }

        impl NativeIntoFidl<$from_type> for $into_type {
            fn native_into_fidl(self) -> $from_type {
                use $from_path as from_ident;
                from_ident {
                    $( $field: self.$field.native_into_fidl(), )+
                    ..from_ident::EMPTY
                }
            }
        }
    }
}

/// Generates an enum with a `FidlIntoNative` implementation that calls `fidl_into_native()` on each
/// field.
/// - `into_type` is the name of the enum and the into type for the conversion.
/// - `into_ident` must be identical to `into_type`.
/// - `from_type` is the from type for the conversion.
/// - `from_path` must be identical to `from_type`.
/// - `from_unknown` is the from unknown macro, i.e. `from_path` with "Unknown" appended
/// - `variant(type)` form a list of variants and their types for the generated enum.
macro_rules! fidl_into_enum {
    ($into_type:ty, $into_ident:ident, $from_type:ty, $from_path:path, $from_unknown:path,
     { $( $variant:ident($type:ty), )+ } ) => {
        #[derive(Debug, Clone, PartialEq, Eq)]
        pub enum $into_ident {
            $(
                $variant($type),
            )+
        }

        impl FidlIntoNative<$into_type> for $from_type {
            fn fidl_into_native(self) -> $into_type {
                use $from_path as from_ident;
                match self {
                    $(
                    from_ident::$variant(e) => $into_ident::$variant(e.fidl_into_native()),
                    )+
                    $from_unknown!() => { panic!("invalid variant") }
                }
            }
        }

        impl NativeIntoFidl<$from_type> for $into_type {
            fn native_into_fidl(self) -> $from_type {
                use $from_path as from_ident;
                match self {
                    $(
                        $into_ident::$variant(e) => from_ident::$variant(e.native_into_fidl()),
                    )+
                }
            }
        }
    }
}

/// Generates `FidlIntoNative` and `NativeIntoFidl` implementations between `Vec` and
/// `Option<Vec>`.
/// - `into_type` is the name of the struct and the into type for the conversion.
/// - `from_type` is the from type for the conversion.
macro_rules! fidl_into_vec {
    ($into_type:ty, $from_type:ty) => {
        impl FidlIntoNative<Vec<$into_type>> for Option<Vec<$from_type>> {
            fn fidl_into_native(self) -> Vec<$into_type> {
                if let Some(from) = self {
                    from.into_iter().map(|e: $from_type| e.fidl_into_native()).collect()
                } else {
                    vec![]
                }
            }
        }

        impl NativeIntoFidl<Option<Vec<$from_type>>> for Vec<$into_type> {
            fn native_into_fidl(self) -> Option<Vec<$from_type>> {
                if self.is_empty() {
                    None
                } else {
                    Some(self.into_iter().map(|e: $into_type| e.native_into_fidl()).collect())
                }
            }
        }
    };
}

#[derive(Debug, PartialEq, Default)]
pub struct ComponentDecl {
    pub program: Option<fdata::Dictionary>,
    pub uses: Vec<UseDecl>,
    pub exposes: Vec<ExposeDecl>,
    pub offers: Vec<OfferDecl>,
    pub capabilities: Vec<CapabilityDecl>,
    pub children: Vec<ChildDecl>,
    pub collections: Vec<CollectionDecl>,
    pub facets: Option<fsys::Object>,
    pub environments: Vec<EnvironmentDecl>,
}

impl FidlIntoNative<ComponentDecl> for fsys::ComponentDecl {
    fn fidl_into_native(self) -> ComponentDecl {
        // When transforming ExposeDecl::Service and OfferDecl::Service from
        // FIDL to native, we aggregate the declarations by target.
        let mut exposes = vec![];
        if let Some(e) = self.exposes {
            let mut services: HashMap<(ExposeTarget, CapabilityName), Vec<_>> = HashMap::new();
            for expose in e.into_iter() {
                match expose {
                    fsys::ExposeDecl::Service(s) => services
                        .entry((s.target.fidl_into_native(), s.target_name.fidl_into_native()))
                        .or_default()
                        .push(ServiceSource::<ExposeServiceSource> {
                            source: s.source.fidl_into_native(),
                            source_name: s.source_name.fidl_into_native(),
                        }),
                    fsys::ExposeDecl::Protocol(ls) => {
                        exposes.push(ExposeDecl::Protocol(ls.fidl_into_native()))
                    }
                    fsys::ExposeDecl::Directory(d) => {
                        exposes.push(ExposeDecl::Directory(d.fidl_into_native()))
                    }
                    fsys::ExposeDecl::Runner(r) => {
                        exposes.push(ExposeDecl::Runner(r.fidl_into_native()))
                    }
                    fsys::ExposeDecl::Resolver(r) => {
                        exposes.push(ExposeDecl::Resolver(r.fidl_into_native()))
                    }
                    fsys::ExposeDeclUnknown!() => panic!("invalid variant"),
                }
            }
            for ((target, target_name), sources) in services.into_iter() {
                exposes.push(ExposeDecl::Service(ExposeServiceDecl {
                    sources,
                    target,
                    target_name,
                }))
            }
        }
        let mut offers = vec![];
        if let Some(o) = self.offers {
            let mut services: HashMap<(OfferTarget, CapabilityName), Vec<_>> = HashMap::new();
            for offer in o.into_iter() {
                match offer {
                    fsys::OfferDecl::Service(s) => services
                        .entry((s.target.fidl_into_native(), s.target_name.fidl_into_native()))
                        .or_default()
                        .push(ServiceSource::<OfferServiceSource> {
                            source: s.source.fidl_into_native(),
                            source_name: s.source_name.fidl_into_native(),
                        }),
                    fsys::OfferDecl::Protocol(ls) => {
                        offers.push(OfferDecl::Protocol(ls.fidl_into_native()))
                    }
                    fsys::OfferDecl::Directory(d) => {
                        offers.push(OfferDecl::Directory(d.fidl_into_native()))
                    }
                    fsys::OfferDecl::Storage(s) => {
                        offers.push(OfferDecl::Storage(s.fidl_into_native()))
                    }
                    fsys::OfferDecl::Runner(s) => {
                        offers.push(OfferDecl::Runner(s.fidl_into_native()))
                    }
                    fsys::OfferDecl::Resolver(r) => {
                        offers.push(OfferDecl::Resolver(r.fidl_into_native()))
                    }
                    fsys::OfferDecl::Event(e) => {
                        offers.push(OfferDecl::Event(e.fidl_into_native()))
                    }
                    fsys::OfferDeclUnknown!() => panic!("invalid variant"),
                }
            }
            for ((target, target_name), sources) in services.into_iter() {
                offers.push(OfferDecl::Service(OfferServiceDecl { sources, target, target_name }))
            }
        }
        ComponentDecl {
            program: self.program.fidl_into_native(),
            uses: self.uses.fidl_into_native(),
            exposes,
            offers,
            capabilities: self.capabilities.fidl_into_native(),
            children: self.children.fidl_into_native(),
            collections: self.collections.fidl_into_native(),
            facets: self.facets.fidl_into_native(),
            environments: self.environments.fidl_into_native(),
        }
    }
}

impl NativeIntoFidl<fsys::ComponentDecl> for ComponentDecl {
    fn native_into_fidl(self) -> fsys::ComponentDecl {
        // When transforming ExposeDecl::Service and OfferDecl::Service from
        // native to FIDL, we disaggregate the declarations.
        let mut exposes = vec![];
        for expose in self.exposes.into_iter() {
            match expose {
                ExposeDecl::Service(s) => {
                    for es in s.sources.into_iter() {
                        exposes.push(fsys::ExposeDecl::Service(fsys::ExposeServiceDecl {
                            source: es.source.native_into_fidl(),
                            source_name: es.source_name.native_into_fidl(),
                            target: s.target.clone().native_into_fidl(),
                            target_name: s.target_name.clone().native_into_fidl(),
                            ..fsys::ExposeServiceDecl::EMPTY
                        }))
                    }
                }
                ExposeDecl::Protocol(ls) => {
                    exposes.push(fsys::ExposeDecl::Protocol(ls.native_into_fidl()))
                }
                ExposeDecl::Directory(d) => {
                    exposes.push(fsys::ExposeDecl::Directory(d.native_into_fidl()))
                }
                ExposeDecl::Runner(r) => {
                    exposes.push(fsys::ExposeDecl::Runner(r.native_into_fidl()))
                }
                ExposeDecl::Resolver(r) => {
                    exposes.push(fsys::ExposeDecl::Resolver(r.native_into_fidl()))
                }
            }
        }
        let mut offers = vec![];
        for offer in self.offers.into_iter() {
            match offer {
                OfferDecl::Service(s) => {
                    for os in s.sources.into_iter() {
                        offers.push(fsys::OfferDecl::Service(fsys::OfferServiceDecl {
                            source: os.source.native_into_fidl(),
                            source_name: os.source_name.native_into_fidl(),
                            target: s.target.clone().native_into_fidl(),
                            target_name: s.target_name.clone().native_into_fidl(),
                            ..fsys::OfferServiceDecl::EMPTY
                        }))
                    }
                }
                OfferDecl::Protocol(ls) => {
                    offers.push(fsys::OfferDecl::Protocol(ls.native_into_fidl()))
                }
                OfferDecl::Directory(d) => {
                    offers.push(fsys::OfferDecl::Directory(d.native_into_fidl()))
                }
                OfferDecl::Storage(s) => {
                    offers.push(fsys::OfferDecl::Storage(s.native_into_fidl()))
                }
                OfferDecl::Runner(s) => offers.push(fsys::OfferDecl::Runner(s.native_into_fidl())),
                OfferDecl::Resolver(r) => {
                    offers.push(fsys::OfferDecl::Resolver(r.native_into_fidl()))
                }
                OfferDecl::Event(e) => offers.push(fsys::OfferDecl::Event(e.native_into_fidl())),
            }
        }
        fsys::ComponentDecl {
            program: self.program.native_into_fidl(),
            uses: self.uses.native_into_fidl(),
            exposes: if exposes.is_empty() { None } else { Some(exposes) },
            offers: if offers.is_empty() { None } else { Some(offers) },
            capabilities: self.capabilities.native_into_fidl(),
            children: self.children.native_into_fidl(),
            collections: self.collections.native_into_fidl(),
            facets: self.facets.native_into_fidl(),
            environments: self.environments.native_into_fidl(),
            ..fsys::ComponentDecl::EMPTY
        }
    }
}

impl Clone for ComponentDecl {
    fn clone(&self) -> Self {
        ComponentDecl {
            program: data::clone_option_dictionary(&self.program),
            uses: self.uses.clone(),
            exposes: self.exposes.clone(),
            offers: self.offers.clone(),
            capabilities: self.capabilities.clone(),
            children: self.children.clone(),
            collections: self.collections.clone(),
            facets: data::clone_option_object(&self.facets),
            environments: self.environments.clone(),
        }
    }
}

impl ComponentDecl {
    /// Returns the `UseRunnerDecl` for this component, or `None` if this is a non-executable
    /// component.
    pub fn get_used_runner(&self) -> Option<&UseRunnerDecl> {
        self.uses.iter().find_map(|u| match u {
            UseDecl::Runner(runner) => Some(runner),
            _ => return None,
        })
    }

    /// Returns the `StorageDecl` corresponding to `storage_name`.
    pub fn find_storage_source<'a>(
        &'a self,
        storage_name: &CapabilityName,
    ) -> Option<&'a StorageDecl> {
        self.capabilities.iter().find_map(|c| match c {
            CapabilityDecl::Storage(s) if &s.name == storage_name => Some(s),
            _ => None,
        })
    }

    /// Returns the `ProtocolDecl` corresponding to `protocol_name`.
    pub fn find_protocol_source<'a>(
        &'a self,
        protocol_name: &CapabilityName,
    ) -> Option<&'a ProtocolDecl> {
        self.capabilities.iter().find_map(|c| match c {
            CapabilityDecl::Protocol(r) if &r.name == protocol_name => Some(r),
            _ => None,
        })
    }

    /// Returns the `DirectoryDecl` corresponding to `directory_name`.
    pub fn find_directory_source<'a>(
        &'a self,
        directory_name: &CapabilityName,
    ) -> Option<&'a DirectoryDecl> {
        self.capabilities.iter().find_map(|c| match c {
            CapabilityDecl::Directory(r) if &r.name == directory_name => Some(r),
            _ => None,
        })
    }

    /// Returns the `RunnerDecl` corresponding to `runner_name`.
    pub fn find_runner_source<'a>(
        &'a self,
        runner_name: &CapabilityName,
    ) -> Option<&'a RunnerDecl> {
        self.capabilities.iter().find_map(|c| match c {
            CapabilityDecl::Runner(r) if &r.name == runner_name => Some(r),
            _ => None,
        })
    }

    /// Returns the `ResolverDecl` corresponding to `resolver_name`.
    pub fn find_resolver_source<'a>(
        &'a self,
        resolver_name: &CapabilityName,
    ) -> Option<&'a ResolverDecl> {
        self.capabilities.iter().find_map(|c| match c {
            CapabilityDecl::Resolver(r) if &r.name == resolver_name => Some(r),
            _ => None,
        })
    }

    /// Returns the `CollectionDecl` corresponding to `collection_name`.
    pub fn find_collection<'a>(&'a self, collection_name: &str) -> Option<&'a CollectionDecl> {
        self.collections.iter().find(|c| c.name == collection_name)
    }

    /// Indicates whether the capability specified by `target_name` is exposed to the framework.
    pub fn is_protocol_exposed_to_framework(&self, in_target_name: &CapabilityName) -> bool {
        self.exposes.iter().any(|expose| match expose {
            ExposeDecl::Protocol(ExposeProtocolDecl { target, target_name, .. })
                if target == &ExposeTarget::Framework =>
            {
                target_name == in_target_name
            }
            _ => false,
        })
    }

    /// Indicates whether the capability specified by `source_name` is requested.
    pub fn uses_protocol(&self, source_name: &CapabilityName) -> bool {
        self.uses.iter().any(|use_decl| match use_decl {
            UseDecl::Protocol(ls) => &ls.source_name == source_name,
            _ => false,
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExposeDecl {
    Service(ExposeServiceDecl),
    Protocol(ExposeProtocolDecl),
    Directory(ExposeDirectoryDecl),
    Runner(ExposeRunnerDecl),
    Resolver(ExposeResolverDecl),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ExposeServiceDecl {
    pub sources: Vec<ServiceSource<ExposeServiceSource>>,
    pub target: ExposeTarget,
    pub target_name: CapabilityName,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OfferDecl {
    Service(OfferServiceDecl),
    Protocol(OfferProtocolDecl),
    Directory(OfferDirectoryDecl),
    Storage(OfferStorageDecl),
    Runner(OfferRunnerDecl),
    Resolver(OfferResolverDecl),
    Event(OfferEventDecl),
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct OfferServiceDecl {
    pub sources: Vec<ServiceSource<OfferServiceSource>>,
    pub target: OfferTarget,
    pub target_name: CapabilityName,
}

fidl_into_enum!(UseDecl, UseDecl, fsys::UseDecl, fsys::UseDecl, fsys::UseDeclUnknown,
{
    Service(UseServiceDecl),
    Protocol(UseProtocolDecl),
    Directory(UseDirectoryDecl),
    Storage(UseStorageDecl),
    Runner(UseRunnerDecl),
    Event(UseEventDecl),
    EventStream(UseEventStreamDecl),
});
fidl_into_struct!(UseServiceDecl, UseServiceDecl, fsys::UseServiceDecl, fsys::UseServiceDecl,
{
    source: UseSource,
    source_name: CapabilityName,
    target_path: CapabilityPath,
});
fidl_into_struct!(UseProtocolDecl, UseProtocolDecl, fsys::UseProtocolDecl, fsys::UseProtocolDecl,
{
    source: UseSource,
    source_name: CapabilityName,
    target_path: CapabilityPath,
});
fidl_into_struct!(UseDirectoryDecl, UseDirectoryDecl, fsys::UseDirectoryDecl,
fsys::UseDirectoryDecl,
{
    source: UseSource,
    source_name: CapabilityName,
    target_path: CapabilityPath,
    rights: fio2::Operations,
    subdir: Option<PathBuf>,
});
fidl_into_struct!(UseStorageDecl, UseStorageDecl, fsys::UseStorageDecl, fsys::UseStorageDecl,
{
    source_name: CapabilityName,
    target_path: CapabilityPath,
});
fidl_into_struct!(UseRunnerDecl, UseRunnerDecl, fsys::UseRunnerDecl,
fsys::UseRunnerDecl,
{
    source_name: CapabilityName,
});
fidl_into_struct!(EventSubscription, EventSubscription, fsys::EventSubscription,
fsys::EventSubscription, {
    event_name: String,
    mode: EventMode,
});
fidl_into_struct!(UseEventDecl, UseEventDecl, fsys::UseEventDecl,
fsys::UseEventDecl,
{
    source: UseSource,
    source_name: CapabilityName,
    target_name: CapabilityName,
    filter: Option<HashMap<String, DictionaryValue>>,
    mode: EventMode,
});
fidl_into_struct!(UseEventStreamDecl, UseEventStreamDecl, fsys::UseEventStreamDecl,
fsys::UseEventStreamDecl,
{
    target_path: CapabilityPath,
    events: Vec<EventSubscription>,
});

fidl_into_struct!(ExposeProtocolDecl, ExposeProtocolDecl, fsys::ExposeProtocolDecl,
fsys::ExposeProtocolDecl,
{
    source: ExposeSource,
    source_name: CapabilityName,
    target: ExposeTarget,
    target_name: CapabilityName,
});
fidl_into_struct!(ExposeDirectoryDecl, ExposeDirectoryDecl, fsys::ExposeDirectoryDecl,
fsys::ExposeDirectoryDecl,
{
    source: ExposeSource,
    source_name: CapabilityName,
    target: ExposeTarget,
    target_name: CapabilityName,
    rights: Option<fio2::Operations>,
    subdir: Option<PathBuf>,
});
fidl_into_struct!(ExposeResolverDecl, ExposeResolverDecl, fsys::ExposeResolverDecl,
fsys::ExposeResolverDecl,
{
    source: ExposeSource,
    source_name: CapabilityName,
    target: ExposeTarget,
    target_name: CapabilityName,
});
fidl_into_struct!(ExposeRunnerDecl, ExposeRunnerDecl, fsys::ExposeRunnerDecl,
fsys::ExposeRunnerDecl,
{
    source: ExposeSource,
    source_name: CapabilityName,
    target: ExposeTarget,
    target_name: CapabilityName,
});
fidl_into_struct!(OfferProtocolDecl, OfferProtocolDecl, fsys::OfferProtocolDecl,
fsys::OfferProtocolDecl,
{
    source: OfferServiceSource,
    source_name: CapabilityName,
    target: OfferTarget,
    target_name: CapabilityName,
    dependency_type: DependencyType,
});
fidl_into_struct!(OfferDirectoryDecl, OfferDirectoryDecl, fsys::OfferDirectoryDecl,
fsys::OfferDirectoryDecl,
{
    source: OfferDirectorySource,
    source_name: CapabilityName,
    target: OfferTarget,
    target_name: CapabilityName,
    rights: Option<fio2::Operations>,
    subdir: Option<PathBuf>,
    dependency_type: DependencyType,
});
fidl_into_struct!(OfferStorageDecl, OfferStorageDecl, fsys::OfferStorageDecl,
fsys::OfferStorageDecl,
{
    source_name: CapabilityName,
    source: OfferStorageSource,
    target: OfferTarget,
    target_name: CapabilityName,
});
fidl_into_struct!(OfferResolverDecl, OfferResolverDecl, fsys::OfferResolverDecl,
fsys::OfferResolverDecl,
{
    source: OfferResolverSource,
    source_name: CapabilityName,
    target: OfferTarget,
    target_name: CapabilityName,
});
fidl_into_struct!(OfferRunnerDecl, OfferRunnerDecl, fsys::OfferRunnerDecl,
fsys::OfferRunnerDecl,
{
    source: OfferRunnerSource,
    source_name: CapabilityName,
    target: OfferTarget,
    target_name: CapabilityName,
});
fidl_into_struct!(OfferEventDecl, OfferEventDecl, fsys::OfferEventDecl,
fsys::OfferEventDecl,
{
    source: OfferEventSource,
    source_name: CapabilityName,
    target: OfferTarget,
    target_name: CapabilityName,
    filter: Option<HashMap<String, DictionaryValue>>,
    mode: EventMode,
});
fidl_into_enum!(CapabilityDecl, CapabilityDecl, fsys::CapabilityDecl, fsys::CapabilityDecl, fsys::CapabilityDeclUnknown,
{
    Service(ServiceDecl),
    Protocol(ProtocolDecl),
    Directory(DirectoryDecl),
    Storage(StorageDecl),
    Runner(RunnerDecl),    Resolver(ResolverDecl),
});
fidl_into_struct!(ServiceDecl, ServiceDecl, fsys::ServiceDecl, fsys::ServiceDecl,
{
    name: CapabilityName,
    source_path: CapabilityPath,
});
fidl_into_struct!(ProtocolDecl, ProtocolDecl, fsys::ProtocolDecl, fsys::ProtocolDecl,
{
    name: CapabilityName,
    source_path: CapabilityPath,
});
fidl_into_struct!(DirectoryDecl, DirectoryDecl, fsys::DirectoryDecl, fsys::DirectoryDecl,
{
    name: CapabilityName,
    source_path: CapabilityPath,
    rights: fio2::Operations,
});
fidl_into_struct!(StorageDecl, StorageDecl, fsys::StorageDecl,
fsys::StorageDecl,
{
    name: CapabilityName,
    source: StorageDirectorySource,
    backing_dir: CapabilityName,
    subdir: Option<PathBuf>,
});
fidl_into_struct!(RunnerDecl, RunnerDecl, fsys::RunnerDecl, fsys::RunnerDecl,
{
    name: CapabilityName,
    source: RunnerSource,
    source_path: CapabilityPath,
});
fidl_into_struct!(ResolverDecl, ResolverDecl, fsys::ResolverDecl, fsys::ResolverDecl,
{
    name: CapabilityName,
    source_path: CapabilityPath,
});
fidl_into_struct!(ChildDecl, ChildDecl, fsys::ChildDecl, fsys::ChildDecl,
{
    name: String,
    url: String,
    startup: fsys::StartupMode,
    environment: Option<String>,
});

fidl_into_struct!(CollectionDecl, CollectionDecl, fsys::CollectionDecl, fsys::CollectionDecl,
{
    name: String,
    durability: fsys::Durability,
    environment: Option<String>,
});
fidl_into_struct!(EnvironmentDecl, EnvironmentDecl, fsys::EnvironmentDecl, fsys::EnvironmentDecl,
{
    name: String,
    extends: fsys::EnvironmentExtends,
    runners: Vec<RunnerRegistration>,
    resolvers: Vec<ResolverRegistration>,
    stop_timeout_ms: Option<u32>,
});
fidl_into_struct!(RunnerRegistration, RunnerRegistration, fsys::RunnerRegistration,
fsys::RunnerRegistration,
{
    source_name: CapabilityName,
    source: RegistrationSource,
    target_name: CapabilityName,
});
fidl_into_struct!(ResolverRegistration, ResolverRegistration, fsys::ResolverRegistration,
fsys::ResolverRegistration,
{
    resolver: CapabilityName,
    source: RegistrationSource,
    scheme: String,
});

fidl_into_vec!(UseDecl, fsys::UseDecl);
fidl_into_vec!(ChildDecl, fsys::ChildDecl);
fidl_into_vec!(CollectionDecl, fsys::CollectionDecl);
fidl_into_vec!(CapabilityDecl, fsys::CapabilityDecl);
fidl_into_vec!(EnvironmentDecl, fsys::EnvironmentDecl);
fidl_into_vec!(RunnerRegistration, fsys::RunnerRegistration);
fidl_into_vec!(ResolverRegistration, fsys::ResolverRegistration);
fidl_into_vec!(EventSubscription, fsys::EventSubscription);
fidl_translations_opt_type!(Vec<String>);
fidl_translations_opt_type!(String);
fidl_translations_opt_type!(fsys::StartupMode);
fidl_translations_opt_type!(fsys::Durability);
fidl_translations_opt_type!(fsys::Object);
fidl_translations_opt_type!(fdata::Dictionary);
fidl_translations_opt_type!(fio2::Operations);
fidl_translations_opt_type!(fsys::EnvironmentExtends);
fidl_translations_identical!(Option<fio2::Operations>);
fidl_translations_identical!(Option<fsys::Object>);
fidl_translations_identical!(Option<fdata::Dictionary>);
fidl_translations_identical!(Option<String>);

/// A path to a capability.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CapabilityPath {
    /// The directory containing the last path element, e.g. `/svc/foo` in `/svc/foo/bar`.
    pub dirname: String,
    /// The last path element: e.g. `bar` in `/svc/foo/bar`.
    pub basename: String,
}

impl CapabilityPath {
    pub fn to_path_buf(&self) -> PathBuf {
        PathBuf::from(self.to_string())
    }

    /// Splits the path according to "/", ignoring empty path components
    pub fn split(&self) -> Vec<String> {
        self.to_string().split("/").map(|s| s.to_string()).filter(|s| !s.is_empty()).collect()
    }
}

impl FromStr for CapabilityPath {
    type Err = Error;

    fn from_str(path: &str) -> Result<CapabilityPath, Error> {
        cm_types::Path::validate(path)
            .map_err(|_| Error::InvalidCapabilityPath { raw: path.to_string() })?;
        let idx = path.rfind('/').expect("path validation is wrong");
        Ok(CapabilityPath {
            dirname: if idx == 0 { "/".to_string() } else { path[0..idx].to_string() },
            basename: path[idx + 1..].to_string(),
        })
    }
}

impl TryFrom<&str> for CapabilityPath {
    type Error = Error;

    fn try_from(path: &str) -> Result<CapabilityPath, Error> {
        Self::from_str(path)
    }
}

impl fmt::Display for CapabilityPath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if &self.dirname == "/" {
            write!(f, "/{}", self.basename)
        } else {
            write!(f, "{}/{}", self.dirname, self.basename)
        }
    }
}

impl UseDecl {
    pub fn path(&self) -> Option<&CapabilityPath> {
        match self {
            UseDecl::Service(d) => Some(&d.target_path),
            UseDecl::Protocol(d) => Some(&d.target_path),
            UseDecl::Directory(d) => Some(&d.target_path),
            UseDecl::Storage(d) => Some(&d.target_path),
            UseDecl::EventStream(e) => Some(&e.target_path),
            UseDecl::Runner(_) | UseDecl::Event(_) => None,
        }
    }

    pub fn name(&self) -> Option<&CapabilityName> {
        match self {
            UseDecl::Event(event_decl) => Some(&event_decl.source_name),
            UseDecl::Runner(runner_decl) => Some(&runner_decl.source_name),
            UseDecl::Storage(storage_decl) => Some(&storage_decl.source_name),
            UseDecl::Service(_)
            | UseDecl::Protocol(_)
            | UseDecl::Directory(_)
            | UseDecl::EventStream(_) => None,
        }
    }
}

/// A named capability.
///
/// Unlike a `CapabilityPath`, a `CapabilityName` doesn't encode any form
/// of hierarchy.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct CapabilityName(pub String);

impl CapabilityName {
    pub fn str(&self) -> &str {
        &self.0
    }
}

impl From<&str> for CapabilityName {
    fn from(name: &str) -> CapabilityName {
        CapabilityName(name.to_string())
    }
}

impl From<String> for CapabilityName {
    fn from(name: String) -> CapabilityName {
        CapabilityName(name)
    }
}

impl fmt::Display for CapabilityName {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.0.fmt(f)
    }
}

/// A named capability type.
///
/// `CapabilityTypeName` provides a user friendly type encoding for a capability.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum CapabilityTypeName {
    Directory,
    Event,
    EventStream,
    Protocol,
    Resolver,
    Runner,
    Service,
    Storage,
}

impl fmt::Display for CapabilityTypeName {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let display_name = match &self {
            CapabilityTypeName::Directory => "directory",
            CapabilityTypeName::Event => "event",
            CapabilityTypeName::EventStream => "event_stream",
            CapabilityTypeName::Protocol => "protocol",
            CapabilityTypeName::Resolver => "resolver",
            CapabilityTypeName::Runner => "runner",
            CapabilityTypeName::Service => "service",
            CapabilityTypeName::Storage => "storage",
        };
        write!(f, "{}", display_name)
    }
}

// TODO: Runners and third parties can use this to parse `facets`.
impl FidlIntoNative<Option<HashMap<String, Value>>> for Option<fsys::Object> {
    fn fidl_into_native(self) -> Option<HashMap<String, Value>> {
        self.map(|o| from_fidl_obj(o))
    }
}

impl FidlIntoNative<Option<HashMap<String, DictionaryValue>>> for Option<fdata::Dictionary> {
    fn fidl_into_native(self) -> Option<HashMap<String, DictionaryValue>> {
        self.map(|d| from_fidl_dict(d))
    }
}

impl NativeIntoFidl<Option<fdata::Dictionary>> for Option<HashMap<String, DictionaryValue>> {
    fn native_into_fidl(self) -> Option<fdata::Dictionary> {
        self.map(|d| to_fidl_dict(d))
    }
}

fidl_translations_identical!(Option<u32>);

impl FidlIntoNative<CapabilityPath> for Option<String> {
    fn fidl_into_native(self) -> CapabilityPath {
        let s: &str = &self.unwrap();
        s.try_into().expect("invalid capability path")
    }
}

impl NativeIntoFidl<Option<String>> for CapabilityPath {
    fn native_into_fidl(self) -> Option<String> {
        Some(self.to_string())
    }
}

impl FidlIntoNative<Option<PathBuf>> for Option<String> {
    fn fidl_into_native(self) -> Option<PathBuf> {
        self.map(|p| PathBuf::from(p))
    }
}

impl NativeIntoFidl<Option<String>> for Option<PathBuf> {
    fn native_into_fidl(self) -> Option<String> {
        self.map(|p| p.to_str().expect("invalid utf8").to_string())
    }
}

impl FidlIntoNative<CapabilityName> for Option<String> {
    fn fidl_into_native(self) -> CapabilityName {
        let s: &str = &self.unwrap();
        s.into()
    }
}

impl NativeIntoFidl<Option<String>> for CapabilityName {
    fn native_into_fidl(self) -> Option<String> {
        Some(self.to_string())
    }
}

impl FidlIntoNative<bool> for Option<bool> {
    fn fidl_into_native(self) -> bool {
        self.unwrap()
    }
}

impl NativeIntoFidl<Option<bool>> for bool {
    fn native_into_fidl(self) -> Option<bool> {
        Some(self)
    }
}

#[derive(Debug, PartialEq)]
pub enum Value {
    Bit(bool),
    Inum(i64),
    Fnum(f64),
    Str(String),
    Vec(Vec<Value>),
    Obj(HashMap<String, Value>),
    Null,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DictionaryValue {
    Str(String),
    StrVec(Vec<String>),
    Null,
}

impl FidlIntoNative<Value> for Option<Box<fsys::Value>> {
    fn fidl_into_native(self) -> Value {
        match self {
            Some(v) => match *v {
                fsys::Value::Bit(b) => Value::Bit(b),
                fsys::Value::Inum(i) => Value::Inum(i),
                fsys::Value::Fnum(f) => Value::Fnum(f),
                fsys::Value::Str(s) => Value::Str(s),
                fsys::Value::Vec(v) => Value::Vec(from_fidl_vec(v)),
                fsys::Value::Obj(d) => Value::Obj(from_fidl_obj(d)),
            },
            None => Value::Null,
        }
    }
}

impl FidlIntoNative<DictionaryValue> for Option<Box<fdata::DictionaryValue>> {
    fn fidl_into_native(self) -> DictionaryValue {
        match self {
            Some(v) => match *v {
                fdata::DictionaryValue::Str(s) => DictionaryValue::Str(s),
                fdata::DictionaryValue::StrVec(ss) => DictionaryValue::StrVec(ss),
            },
            None => DictionaryValue::Null,
        }
    }
}

impl NativeIntoFidl<Option<Box<fdata::DictionaryValue>>> for DictionaryValue {
    fn native_into_fidl(self) -> Option<Box<fdata::DictionaryValue>> {
        match self {
            DictionaryValue::Str(s) => Some(Box::new(fdata::DictionaryValue::Str(s))),
            DictionaryValue::StrVec(ss) => Some(Box::new(fdata::DictionaryValue::StrVec(ss))),
            DictionaryValue::Null => None,
        }
    }
}

fn from_fidl_vec(vec: fsys::Vector) -> Vec<Value> {
    vec.values.into_iter().map(|v| v.fidl_into_native()).collect()
}

fn from_fidl_obj(obj: fsys::Object) -> HashMap<String, Value> {
    obj.entries.into_iter().map(|e| (e.key, e.value.fidl_into_native())).collect()
}

fn from_fidl_dict(dict: fdata::Dictionary) -> HashMap<String, DictionaryValue> {
    match dict.entries {
        Some(entries) => entries.into_iter().map(|e| (e.key, e.value.fidl_into_native())).collect(),
        _ => HashMap::new(),
    }
}

fn to_fidl_dict(dict: HashMap<String, DictionaryValue>) -> fdata::Dictionary {
    fdata::Dictionary {
        entries: Some(
            dict.into_iter()
                .map(|(key, value)| fdata::DictionaryEntry { key, value: value.native_into_fidl() })
                .collect(),
        ),
        ..fdata::Dictionary::EMPTY
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum UseSource {
    Parent,
    Framework,
    Capability(CapabilityName),
}

impl FidlIntoNative<UseSource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> UseSource {
        match self.unwrap() {
            fsys::Ref::Parent(_) => UseSource::Parent,
            fsys::Ref::Framework(_) => UseSource::Framework,
            fsys::Ref::Capability(c) => UseSource::Capability(c.name.into()),
            _ => panic!("invalid UseSource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for UseSource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            UseSource::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
            UseSource::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}),
            UseSource::Capability(name) => {
                fsys::Ref::Capability(fsys::CapabilityRef { name: name.to_string() })
            }
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExposeSource {
    Self_,
    Child(String),
    Framework,
    Capability(CapabilityName),
}

impl FidlIntoNative<ExposeSource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> ExposeSource {
        match self.unwrap() {
            fsys::Ref::Self_(_) => ExposeSource::Self_,
            fsys::Ref::Child(c) => ExposeSource::Child(c.name),
            fsys::Ref::Framework(_) => ExposeSource::Framework,
            fsys::Ref::Capability(c) => ExposeSource::Capability(c.name.into()),
            _ => panic!("invalid ExposeSource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for ExposeSource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            ExposeSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}),
            ExposeSource::Child(child_name) => {
                fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None })
            }
            ExposeSource::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}),
            ExposeSource::Capability(name) => {
                fsys::Ref::Capability(fsys::CapabilityRef { name: name.to_string() })
            }
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ExposeTarget {
    Parent,
    Framework,
}

impl FidlIntoNative<ExposeTarget> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> ExposeTarget {
        match self {
            Some(dest) => match dest {
                fsys::Ref::Parent(_) => ExposeTarget::Parent,
                fsys::Ref::Framework(_) => ExposeTarget::Framework,
                _ => panic!("invalid ExposeTarget variant"),
            },
            None => ExposeTarget::Parent,
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for ExposeTarget {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            ExposeTarget::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
            ExposeTarget::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}),
        })
    }
}

/// A source for a service.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct ServiceSource<T> {
    /// The provider of the service, relative to a component.
    pub source: T,
    /// The name of the service.
    pub source_name: CapabilityName,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum DependencyType {
    Strong,
    WeakForMigration,
}

impl FidlIntoNative<DependencyType> for Option<fsys::DependencyType> {
    fn fidl_into_native(self) -> DependencyType {
        match self.unwrap() {
            fsys::DependencyType::Strong => DependencyType::Strong,
            fsys::DependencyType::WeakForMigration => DependencyType::WeakForMigration,
        }
    }
}

impl NativeIntoFidl<Option<fsys::DependencyType>> for DependencyType {
    fn native_into_fidl(self) -> Option<fsys::DependencyType> {
        Some(match self {
            DependencyType::Strong => fsys::DependencyType::Strong,
            DependencyType::WeakForMigration => fsys::DependencyType::WeakForMigration,
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OfferServiceSource {
    Parent,
    Self_,
    Child(String),
    Capability(CapabilityName),
}

impl FidlIntoNative<OfferServiceSource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> OfferServiceSource {
        match self.unwrap() {
            fsys::Ref::Parent(_) => OfferServiceSource::Parent,
            fsys::Ref::Self_(_) => OfferServiceSource::Self_,
            fsys::Ref::Child(c) => OfferServiceSource::Child(c.name),
            fsys::Ref::Capability(c) => OfferServiceSource::Capability(c.name.into()),
            _ => panic!("invalid OfferServiceSource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for OfferServiceSource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            OfferServiceSource::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
            OfferServiceSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}),
            OfferServiceSource::Child(child_name) => {
                fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None })
            }
            OfferServiceSource::Capability(name) => {
                fsys::Ref::Capability(fsys::CapabilityRef { name: name.to_string() })
            }
        })
    }
}

/// The valid sources of a service protocol's expose declaration.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ExposeServiceSource {
    /// The service is exposed from the component manager itself.
    Framework,
    /// The service is exposed by the component itself.
    Self_,
    /// The service is exposed by a named child component.
    Child(String),
}

impl FidlIntoNative<ExposeServiceSource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> ExposeServiceSource {
        match self.unwrap() {
            fsys::Ref::Framework(_) => ExposeServiceSource::Framework,
            fsys::Ref::Self_(_) => ExposeServiceSource::Self_,
            fsys::Ref::Child(c) => ExposeServiceSource::Child(c.name),
            _ => panic!("invalid ExposeServiceSource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for ExposeServiceSource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            ExposeServiceSource::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}),
            ExposeServiceSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}),
            ExposeServiceSource::Child(child_name) => {
                fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None })
            }
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StorageDirectorySource {
    Parent,
    Self_,
    Child(String),
}

impl FidlIntoNative<StorageDirectorySource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> StorageDirectorySource {
        match self.unwrap() {
            fsys::Ref::Parent(_) => StorageDirectorySource::Parent,
            fsys::Ref::Self_(_) => StorageDirectorySource::Self_,
            fsys::Ref::Child(c) => StorageDirectorySource::Child(c.name),
            _ => panic!("invalid OfferDirectorySource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for StorageDirectorySource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            StorageDirectorySource::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
            StorageDirectorySource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}),
            StorageDirectorySource::Child(child_name) => {
                fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None })
            }
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RunnerSource {
    Parent,
    Self_,
    Child(String),
}

impl FidlIntoNative<RunnerSource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> RunnerSource {
        match self.unwrap() {
            fsys::Ref::Parent(_) => RunnerSource::Parent,
            fsys::Ref::Self_(_) => RunnerSource::Self_,
            fsys::Ref::Child(c) => RunnerSource::Child(c.name),
            _ => panic!("invalid RunnerSource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for RunnerSource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            RunnerSource::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
            RunnerSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}),
            RunnerSource::Child(child_name) => {
                fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None })
            }
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum RegistrationSource {
    Parent,
    Self_,
    Child(String),
}

impl FidlIntoNative<RegistrationSource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> RegistrationSource {
        match self.unwrap() {
            fsys::Ref::Parent(_) => RegistrationSource::Parent,
            fsys::Ref::Self_(_) => RegistrationSource::Self_,
            fsys::Ref::Child(c) => RegistrationSource::Child(c.name),
            _ => panic!("invalid RegistrationSource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for RegistrationSource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            RegistrationSource::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
            RegistrationSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}),
            RegistrationSource::Child(child_name) => {
                fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None })
            }
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OfferDirectorySource {
    Parent,
    Self_,
    Framework,
    Child(String),
}

impl FidlIntoNative<OfferDirectorySource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> OfferDirectorySource {
        match self.unwrap() {
            fsys::Ref::Parent(_) => OfferDirectorySource::Parent,
            fsys::Ref::Self_(_) => OfferDirectorySource::Self_,
            fsys::Ref::Framework(_) => OfferDirectorySource::Framework,
            fsys::Ref::Child(c) => OfferDirectorySource::Child(c.name),
            _ => panic!("invalid OfferDirectorySource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for OfferDirectorySource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            OfferDirectorySource::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
            OfferDirectorySource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}),
            OfferDirectorySource::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}),
            OfferDirectorySource::Child(child_name) => {
                fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None })
            }
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OfferStorageSource {
    Parent,
    Self_,
}

impl FidlIntoNative<OfferStorageSource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> OfferStorageSource {
        match self.unwrap() {
            fsys::Ref::Parent(_) => OfferStorageSource::Parent,
            fsys::Ref::Self_(_) => OfferStorageSource::Self_,
            _ => panic!("invalid OfferStorageSource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for OfferStorageSource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            OfferStorageSource::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
            OfferStorageSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}),
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OfferRunnerSource {
    Parent,
    Self_,
    Child(String),
}

impl FidlIntoNative<OfferRunnerSource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> OfferRunnerSource {
        match self.unwrap() {
            fsys::Ref::Parent(_) => OfferRunnerSource::Parent,
            fsys::Ref::Self_(_) => OfferRunnerSource::Self_,
            fsys::Ref::Child(c) => OfferRunnerSource::Child(c.name),
            _ => panic!("invalid OfferRunnerSource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for OfferRunnerSource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            OfferRunnerSource::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
            OfferRunnerSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}),
            OfferRunnerSource::Child(child_name) => {
                fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None })
            }
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OfferResolverSource {
    Parent,
    Self_,
    Child(String),
}

impl FidlIntoNative<OfferResolverSource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> OfferResolverSource {
        match self.unwrap() {
            fsys::Ref::Parent(_) => OfferResolverSource::Parent,
            fsys::Ref::Self_(_) => OfferResolverSource::Self_,
            fsys::Ref::Child(c) => OfferResolverSource::Child(c.name),
            _ => panic!("invalid OfferResolverSource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for OfferResolverSource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            OfferResolverSource::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
            OfferResolverSource::Self_ => fsys::Ref::Self_(fsys::SelfRef {}),
            OfferResolverSource::Child(child_name) => {
                fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None })
            }
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum OfferEventSource {
    Framework,
    Parent,
}

impl FidlIntoNative<OfferEventSource> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> OfferEventSource {
        match self.unwrap() {
            fsys::Ref::Framework(_) => OfferEventSource::Framework,
            fsys::Ref::Parent(_) => OfferEventSource::Parent,
            _ => panic!("invalid OfferEventSource variant"),
        }
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for OfferEventSource {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(match self {
            OfferEventSource::Framework => fsys::Ref::Framework(fsys::FrameworkRef {}),
            OfferEventSource::Parent => fsys::Ref::Parent(fsys::ParentRef {}),
        })
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum EventMode {
    Sync,
    Async,
}

impl NativeIntoFidl<Option<fsys::EventMode>> for EventMode {
    fn native_into_fidl(self) -> Option<fsys::EventMode> {
        match self {
            EventMode::Sync => Some(fsys::EventMode::Sync),
            EventMode::Async => Some(fsys::EventMode::Async),
        }
    }
}

impl FidlIntoNative<EventMode> for Option<fsys::EventMode> {
    fn fidl_into_native(self) -> EventMode {
        match self {
            Some(fsys::EventMode::Sync) => EventMode::Sync,
            Some(fsys::EventMode::Async) => EventMode::Async,
            None => panic!("invalid EventMode variant"),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum OfferTarget {
    Child(String),
    Collection(String),
}

impl FidlIntoNative<OfferTarget> for fsys::Ref {
    fn fidl_into_native(self) -> OfferTarget {
        match self {
            fsys::Ref::Child(c) => OfferTarget::Child(c.name),
            fsys::Ref::Collection(c) => OfferTarget::Collection(c.name),
            _ => panic!("invalid OfferTarget variant"),
        }
    }
}

impl NativeIntoFidl<fsys::Ref> for OfferTarget {
    fn native_into_fidl(self) -> fsys::Ref {
        match self {
            OfferTarget::Child(child_name) => {
                fsys::Ref::Child(fsys::ChildRef { name: child_name, collection: None })
            }
            OfferTarget::Collection(collection_name) => {
                fsys::Ref::Collection(fsys::CollectionRef { name: collection_name })
            }
        }
    }
}

impl FidlIntoNative<OfferTarget> for Option<fsys::Ref> {
    fn fidl_into_native(self) -> OfferTarget {
        self.unwrap().fidl_into_native()
    }
}

impl NativeIntoFidl<Option<fsys::Ref>> for OfferTarget {
    fn native_into_fidl(self) -> Option<fsys::Ref> {
        Some(self.native_into_fidl())
    }
}

/// Converts the contents of a CM-FIDL declaration and produces the equivalent CM-Rust
/// struct.
/// This function applies cm_fidl_validator to check correctness.
impl TryFrom<fsys::ComponentDecl> for ComponentDecl {
    type Error = Error;

    fn try_from(decl: fsys::ComponentDecl) -> Result<Self, Self::Error> {
        cm_fidl_validator::validate(&decl).map_err(|err| Error::Validate { err })?;
        Ok(decl.fidl_into_native())
    }
}

// Converts the contents of a CM-Rust declaration into a CM_FIDL declaration
impl TryFrom<ComponentDecl> for fsys::ComponentDecl {
    type Error = Error;
    fn try_from(decl: ComponentDecl) -> Result<Self, Self::Error> {
        Ok(decl.native_into_fidl())
    }
}

/// Errors produced by cm_rust.
#[derive(Debug, Error)]
pub enum Error {
    #[error("Fidl validation failed: {}", err)]
    Validate {
        #[source]
        err: cm_fidl_validator::ErrorList,
    },
    #[error("Invalid capability path: {}", raw)]
    InvalidCapabilityPath { raw: String },
}

#[cfg(test)]
mod tests {
    use {super::*, maplit::hashmap};

    macro_rules! test_try_from_decl {
        (
            $(
                $test_name:ident => {
                    input = $input:expr,
                    result = $result:expr,
                },
            )+
        ) => {
            $(
                #[test]
                fn $test_name() {
                    {
                        let res = ComponentDecl::try_from($input).expect("try_from failed");
                        assert_eq!(res, $result);
                    }
                    {
                        let res = fsys::ComponentDecl::try_from($result).expect("try_from failed");
                        assert_eq!(res, $input);
                    }
                }
            )+
        }
    }

    macro_rules! test_fidl_into_and_from {
        (
            $(
                $test_name:ident => {
                    input = $input:expr,
                    input_type = $input_type:ty,
                    result = $result:expr,
                    result_type = $result_type:ty,
                },
            )+
        ) => {
            $(
                #[test]
                fn $test_name() {
                    {
                        let res: Vec<$result_type> =
                            $input.into_iter().map(|e| e.fidl_into_native()).collect();
                        assert_eq!(res, $result);
                    }
                    {
                        let res: Vec<$input_type> =
                            $result.into_iter().map(|e| e.native_into_fidl()).collect();
                        assert_eq!(res, $input);
                    }
                }
            )+
        }
    }

    macro_rules! test_fidl_into {
        (
            $(
                $test_name:ident => {
                    input = $input:expr,
                    result = $result:expr,
                },
            )+
        ) => {
            $(
                #[test]
                fn $test_name() {
                    test_fidl_into_helper($input, $result);
                }
            )+
        }
    }

    fn test_fidl_into_helper<T, U>(input: T, expected_res: U)
    where
        T: FidlIntoNative<U>,
        U: std::cmp::PartialEq + std::fmt::Debug,
    {
        let res: U = input.fidl_into_native();
        assert_eq!(res, expected_res);
    }

    macro_rules! test_capability_path {
        (
            $(
                $test_name:ident => {
                    input = $input:expr,
                    result = $result:expr,
                },
            )+
        ) => {
            $(
                #[test]
                fn $test_name() {
                    test_capability_path_helper($input, $result);
                }
            )+
        }
    }

    fn test_capability_path_helper(input: &str, result: Result<CapabilityPath, Error>) {
        let res = CapabilityPath::try_from(input);
        assert_eq!(format!("{:?}", res), format!("{:?}", result));
        if let Ok(p) = res {
            assert_eq!(&p.to_string(), input);
        }
    }

    test_try_from_decl! {
        try_from_empty => {
            input = fsys::ComponentDecl {
                program: None,
                uses: None,
                exposes: None,
                offers: None,
                capabilities: None,
                children: None,
                collections: None,
                facets: None,
                environments: None,
                ..fsys::ComponentDecl::EMPTY
            },
            result = ComponentDecl {
                program: None,
                uses: vec![],
                exposes: vec![],
                offers: vec![],
                capabilities: vec![],
                children: vec![],
                collections: vec![],
                facets: None,
                environments: vec![],
            },
        },
        try_from_all => {
            input = fsys::ComponentDecl {
               program: Some(fdata::Dictionary{entries: Some(vec![
                   fdata::DictionaryEntry {
                       key: "args".to_string(),
                       value: Some(Box::new(fdata::DictionaryValue::StrVec(vec!["foo".to_string(), "bar".to_string()]))),
                   },
                   fdata::DictionaryEntry {
                       key: "binary".to_string(),
                       value: Some(Box::new(fdata::DictionaryValue::Str("bin/app".to_string()))),
                   },
               ]), ..fdata::Dictionary::EMPTY}),
               uses: Some(vec![
                   fsys::UseDecl::Service(fsys::UseServiceDecl {
                       source: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       source_name: Some("netstack".to_string()),
                       target_path: Some("/svc/mynetstack".to_string()),
                       ..fsys::UseServiceDecl::EMPTY
                   }),
                   fsys::UseDecl::Protocol(fsys::UseProtocolDecl {
                       source: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       source_name: Some("legacy_netstack".to_string()),
                       target_path: Some("/svc/legacy_mynetstack".to_string()),
                       ..fsys::UseProtocolDecl::EMPTY
                   }),
                   fsys::UseDecl::Directory(fsys::UseDirectoryDecl {
                       source: Some(fsys::Ref::Framework(fsys::FrameworkRef {})),
                       source_name: Some("dir".to_string()),
                       target_path: Some("/data".to_string()),
                       rights: Some(fio2::Operations::Connect),
                       subdir: Some("foo/bar".to_string()),
                       ..fsys::UseDirectoryDecl::EMPTY
                   }),
                   fsys::UseDecl::Storage(fsys::UseStorageDecl {
                       source_name: Some("cache".to_string()),
                       target_path: Some("/cache".to_string()),
                       ..fsys::UseStorageDecl::EMPTY
                   }),
                   fsys::UseDecl::Storage(fsys::UseStorageDecl {
                       source_name: Some("temp".to_string()),
                       target_path: Some("/temp".to_string()),
                       ..fsys::UseStorageDecl::EMPTY
                   }),
                   fsys::UseDecl::Runner(fsys::UseRunnerDecl {
                       source_name: Some("myrunner".to_string()),
                       ..fsys::UseRunnerDecl::EMPTY
                   }),
                   fsys::UseDecl::Event(fsys::UseEventDecl {
                       source: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       source_name: Some("capability_ready".to_string()),
                       target_name: Some("diagnostics_ready".to_string()),
                       filter: Some(fdata::Dictionary{
                           entries: Some(vec![
                              fdata::DictionaryEntry {
                                  key: "path".to_string(),
                                  value: Some(Box::new(fdata::DictionaryValue::Str("/diagnostics".to_string()))),
                              },
                           ]),
                           ..fdata::Dictionary::EMPTY
                       }),
                       mode: Some(fsys::EventMode::Sync),
                       ..fsys::UseEventDecl::EMPTY
                   }),
               ]),
               exposes: Some(vec![
                   fsys::ExposeDecl::Protocol(fsys::ExposeProtocolDecl {
                       source: Some(fsys::Ref::Child(fsys::ChildRef {
                           name: "netstack".to_string(),
                           collection: None,
                       })),
                       source_name: Some("legacy_netstack".to_string()),
                       target_name: Some("legacy_mynetstack".to_string()),
                       target: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       ..fsys::ExposeProtocolDecl::EMPTY
                   }),
                   fsys::ExposeDecl::Directory(fsys::ExposeDirectoryDecl {
                       source: Some(fsys::Ref::Child(fsys::ChildRef {
                           name: "netstack".to_string(),
                           collection: None,
                       })),
                       source_name: Some("dir".to_string()),
                       target_name: Some("data".to_string()),
                       target: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       rights: Some(fio2::Operations::Connect),
                       subdir: Some("foo/bar".to_string()),
                       ..fsys::ExposeDirectoryDecl::EMPTY
                   }),
                   fsys::ExposeDecl::Runner(fsys::ExposeRunnerDecl {
                       source: Some(fsys::Ref::Child(fsys::ChildRef {
                           name: "netstack".to_string(),
                           collection: None,
                       })),
                       source_name: Some("elf".to_string()),
                       target: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       target_name: Some("elf".to_string()),
                       ..fsys::ExposeRunnerDecl::EMPTY
                   }),
                   fsys::ExposeDecl::Resolver(fsys::ExposeResolverDecl{
                       source: Some(fsys::Ref::Child(fsys::ChildRef {
                           name: "netstack".to_string(),
                           collection: None,
                       })),
                       source_name: Some("pkg".to_string()),
                       target: Some(fsys::Ref::Parent(fsys::ParentRef{})),
                       target_name: Some("pkg".to_string()),
                       ..fsys::ExposeResolverDecl::EMPTY
                   }),
                   fsys::ExposeDecl::Service(fsys::ExposeServiceDecl {
                       source: Some(fsys::Ref::Child(fsys::ChildRef {
                           name: "netstack".to_string(),
                           collection: None,
                       })),
                       source_name: Some("netstack1".to_string()),
                       target_name: Some("mynetstack".to_string()),
                       target: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       ..fsys::ExposeServiceDecl::EMPTY
                   }),
                   fsys::ExposeDecl::Service(fsys::ExposeServiceDecl {
                       source: Some(fsys::Ref::Child(fsys::ChildRef {
                           name: "netstack".to_string(),
                           collection: None,
                       })),
                       source_name: Some("netstack2".to_string()),
                       target_name: Some("mynetstack".to_string()),
                       target: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       ..fsys::ExposeServiceDecl::EMPTY
                   }),
               ]),
               offers: Some(vec![
                   fsys::OfferDecl::Protocol(fsys::OfferProtocolDecl {
                       source: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       source_name: Some("legacy_netstack".to_string()),
                       target: Some(fsys::Ref::Child(
                          fsys::ChildRef {
                              name: "echo".to_string(),
                              collection: None,
                          }
                       )),
                       target_name: Some("legacy_mynetstack".to_string()),
                       dependency_type: Some(fsys::DependencyType::WeakForMigration),
                       ..fsys::OfferProtocolDecl::EMPTY
                   }),
                   fsys::OfferDecl::Directory(fsys::OfferDirectoryDecl {
                       source: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       source_name: Some("dir".to_string()),
                       target: Some(fsys::Ref::Collection(
                           fsys::CollectionRef { name: "modular".to_string() }
                       )),
                       target_name: Some("data".to_string()),
                       rights: Some(fio2::Operations::Connect),
                       subdir: None,
                       dependency_type: Some(fsys::DependencyType::Strong),
                       ..fsys::OfferDirectoryDecl::EMPTY
                   }),
                   fsys::OfferDecl::Storage(fsys::OfferStorageDecl {
                       source_name: Some("cache".to_string()),
                       source: Some(fsys::Ref::Self_(fsys::SelfRef {})),
                       target: Some(fsys::Ref::Collection(
                           fsys::CollectionRef { name: "modular".to_string() }
                       )),
                       target_name: Some("cache".to_string()),
                       ..fsys::OfferStorageDecl::EMPTY
                   }),
                   fsys::OfferDecl::Runner(fsys::OfferRunnerDecl {
                       source: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       source_name: Some("elf".to_string()),
                       target: Some(fsys::Ref::Child(
                          fsys::ChildRef {
                              name: "echo".to_string(),
                              collection: None,
                          }
                       )),
                       target_name: Some("elf2".to_string()),
                       ..fsys::OfferRunnerDecl::EMPTY
                   }),
                   fsys::OfferDecl::Resolver(fsys::OfferResolverDecl{
                       source: Some(fsys::Ref::Parent(fsys::ParentRef{})),
                       source_name: Some("pkg".to_string()),
                       target: Some(fsys::Ref::Child(
                          fsys::ChildRef {
                             name: "echo".to_string(),
                             collection: None,
                          }
                       )),
                       target_name: Some("pkg".to_string()),
                       ..fsys::OfferResolverDecl::EMPTY
                   }),
                   fsys::OfferDecl::Event(fsys::OfferEventDecl {
                       source: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       source_name: Some("started".to_string()),
                       target: Some(fsys::Ref::Child(
                          fsys::ChildRef {
                              name: "echo".to_string(),
                              collection: None,
                          }
                       )),
                       target_name: Some("mystarted".to_string()),
                       filter: Some(fdata::Dictionary {
                           entries: Some(vec![
                              fdata::DictionaryEntry {
                                  key: "path".to_string(),
                                  value: Some(Box::new(fdata::DictionaryValue::Str("/a".to_string()))),
                              },
                           ]),
                           ..fdata::Dictionary::EMPTY
                       }),
                       mode: Some(fsys::EventMode::Sync),
                       ..fsys::OfferEventDecl::EMPTY
                   }),
                   fsys::OfferDecl::Service(fsys::OfferServiceDecl {
                       source: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       source_name: Some("netstack1".to_string()),
                       target: Some(fsys::Ref::Child(
                          fsys::ChildRef {
                              name: "echo".to_string(),
                              collection: None,
                          }
                       )),
                       target_name: Some("mynetstack".to_string()),
                       ..fsys::OfferServiceDecl::EMPTY
                   }),
                   fsys::OfferDecl::Service(fsys::OfferServiceDecl {
                       source: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       source_name: Some("netstack2".to_string()),
                       target: Some(fsys::Ref::Child(
                          fsys::ChildRef {
                              name: "echo".to_string(),
                              collection: None,
                          }
                       )),
                       target_name: Some("mynetstack".to_string()),
                       ..fsys::OfferServiceDecl::EMPTY
                   }),
               ]),
               capabilities: Some(vec![
                   fsys::CapabilityDecl::Service(fsys::ServiceDecl {
                       name: Some("netstack".to_string()),
                       source_path: Some("/netstack".to_string()),
                       ..fsys::ServiceDecl::EMPTY
                   }),
                   fsys::CapabilityDecl::Protocol(fsys::ProtocolDecl {
                       name: Some("netstack2".to_string()),
                       source_path: Some("/netstack2".to_string()),
                       ..fsys::ProtocolDecl::EMPTY
                   }),
                   fsys::CapabilityDecl::Directory(fsys::DirectoryDecl {
                       name: Some("data".to_string()),
                       source_path: Some("/data".to_string()),
                       rights: Some(fio2::Operations::Connect),
                       ..fsys::DirectoryDecl::EMPTY
                   }),
                   fsys::CapabilityDecl::Storage(fsys::StorageDecl {
                       name: Some("cache".to_string()),
                       backing_dir: Some("data".to_string()),
                       source: Some(fsys::Ref::Parent(fsys::ParentRef {})),
                       subdir: Some("cache".to_string()),
                       ..fsys::StorageDecl::EMPTY
                   }),
                   fsys::CapabilityDecl::Runner(fsys::RunnerDecl {
                       name: Some("elf".to_string()),
                       source_path: Some("/elf".to_string()),
                       source: Some(fsys::Ref::Self_(fsys::SelfRef {})),
                       ..fsys::RunnerDecl::EMPTY
                   }),
                   fsys::CapabilityDecl::Resolver(fsys::ResolverDecl {
                       name: Some("pkg".to_string()),
                       source_path: Some("/pkg_resolver".to_string()),
                       ..fsys::ResolverDecl::EMPTY
                   }),
               ]),
               children: Some(vec![
                    fsys::ChildDecl {
                        name: Some("netstack".to_string()),
                        url: Some("fuchsia-pkg://fuchsia.com/netstack#meta/netstack.cm"
                                  .to_string()),
                        startup: Some(fsys::StartupMode::Lazy),
                        environment: None,
                        ..fsys::ChildDecl::EMPTY
                    },
                    fsys::ChildDecl {
                        name: Some("gtest".to_string()),
                        url: Some("fuchsia-pkg://fuchsia.com/gtest#meta/gtest.cm".to_string()),
                        startup: Some(fsys::StartupMode::Lazy),
                        environment: None,
                        ..fsys::ChildDecl::EMPTY
                    },
                    fsys::ChildDecl {
                        name: Some("echo".to_string()),
                        url: Some("fuchsia-pkg://fuchsia.com/echo#meta/echo.cm"
                                  .to_string()),
                        startup: Some(fsys::StartupMode::Eager),
                        environment: Some("test_env".to_string()),
                        ..fsys::ChildDecl::EMPTY
                    },
               ]),
               collections: Some(vec![
                    fsys::CollectionDecl {
                        name: Some("modular".to_string()),
                        durability: Some(fsys::Durability::Persistent),
                        environment: None,
                        ..fsys::CollectionDecl::EMPTY
                    },
                    fsys::CollectionDecl {
                        name: Some("tests".to_string()),
                        durability: Some(fsys::Durability::Transient),
                        environment: Some("test_env".to_string()),
                        ..fsys::CollectionDecl::EMPTY
                    },
               ]),
               facets: Some(fsys::Object{entries: vec![
                   fsys::Entry{
                       key: "author".to_string(),
                       value: Some(Box::new(fsys::Value::Str("Fuchsia".to_string()))),
                   },
               ]}),
               environments: Some(vec![
                   fsys::EnvironmentDecl {
                       name: Some("test_env".to_string()),
                       extends: Some(fsys::EnvironmentExtends::Realm),
                       runners: Some(vec![
                           fsys::RunnerRegistration {
                               source_name: Some("runner".to_string()),
                               source: Some(fsys::Ref::Child(fsys::ChildRef {
                                   name: "gtest".to_string(),
                                   collection: None,
                               })),
                               target_name: Some("gtest-runner".to_string()),
                               ..fsys::RunnerRegistration::EMPTY
                           }
                       ]),
                       resolvers: Some(vec![
                           fsys::ResolverRegistration {
                               resolver: Some("pkg_resolver".to_string()),
                               source: Some(fsys::Ref::Parent(fsys::ParentRef{})),
                               scheme: Some("fuchsia-pkg".to_string()),
                               ..fsys::ResolverRegistration::EMPTY
                           }
                       ]),
                       stop_timeout_ms: Some(4567),
                       ..fsys::EnvironmentDecl::EMPTY
                   }
               ]),
                ..fsys::ComponentDecl::EMPTY
            },
            result = {
                ComponentDecl {
                    program: Some(fdata::Dictionary{entries: Some(vec![
                        fdata::DictionaryEntry {
                            key: "args".to_string(),
                            value: Some(Box::new(fdata::DictionaryValue::StrVec(vec!["foo".to_string(), "bar".to_string()]))),
                        },
                        fdata::DictionaryEntry{
                            key: "binary".to_string(),
                            value: Some(Box::new(fdata::DictionaryValue::Str("bin/app".to_string()))),
                        },
                    ]), ..fdata::Dictionary::EMPTY}),
                    uses: vec![
                        UseDecl::Service(UseServiceDecl {
                            source: UseSource::Parent,
                            source_name: "netstack".try_into().unwrap(),
                            target_path: "/svc/mynetstack".try_into().unwrap(),
                        }),
                        UseDecl::Protocol(UseProtocolDecl {
                            source: UseSource::Parent,
                            source_name: "legacy_netstack".try_into().unwrap(),
                            target_path: "/svc/legacy_mynetstack".try_into().unwrap(),
                        }),
                        UseDecl::Directory(UseDirectoryDecl {
                            source: UseSource::Framework,
                            source_name: "dir".try_into().unwrap(),
                            target_path: "/data".try_into().unwrap(),
                            rights: fio2::Operations::Connect,
                            subdir: Some("foo/bar".into()),
                        }),
                        UseDecl::Storage(UseStorageDecl {
                            source_name: "cache".into(),
                            target_path: "/cache".try_into().unwrap(),
                        }),
                        UseDecl::Storage(UseStorageDecl {
                            source_name: "temp".into(),
                            target_path: "/temp".try_into().unwrap(),
                        }),
                        UseDecl::Runner(UseRunnerDecl {
                            source_name: "myrunner".into(),
                        }),
                        UseDecl::Event(UseEventDecl {
                            source: UseSource::Parent,
                            source_name: "capability_ready".into(),
                            target_name: "diagnostics_ready".into(),
                            filter: Some(hashmap!{"path".to_string() =>  DictionaryValue::Str("/diagnostics".to_string())}),
                            mode: EventMode::Sync,
                        })
                    ],
                    exposes: vec![
                        ExposeDecl::Protocol(ExposeProtocolDecl {
                            source: ExposeSource::Child("netstack".to_string()),
                            source_name: "legacy_netstack".try_into().unwrap(),
                            target_name: "legacy_mynetstack".try_into().unwrap(),
                            target: ExposeTarget::Parent,
                        }),
                        ExposeDecl::Directory(ExposeDirectoryDecl {
                            source: ExposeSource::Child("netstack".to_string()),
                            source_name: "dir".try_into().unwrap(),
                            target_name: "data".try_into().unwrap(),
                            target: ExposeTarget::Parent,
                            rights: Some(fio2::Operations::Connect),
                            subdir: Some("foo/bar".into()),
                        }),
                        ExposeDecl::Runner(ExposeRunnerDecl {
                            source: ExposeSource::Child("netstack".to_string()),
                            source_name: "elf".try_into().unwrap(),
                            target: ExposeTarget::Parent,
                            target_name: "elf".try_into().unwrap(),
                        }),
                        ExposeDecl::Resolver(ExposeResolverDecl {
                            source: ExposeSource::Child("netstack".to_string()),
                            source_name: "pkg".try_into().unwrap(),
                            target: ExposeTarget::Parent,
                            target_name: "pkg".try_into().unwrap(),
                        }),
                        ExposeDecl::Service(ExposeServiceDecl {
                            sources: vec![
                                ServiceSource::<ExposeServiceSource> {
                                    source: ExposeServiceSource::Child("netstack".to_string()),
                                    source_name: "netstack1".try_into().unwrap(),
                                },
                                ServiceSource::<ExposeServiceSource> {
                                    source: ExposeServiceSource::Child("netstack".to_string()),
                                    source_name: "netstack2".try_into().unwrap(),
                                },
                            ],
                            target_name: "mynetstack".try_into().unwrap(),
                            target: ExposeTarget::Parent,
                        }),
                    ],
                    offers: vec![
                        OfferDecl::Protocol(OfferProtocolDecl {
                            source: OfferServiceSource::Parent,
                            source_name: "legacy_netstack".try_into().unwrap(),
                            target: OfferTarget::Child("echo".to_string()),
                            target_name: "legacy_mynetstack".try_into().unwrap(),
                            dependency_type: DependencyType::WeakForMigration,
                        }),
                        OfferDecl::Directory(OfferDirectoryDecl {
                            source: OfferDirectorySource::Parent,
                            source_name: "dir".try_into().unwrap(),
                            target: OfferTarget::Collection("modular".to_string()),
                            target_name: "data".try_into().unwrap(),
                            rights: Some(fio2::Operations::Connect),
                            subdir: None,
                            dependency_type: DependencyType::Strong,
                        }),
                        OfferDecl::Storage(OfferStorageDecl {
                            source_name: "cache".try_into().unwrap(),
                            source: OfferStorageSource::Self_,
                            target: OfferTarget::Collection("modular".to_string()),
                            target_name: "cache".try_into().unwrap(),
                        }),
                        OfferDecl::Runner(OfferRunnerDecl {
                            source: OfferRunnerSource::Parent,
                            source_name: "elf".try_into().unwrap(),
                            target: OfferTarget::Child("echo".to_string()),
                            target_name: "elf2".try_into().unwrap(),
                        }),
                        OfferDecl::Resolver(OfferResolverDecl {
                            source: OfferResolverSource::Parent,
                            source_name: "pkg".try_into().unwrap(),
                            target: OfferTarget::Child("echo".to_string()),
                            target_name: "pkg".try_into().unwrap(),
                        }),
                        OfferDecl::Event(OfferEventDecl {
                            source: OfferEventSource::Parent,
                            source_name: "started".into(),
                            target: OfferTarget::Child("echo".to_string()),
                            target_name: "mystarted".into(),
                            filter: Some(hashmap!{"path".to_string() => DictionaryValue::Str("/a".to_string())}),
                            mode: EventMode::Sync,
                        }),
                        OfferDecl::Service(OfferServiceDecl {
                            sources: vec![
                                ServiceSource::<OfferServiceSource> {
                                    source: OfferServiceSource::Parent,
                                    source_name: "netstack1".try_into().unwrap(),
                                },
                                ServiceSource::<OfferServiceSource> {
                                    source: OfferServiceSource::Parent,
                                    source_name: "netstack2".try_into().unwrap(),
                                },
                            ],
                            target: OfferTarget::Child("echo".to_string()),
                            target_name: "mynetstack".try_into().unwrap(),
                        }),
                    ],
                    capabilities: vec![
                        CapabilityDecl::Service(ServiceDecl {
                            name: "netstack".into(),
                            source_path: "/netstack".try_into().unwrap(),
                        }),
                        CapabilityDecl::Protocol(ProtocolDecl {
                            name: "netstack2".into(),
                            source_path: "/netstack2".try_into().unwrap(),
                        }),
                        CapabilityDecl::Directory(DirectoryDecl {
                            name: "data".into(),
                            source_path: "/data".try_into().unwrap(),
                            rights: fio2::Operations::Connect,
                        }),
                        CapabilityDecl::Storage(StorageDecl {
                            name: "cache".into(),
                            backing_dir: "data".try_into().unwrap(),
                            source: StorageDirectorySource::Parent,
                            subdir: Some("cache".try_into().unwrap()),
                        }),
                        CapabilityDecl::Runner(RunnerDecl {
                            name: "elf".into(),
                            source: RunnerSource::Self_,
                            source_path: "/elf".try_into().unwrap(),
                        }),
                        CapabilityDecl::Resolver(ResolverDecl {
                            name: "pkg".into(),
                            source_path: "/pkg_resolver".try_into().unwrap(),
                        }),
                    ],
                    children: vec![
                        ChildDecl {
                            name: "netstack".to_string(),
                            url: "fuchsia-pkg://fuchsia.com/netstack#meta/netstack.cm".to_string(),
                            startup: fsys::StartupMode::Lazy,
                            environment: None,
                        },
                        ChildDecl {
                            name: "gtest".to_string(),
                            url: "fuchsia-pkg://fuchsia.com/gtest#meta/gtest.cm".to_string(),
                            startup: fsys::StartupMode::Lazy,
                            environment: None,
                        },
                        ChildDecl {
                            name: "echo".to_string(),
                            url: "fuchsia-pkg://fuchsia.com/echo#meta/echo.cm".to_string(),
                            startup: fsys::StartupMode::Eager,
                            environment: Some("test_env".to_string()),
                        },
                    ],
                    collections: vec![
                        CollectionDecl {
                            name: "modular".to_string(),
                            durability: fsys::Durability::Persistent,
                            environment: None,
                        },
                        CollectionDecl {
                            name: "tests".to_string(),
                            durability: fsys::Durability::Transient,
                            environment: Some("test_env".to_string()),
                        },
                    ],
                    facets: Some(fsys::Object{entries: vec![
                       fsys::Entry{
                           key: "author".to_string(),
                           value: Some(Box::new(fsys::Value::Str("Fuchsia".to_string()))),
                       },
                    ]}),
                    environments: vec![
                        EnvironmentDecl {
                            name: "test_env".into(),
                            extends: fsys::EnvironmentExtends::Realm,
                            runners: vec![
                                RunnerRegistration {
                                    source_name: "runner".into(),
                                    source: RegistrationSource::Child("gtest".to_string()),
                                    target_name: "gtest-runner".into(),
                                }
                            ],
                            resolvers: vec![
                                ResolverRegistration {
                                    resolver: "pkg_resolver".into(),
                                    source: RegistrationSource::Parent,
                                    scheme: "fuchsia-pkg".to_string(),
                                }
                            ],
                            stop_timeout_ms: Some(4567),
                        }
                    ]
                }
            },
        },
    }

    test_capability_path! {
        capability_path_one_part => {
            input = "/foo",
            result = Ok(CapabilityPath{dirname: "/".to_string(), basename: "foo".to_string()}),
        },
        capability_path_two_parts => {
            input = "/foo/bar",
            result = Ok(CapabilityPath{dirname: "/foo".to_string(), basename: "bar".to_string()}),
        },
        capability_path_many_parts => {
            input = "/foo/bar/long/path",
            result = Ok(CapabilityPath{
                dirname: "/foo/bar/long".to_string(),
                basename: "path".to_string()
            }),
        },
        capability_path_invalid_empty_part => {
            input = "/foo/bar//long/path",
            result = Err(Error::InvalidCapabilityPath{raw: "/foo/bar//long/path".to_string()}),
        },
        capability_path_invalid_empty => {
            input = "",
            result = Err(Error::InvalidCapabilityPath{raw: "".to_string()}),
        },
        capability_path_invalid_root => {
            input = "/",
            result = Err(Error::InvalidCapabilityPath{raw: "/".to_string()}),
        },
        capability_path_invalid_relative => {
            input = "foo/bar",
            result = Err(Error::InvalidCapabilityPath{raw: "foo/bar".to_string()}),
        },
        capability_path_invalid_trailing => {
            input = "/foo/bar/",
            result = Err(Error::InvalidCapabilityPath{raw: "/foo/bar/".to_string()}),
        },
    }

    test_fidl_into_and_from! {
        fidl_into_and_from_expose_source => {
            input = vec![
                Some(fsys::Ref::Self_(fsys::SelfRef {})),
                Some(fsys::Ref::Child(fsys::ChildRef {
                    name: "foo".to_string(),
                    collection: None,
                })),
                Some(fsys::Ref::Framework(fsys::FrameworkRef {})),
            ],
            input_type = Option<fsys::Ref>,
            result = vec![
                ExposeSource::Self_,
                ExposeSource::Child("foo".to_string()),
                ExposeSource::Framework,
            ],
            result_type = ExposeSource,
        },
        fidl_into_and_from_offer_service_source => {
            input = vec![
                Some(fsys::Ref::Parent(fsys::ParentRef {})),
                Some(fsys::Ref::Self_(fsys::SelfRef {})),
                Some(fsys::Ref::Child(fsys::ChildRef {
                    name: "foo".to_string(),
                    collection: None,
                })),
            ],
            input_type = Option<fsys::Ref>,
            result = vec![
                OfferServiceSource::Parent,
                OfferServiceSource::Self_,
                OfferServiceSource::Child("foo".to_string()),
            ],
            result_type = OfferServiceSource,
        },
        fidl_into_and_from_offer_event_source => {
            input = vec![Some(fsys::Ref::Parent(fsys::ParentRef {}))],
            input_type = Option<fsys::Ref>,
            result = vec![OfferEventSource::Parent],
            result_type = OfferEventSource,
        },
        fidl_into_and_from_offer_directory_source => {
            input = vec![
                Some(fsys::Ref::Parent(fsys::ParentRef {})),
                Some(fsys::Ref::Self_(fsys::SelfRef {})),
                Some(fsys::Ref::Framework(fsys::FrameworkRef {})),
                Some(fsys::Ref::Child(fsys::ChildRef {
                    name: "foo".to_string(),
                    collection: None,
                })),
            ],
            input_type = Option<fsys::Ref>,
            result = vec![
                OfferDirectorySource::Parent,
                OfferDirectorySource::Self_,
                OfferDirectorySource::Framework,
                OfferDirectorySource::Child("foo".to_string()),
            ],
            result_type = OfferDirectorySource,
        },
        fidl_into_and_from_offer_storage_source => {
            input = vec![
                Some(fsys::Ref::Parent(fsys::ParentRef {})),
                Some(fsys::Ref::Self_(fsys::SelfRef {})),
            ],
            input_type = Option<fsys::Ref>,
            result = vec![
                OfferStorageSource::Parent,
                OfferStorageSource::Self_,
            ],
            result_type = OfferStorageSource,
        },
        fidl_into_and_from_storage_capability => {
            input = vec![
                fsys::StorageDecl {
                    name: Some("minfs".to_string()),
                    backing_dir: Some("minfs".into()),
                    source: Some(fsys::Ref::Child(fsys::ChildRef {
                        name: "foo".to_string(),
                        collection: None,
                    })),
                    subdir: None,
                    ..fsys::StorageDecl::EMPTY
                },
            ],
            input_type = fsys::StorageDecl,
            result = vec![
                StorageDecl {
                    name: "minfs".into(),
                    backing_dir: "minfs".into(),
                    source: StorageDirectorySource::Child("foo".to_string()),
                    subdir: None,
                },
            ],
            result_type = StorageDecl,
        },
    }

    test_fidl_into! {
        fidl_into_object => {
            input = {
                let obj_inner = fsys::Object{entries: vec![
                    fsys::Entry{
                        key: "string".to_string(),
                        value: Some(Box::new(fsys::Value::Str("bar".to_string()))),
                    },
                ]};
                let vector = fsys::Vector{values: vec![
                    Some(Box::new(fsys::Value::Obj(obj_inner))),
                    Some(Box::new(fsys::Value::Inum(-42)))
                ]};
                let obj_outer = fsys::Object{entries: vec![
                    fsys::Entry{
                        key: "array".to_string(),
                        value: Some(Box::new(fsys::Value::Vec(vector))),
                    },
                ]};
                let obj = fsys::Object {entries: vec![
                    fsys::Entry {
                        key: "bool".to_string(),
                        value: Some(Box::new(fsys::Value::Bit(true))),
                    },
                    fsys::Entry {
                        key: "obj".to_string(),
                        value: Some(Box::new(fsys::Value::Obj(obj_outer))),
                    },
                    fsys::Entry {
                        key: "float".to_string(),
                        value: Some(Box::new(fsys::Value::Fnum(3.14))),
                    },
                    fsys::Entry {
                        key: "int".to_string(),
                        value: Some(Box::new(fsys::Value::Inum(-42))),
                    },
                    fsys::Entry {
                        key: "null".to_string(),
                        value: None,
                    },
                    fsys::Entry {
                        key: "string".to_string(),
                        value: Some(Box::new(fsys::Value::Str("bar".to_string()))),
                    },
                ]};
                Some(obj)
            },
            result = {
                let mut obj_inner = HashMap::new();
                obj_inner.insert("string".to_string(), Value::Str("bar".to_string()));
                let mut obj_outer = HashMap::new();
                let vector = vec![Value::Obj(obj_inner), Value::Inum(-42)];
                obj_outer.insert("array".to_string(), Value::Vec(vector));

                let mut obj: HashMap<String, Value> = HashMap::new();
                obj.insert("bool".to_string(), Value::Bit(true));
                obj.insert("float".to_string(), Value::Fnum(3.14));
                obj.insert("int".to_string(), Value::Inum(-42));
                obj.insert("string".to_string(), Value::Str("bar".to_string()));
                obj.insert("obj".to_string(), Value::Obj(obj_outer));
                obj.insert("null".to_string(), Value::Null);
                Some(obj)
            },
        },
    }
}