// Copyright 2018 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 {
    super::{
        asset::{AssetCollectionBuilder, AssetLoader, AssetLoaderImpl},
        family::{FamilyOrAliasBuilder, FontFamilyBuilder},
        inspect::ServiceInspectData,
        typeface::{Typeface, TypefaceCollectionBuilder, TypefaceId},
        FontService,
    },
    anyhow::{format_err, Error},
    font_info::FontInfoLoaderImpl,
    fuchsia_inspect as finspect,
    fuchsia_syslog::fx_vlog,
    fuchsia_trace as trace,
    manifest::{v2, FontManifestWrapper, FontsManifest},
    std::{
        collections::BTreeMap,
        convert::TryFrom,
        fmt::{self, Display},
        path::{Path, PathBuf},
        sync::Arc,
    },
    thiserror::Error,
    unicase::UniCase,
};

/// Builder for [`FontService`]. Allows populating the fields that remain immutable for the
/// lifetime of the service.
///
/// Create a new builder with [`new()`](FontServiceBuilder::new), then populate using
/// [`load_manifest()`](FontServiceBuilder::load_manifest), and finally construct a `FontService`
/// using [`build()`](FontServiceBuilder::build).
#[derive(Debug)]
pub struct FontServiceBuilder<'a, L>
where
    L: AssetLoader,
{
    manifests: Vec<ManifestOrPath>,
    assets: AssetCollectionBuilder<L>,
    /// Maps the font family name from the manifest (`families.family`) to a FamilyOrAlias.
    families: BTreeMap<UniCase<String>, FamilyOrAliasBuilder>,
    fallback_collection: TypefaceCollectionBuilder,
    inspect_root: &'a finspect::Node,
}

impl<'a> FontServiceBuilder<'a, AssetLoaderImpl> {
    /// Creates a new, empty builder with a real asset loader.
    pub fn with_default_asset_loader(
        cache_capacity_bytes: u64,
        inspect_root: &'a finspect::Node,
    ) -> FontServiceBuilder<'a, AssetLoaderImpl> {
        FontServiceBuilder::<'a, AssetLoaderImpl>::new(
            AssetLoaderImpl::new(),
            cache_capacity_bytes,
            inspect_root,
        )
    }
}

impl<'a, L> FontServiceBuilder<'a, L>
where
    L: AssetLoader,
{
    /// Creates a new, empty builder.
    pub fn new(
        asset_loader: L,
        default_cache_capacity_bytes: u64,
        inspect_root: &'a finspect::Node,
    ) -> FontServiceBuilder<'a, L> {
        FontServiceBuilder {
            manifests: vec![],
            assets: AssetCollectionBuilder::new(asset_loader, default_cache_capacity_bytes, inspect_root),
            families: BTreeMap::new(),
            fallback_collection: TypefaceCollectionBuilder::new(),
            inspect_root,
        }
    }

    /// Add a manifest path to be parsed and processed.
    pub fn add_manifest_from_file(&mut self, manifest_path: &Path) -> &mut Self {
        self.manifests.push(ManifestOrPath::Path(manifest_path.to_path_buf()));
        self
    }

    /// Adds a parsed manifest to be processed.
    #[allow(dead_code)]
    #[cfg(test)]
    pub fn add_manifest(&mut self, manifest_wrapper: FontManifestWrapper) -> &mut Self {
        self.manifests.push(ManifestOrPath::Manifest(manifest_wrapper));
        self
    }

    /// Tries to build a [`FontService`] from the provided manifests, with some additional error
    /// checking.
    pub async fn build(mut self) -> Result<FontService<L>, Error> {
        let manifest_paths = self.manifests.iter().map(ManifestOrPath::to_string).collect();
        let manifests: Result<Vec<(FontManifestWrapper, Option<PathBuf>)>, Error> = self
            .manifests
            .drain(..)
            .map(|manifest_or_path| match manifest_or_path {
                ManifestOrPath::Manifest(manifest) => Ok((manifest, None)),
                ManifestOrPath::Path(path) => {
                    fx_vlog!(1, "Loading manifest {:?}", &path);
                    Ok((FontsManifest::load_from_file(&path)?, Some(path)))
                }
            })
            .collect();

        let mut cache_size_bytes: Option<u64> = None;

        for (wrapper, path) in manifests? {
            match wrapper {
                FontManifestWrapper::Version1(v1) => {
                    self.add_fonts_from_manifest_v1(v1, path).await?
                }
                FontManifestWrapper::Version2(v2) => {
                    // Update the cache size from the first manifest that has it. (In production use
                    // cases, there will only be one manifest.)
                    if v2.settings.cache_size_bytes.is_some() && cache_size_bytes.is_none() {
                        cache_size_bytes = v2.settings.cache_size_bytes.clone();
                    }
                    self.add_fonts_from_manifest_v2(v2, path).await?
                }
            }
        }

        if let Some(cache_size_bytes) = cache_size_bytes {
            self.assets.set_cache_capacity(cache_size_bytes);
        }

        // It's fine to have no fallback collection IFF we loaded an empty manifest.
        if self.fallback_collection.is_empty() && !self.families.is_empty() {
            return Err(FontServiceBuilderError::NoFallbackCollection.into());
        }

        let assets = self.assets.build();
        let families = self.families.into_iter().map(|(key, value)| (key, value.build())).collect();
        let fallback_collection = self.fallback_collection.build();

        let inspect_data = ServiceInspectData::new(
            self.inspect_root,
            manifest_paths,
            &assets,
            &families,
            &fallback_collection,
        );

        Ok(FontService { assets, families, fallback_collection, inspect_data })
    }

    async fn add_fonts_from_manifest_v2(
        &mut self,
        manifest: v2::FontsManifest,
        manifest_path: Option<PathBuf>,
    ) -> Result<(), Error> {
        // Hold on to the typefaces defined in this manifest so that they can be referenced when
        // building the fallback chain.
        let mut manifest_typefaces: BTreeMap<TypefaceId, Arc<Typeface>> = BTreeMap::new();

        for mut manifest_family in manifest.families {
            // Register the family itself
            let family_name = UniCase::new(manifest_family.name.clone());
            let family = match self.families.entry(family_name.clone()).or_insert_with(|| {
                FamilyOrAliasBuilder::Family(FontFamilyBuilder::new(
                    family_name.to_string(),
                    manifest_family.generic_family,
                ))
            }) {
                FamilyOrAliasBuilder::Family(f) => f,
                FamilyOrAliasBuilder::Alias(_, _) => {
                    return Err(FontServiceBuilderError::AliasFamilyConflict {
                        conflicting_name: family_name.to_string(),
                        manifest_path: manifest_path.clone(),
                    }
                    .into());
                }
            };

            // Register the family's assets and their typefaces.

            // We have to use `.drain()` here (instead of moving `assets` out) in order to leave
            // `manifest_family` in a valid state to be able to keep using it further down.
            for manifest_asset in manifest_family.assets.drain(..) {
                let asset_id = self.assets.add_or_get_asset_id(&manifest_asset);
                for manifest_typeface in manifest_asset.typefaces {
                    if manifest_typeface.code_points.is_empty() {
                        return Err(FontServiceBuilderError::NoCodePoints {
                            asset_name: manifest_asset.file_name.to_string(),
                            typeface_idx: manifest_typeface.index,
                            manifest_path: manifest_path.clone(),
                        }
                        .into());
                    }
                    let generic_family = manifest_family.generic_family;
                    let typeface_id = TypefaceId { asset_id, index: manifest_typeface.index };
                    // Deduplicate typefaces across multiple manifests
                    if !family.has_typeface_id(&typeface_id) {
                        // .unwrap() because we already checked for missing code points above
                        let typeface = Arc::new(
                            Typeface::new(asset_id, manifest_typeface, generic_family).unwrap(),
                        );
                        manifest_typefaces.insert(typeface_id, typeface.clone());
                        family.add_typeface_once(typeface);
                    }
                }
            }

            // Above, we're working with `family` mutably borrowed from `self.families`. We have to
            // finish using any mutable references to `self.families` before we can create further
            // references to `self.families` below.

            // Register aliases
            let aliases = FamilyOrAliasBuilder::aliases_from_family(&manifest_family);
            for (key, value) in aliases {
                match self.families.get(&key) {
                    None => {
                        self.families.insert(key, value);
                    }
                    Some(FamilyOrAliasBuilder::Family(_)) => {
                        return Err(FontServiceBuilderError::AliasFamilyConflict {
                            conflicting_name: key.to_string(),
                            manifest_path: manifest_path.clone(),
                        }
                        .into());
                    }
                    Some(FamilyOrAliasBuilder::Alias(other_family_name, _)) => {
                        // If the alias exists then it must be for the same font family.
                        if *other_family_name != family_name {
                            return Err(FontServiceBuilderError::AmbiguousAlias {
                                alias: key.to_string(),
                                canonical_1: other_family_name.to_string(),
                                canonical_2: family_name.to_string(),
                                manifest_path: manifest_path.clone(),
                            }
                            .into());
                        }
                    }
                }
            }
        }

        // We add all the fallback typefaces, preserving their order from the product font
        // configuration file.
        //
        // Unfortunately, when there are multiple manifests with fallback chains, the best we can
        // do is concatenate the fallback chains (with de-duplication). Multiple manifests are not
        // expected in production use cases, so this isn't as awful as it sounds.
        for fallback_typeface in &manifest.fallback_chain {
            let asset_id = self
                .assets
                .get_asset_id_by_name(&fallback_typeface.file_name)
                .ok_or_else(|| FontServiceBuilderError::UnknownFallbackEntry {
                    file_name: fallback_typeface.file_name.clone(),
                    index: fallback_typeface.index,
                    manifest_path: manifest_path.clone(),
                })?;

            let typeface_id = TypefaceId { asset_id, index: fallback_typeface.index };
            if !self.fallback_collection.has_typeface_id(&typeface_id) {
                let typeface = manifest_typefaces
                    .get(&typeface_id)
                    .expect("Invalid state in FontServiceBuilder")
                    .clone();
                self.fallback_collection.add_typeface_once(typeface);
            }
        }

        Ok(())
    }

    async fn add_fonts_from_manifest_v1(
        &mut self,
        manifest_v1: FontsManifest,
        manifest_path: Option<PathBuf>,
    ) -> Result<(), Error> {
        let path_string: String = manifest_path
            .as_ref()
            .map(|path| path.to_string_lossy().to_string())
            .unwrap_or_default();
        trace::duration!(
                "fonts",
                "font_service:builder:add_fonts_from_manifest_v2",
                "path" => &path_string[..]);
        let manifest_v2 = self.convert_manifest_v1_to_v2(manifest_v1).await.map_err(|e| {
            FontServiceBuilderError::ConversionFromV1 {
                manifest_path: manifest_path.clone(),
                cause: e.into(),
            }
        })?;
        self.add_fonts_from_manifest_v2(manifest_v2, manifest_path).await
    }

    /// Converts data format from manifest v1 to v2 and loads character sets for any typefaces that
    /// lack them.
    async fn convert_manifest_v1_to_v2(
        &self,
        manifest_v1: FontsManifest,
    ) -> Result<v2::FontsManifest, Error> {
        let mut manifest_v2 = v2::FontsManifest::try_from(manifest_v1)?;
        let asset_loader = AssetLoaderImpl::new();
        let font_info_loader = FontInfoLoaderImpl::new()?;

        for manifest_family in &mut manifest_v2.families {
            for manifest_asset in &mut manifest_family.assets {
                for manifest_typeface in &mut manifest_asset.typefaces {
                    if manifest_typeface.code_points.is_empty() {
                        match &manifest_asset.location {
                            v2::AssetLocation::LocalFile(v2::LocalFileLocator { directory }) => {
                                let asset_path = directory.join(&manifest_asset.file_name);
                                let buffer = asset_loader.load_vmo_from_path(&asset_path)?;
                                let font_info = {
                                    trace::duration!("fonts", "FontInfoLoaderImpl:load_font_info");
                                    font_info_loader
                                        .load_font_info(buffer, manifest_typeface.index)?
                                };
                                manifest_typeface.code_points = font_info.char_set;
                            }
                            _ => {
                                return Err(format_err!(
                                    "Impossible asset location: {:?}",
                                    &manifest_asset
                                ));
                            }
                        }
                    }
                }
            }
        }

        Ok(manifest_v2)
    }
}

#[allow(dead_code)]
#[derive(Debug)]
enum ManifestOrPath {
    Manifest(FontManifestWrapper),
    Path(PathBuf),
}

impl Display for ManifestOrPath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ManifestOrPath::Manifest(_manifest) => write!(f, "{}", "FontManifestWrapper {{ ... }}"),
            ManifestOrPath::Path(path) => write!(f, "{}", path.to_string_lossy().to_string()),
        }
    }
}

/// Errors arising from the use of [`FontServiceBuilder`].
#[derive(Debug, Error)]
pub enum FontServiceBuilderError {
    /// A name was used as both a canonical family name and a font family alias.
    #[error(
        "Conflict in {:?}: {} cannot be both a canonical family name and an alias",
        manifest_path,
        conflicting_name
    )]
    AliasFamilyConflict { conflicting_name: String, manifest_path: Option<PathBuf> },

    /// One string was used as an alias for two different font families.
    #[error(
        "Conflict in {:?}: {} cannot be an alias for both {} and {}",
        manifest_path,
        alias,
        canonical_1,
        canonical_2
    )]
    AmbiguousAlias {
        alias: String,
        canonical_1: String,
        canonical_2: String,
        manifest_path: Option<PathBuf>,
    },

    /// Something went wrong when converting a manifest from v1 to v2.
    #[error("Conversion from manifest v1 failed in {:?}: {:?}", manifest_path, cause)]
    ConversionFromV1 {
        manifest_path: Option<PathBuf>,
        #[source]
        cause: Error,
    },

    /// The font manifest's fallback chain referenced an undeclared typeface.
    #[error(
        "Unknown typeface in fallback chain in {:?}: file name \'{}\', index {}",
        manifest_path,
        file_name,
        index
    )]
    UnknownFallbackEntry { file_name: String, index: u32, manifest_path: Option<PathBuf> },

    /// None of the loaded manifests contained a non-empty fallback chain.
    #[error("Need at least one fallback font family")]
    NoFallbackCollection,

    /// The manifest did not have defined code points for a particular typeface.
    #[error("Missing code points for \"{}\"[{}] in {:?}", asset_name, typeface_idx, manifest_path)]
    NoCodePoints { asset_name: String, typeface_idx: u32, manifest_path: Option<PathBuf> },
}

#[cfg(test)]
mod tests {
    use {
        super::*,
        crate::font_service::{
            family::{FamilyOrAlias, FontFamily},
            typeface::Collection as TypefaceCollection,
            AssetId,
        },
        char_set::CharSet,
        fidl_fuchsia_fonts::{GenericFontFamily, Slant, Width, WEIGHT_BOLD, WEIGHT_NORMAL},
        manifest::{serde_ext::StyleOptions, v2},
        maplit::{btreemap, btreeset},
        pretty_assertions::assert_eq,
        std::sync::Arc,
        unicase::UniCase,
    };

    #[fuchsia_async::run_singlethreaded(test)]
    async fn test_multiple_overlapping_manifests() -> Result<(), Error> {
        let inspector = finspect::Inspector::new();
        let mut builder = FontServiceBuilder::with_default_asset_loader(5000, inspector.root());
        builder
            .add_manifest(FontManifestWrapper::Version2(v2::FontsManifest {
                families: vec![v2::Family {
                    name: "Alpha".to_string(),
                    aliases: vec![v2::FontFamilyAliasSet::without_overrides(vec![
                        "A", "Aleph", "Alif",
                    ])?],
                    generic_family: Some(GenericFontFamily::SansSerif),
                    assets: vec![
                        v2::Asset {
                            file_name: "Alpha-Regular.ttf".to_string(),
                            location: v2::AssetLocation::LocalFile(v2::LocalFileLocator {
                                directory: PathBuf::from("/pkg/config/data/assets"),
                            }),
                            typefaces: vec![v2::Typeface {
                                index: 0,
                                languages: vec!["en".to_string()],
                                style: v2::Style {
                                    slant: Slant::Upright,
                                    weight: WEIGHT_NORMAL,
                                    width: Width::Normal,
                                },
                                code_points: CharSet::new(vec![0x1, 0x2, 0x3]),
                            }],
                        },
                        v2::Asset {
                            file_name: "Alpha-Bold.ttf".to_string(),
                            location: v2::AssetLocation::LocalFile(v2::LocalFileLocator {
                                directory: PathBuf::from("/pkg/config/data/assets"),
                            }),
                            typefaces: vec![v2::Typeface {
                                index: 0,
                                languages: vec!["en".to_string()],
                                style: v2::Style {
                                    slant: Slant::Upright,
                                    weight: WEIGHT_BOLD,
                                    width: Width::Normal,
                                },
                                code_points: CharSet::new(vec![0x1, 0x2, 0x3]),
                            }],
                        },
                    ],
                }],
                fallback_chain: vec![
                    v2::TypefaceId { file_name: "Alpha-Bold.ttf".to_string(), index: 0 },
                    v2::TypefaceId { file_name: "Alpha-Regular.ttf".to_string(), index: 0 },
                ],
                settings: v2::Settings { cache_size_bytes: Some(12345) },
            }))
            .add_manifest(FontManifestWrapper::Version2(v2::FontsManifest {
                families: vec![v2::Family {
                    name: "Alpha".to_string(),
                    aliases: vec![
                        v2::FontFamilyAliasSet::without_overrides(vec![
                            "A",
                            "Aleph",
                            "Alpha Ordinary",
                        ])?,
                        // Note different languages in second manifest's "Alif" alias
                        v2::FontFamilyAliasSet::new(
                            vec!["Alif"],
                            StyleOptions::default(),
                            vec!["en", "ar"],
                        )?,
                    ],
                    generic_family: Some(GenericFontFamily::SansSerif),
                    assets: vec![v2::Asset {
                        file_name: "Alpha-Regular.ttf".to_string(),
                        location: v2::AssetLocation::LocalFile(v2::LocalFileLocator {
                            directory: PathBuf::from("/pkg/config/data/assets"),
                        }),
                        typefaces: vec![v2::Typeface {
                            index: 0,
                            languages: vec!["en".to_string()],
                            style: v2::Style {
                                slant: Slant::Upright,
                                weight: WEIGHT_NORMAL,
                                width: Width::Expanded, // Note difference
                            },
                            code_points: CharSet::new(vec![0x1, 0x2, 0x3]),
                        }],
                    }],
                }],
                fallback_chain: vec![v2::TypefaceId {
                    file_name: "Alpha-Regular.ttf".to_string(),
                    index: 0,
                }],
                settings: v2::Settings { cache_size_bytes: Some(99999) },
            }));

        let service = builder.build().await?;

        let expected_typeface_regular = Arc::new(Typeface {
            asset_id: AssetId(0),
            font_index: 0,
            slant: Slant::Upright,
            weight: WEIGHT_NORMAL,
            width: Width::Normal, // First version wins
            languages: btreeset!["en".to_string()],
            char_set: CharSet::new(vec![0x1, 0x2, 0x3]),
            generic_family: Some(GenericFontFamily::SansSerif),
        });

        let expected_typeface_bold = Arc::new(Typeface {
            asset_id: AssetId(1),
            font_index: 0,
            slant: Slant::Upright,
            weight: WEIGHT_BOLD,
            width: Width::Normal,
            languages: btreeset!["en".to_string()],
            char_set: CharSet::new(vec![0x1, 0x2, 0x3]),
            generic_family: Some(GenericFontFamily::SansSerif),
        });

        assert_eq!(
            service.families,
            btreemap!(
            UniCase::new("Alpha".to_string()) =>
                FamilyOrAlias::Family(FontFamily {
                    name: "Alpha".to_string(),
                    faces: TypefaceCollection {
                        faces: vec![
                            expected_typeface_regular.clone(),
                            expected_typeface_bold.clone()
                        ]
                    },
                    generic_family: Some(GenericFontFamily::SansSerif)
            }),
            UniCase::new("A".to_string()) =>
                FamilyOrAlias::Alias(UniCase::new("Alpha".to_string()), None),
            UniCase::new("Aleph".to_string()) =>
                FamilyOrAlias::Alias(UniCase::new("Alpha".to_string()), None),
            // First version of "Alif" wins
            UniCase::new("Alif".to_string()) =>
                FamilyOrAlias::Alias(UniCase::new("Alpha".to_string()), None),
            UniCase::new("Alpha Ordinary".to_string()) =>
                FamilyOrAlias::Alias(UniCase::new("Alpha".to_string()), None),
            UniCase::new("AlphaOrdinary".to_string()) =>
                FamilyOrAlias::Alias(UniCase::new("Alpha".to_string()), None),)
        );

        assert_eq!(service.assets.len(), 2);

        assert_eq!(
            service.fallback_collection,
            TypefaceCollection {
                faces: vec![expected_typeface_bold.clone(), expected_typeface_regular.clone()]
            }
        );

        assert_eq!(service.assets.cache_capacity_bytes().await, 12345);

        Ok(())
    }

    #[fuchsia_async::run_singlethreaded(test)]
    async fn test_empty_manifest() -> Result<(), Error> {
        let inspector = finspect::Inspector::new();
        let manifest = FontManifestWrapper::Version2(v2::FontsManifest::empty());
        let mut builder = FontServiceBuilder::with_default_asset_loader(5000, inspector.root());
        builder.add_manifest(manifest);
        builder.build().await?; // Should succeed
        Ok(())
    }
}