// Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use {
    crate::font_service::{inspect::zero_pad, AssetId},
    anyhow::{format_err, Error},
    char_set::CharSet,
    fidl_fuchsia_fonts::{FamilyName, GenericFontFamily, Slant, Style2, TypefaceRequest, Width},
    fidl_fuchsia_fonts_experimental::TypefaceInfo,
    fidl_fuchsia_intl::LocaleId,
    fuchsia_inspect as finspect,
    heck::KebabCase,
    itertools::Itertools,
    manifest::v2,
    std::collections::BTreeSet,
};

/// Asset ID and font index.
#[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
pub struct TypefaceId {
    /// In-memory ID of the font asset.
    pub asset_id: AssetId,
    /// Index of the typeface within the asset.
    pub index: u32,
}

/// In-memory representation of a single typeface's metadata, slightly denormalized.
#[derive(Debug, Eq, PartialEq, Hash)]
pub struct Typeface {
    /// Which asset to find the typeface in
    pub asset_id: AssetId,
    /// Index of the typeface within the asset (for multi-typeface font formats, such as TTC)
    pub font_index: u32,
    /// Style property: slant
    pub slant: Slant,
    /// Style property: weight
    pub weight: u16,
    /// Style property: width
    pub width: Width,
    /// List of BCP-47 language IDs explicitly supported by the typeface
    pub languages: BTreeSet<String>,
    /// Collection of code points contained by the typeface
    pub char_set: CharSet,
    /// A generic font family to which the typeface's family belongs.
    pub generic_family: Option<GenericFontFamily>,
}

impl Typeface {
    /// Create a new `Typeface`, copying all fields except `asset_id` and `generic_family` from
    /// `manifest_typeface`.
    pub fn new(
        asset_id: AssetId,
        manifest_typeface: v2::Typeface,
        generic_family: Option<GenericFontFamily>,
    ) -> Result<Typeface, Error> {
        if manifest_typeface.code_points.is_empty() {
            return Err(format_err!("Can't create Typeface from Font with empty CharSet."));
        }
        Ok(Typeface {
            asset_id,
            font_index: manifest_typeface.index,
            weight: manifest_typeface.style.weight,
            width: manifest_typeface.style.width,
            slant: manifest_typeface.style.slant,
            languages: manifest_typeface.languages.into_iter().collect(),
            char_set: manifest_typeface.code_points,
            generic_family,
        })
    }

    /// Returns value in the range `[0, 2 * request_languages.len()]`. The language code is used for
    /// exact matches; the rest is for partial matches.
    ///
    /// TODO(kpozin): Use a standard locale matching algorithm.
    fn get_lang_match_score(&self, request_languages: &[LocaleId]) -> usize {
        let mut best_partial_match_pos = None;
        for i in 0..request_languages.len() {
            let lang = &request_languages[i].id;

            // Iterate over all languages in the typeface that start with `lang`.
            for typeface_lang in
                self.languages.range::<String, std::ops::RangeFrom<&String>>(lang..)
            {
                if !typeface_lang.starts_with(lang.as_str()) {
                    break;
                }

                if typeface_lang.len() == lang.len() {
                    // Exact match.
                    return i;
                }

                // Partial match is valid only when it's followed by '-' character.
                if (typeface_lang.as_bytes()[lang.len()] == '-' as u8)
                    & best_partial_match_pos.is_none()
                {
                    best_partial_match_pos = Some(i);
                    continue;
                }
            }
        }

        best_partial_match_pos.unwrap_or(request_languages.len()) + request_languages.len()
    }
}

#[derive(Debug)]
pub struct TypefaceAndLangScore<'a> {
    pub typeface: &'a Typeface,
    pub lang_score: usize,
}

impl<'a> TypefaceAndLangScore<'a> {
    pub fn new(typeface: &'a Typeface, request: &TypefaceRequest) -> TypefaceAndLangScore<'a> {
        let request_languages: Vec<LocaleId> =
            match request.query.as_ref().and_then(|query| query.languages.as_ref()) {
                Some(languages) => languages.iter().map(LocaleId::clone).collect(),
                _ => vec![],
            };
        let lang_score = typeface.get_lang_match_score(&request_languages);
        TypefaceAndLangScore { typeface, lang_score }
    }
}

pub struct TypefaceInfoAndCharSet {
    pub asset_id: AssetId,
    pub font_index: u32,
    pub family: FamilyName,
    pub style: Style2,
    pub languages: Vec<LocaleId>,
    pub generic_family: Option<GenericFontFamily>,
    pub char_set: CharSet,
}

impl TypefaceInfoAndCharSet {
    pub fn from_typeface(typeface: &Typeface, canonical_family: String) -> TypefaceInfoAndCharSet {
        TypefaceInfoAndCharSet {
            asset_id: typeface.asset_id,
            font_index: typeface.font_index,
            family: FamilyName { name: canonical_family },
            style: Style2 {
                slant: Some(typeface.slant),
                weight: Some(typeface.weight),
                width: Some(typeface.width),
                ..Style2::EMPTY
            },
            // Convert BTreeSet<String> to Vec<LocaleId>
            languages: typeface
                .languages
                .iter()
                .map(|lang| LocaleId { id: lang.clone() })
                .collect(),
            generic_family: typeface.generic_family,
            char_set: typeface.char_set.clone(),
        }
    }
}

impl From<TypefaceInfoAndCharSet> for TypefaceInfo {
    fn from(info: TypefaceInfoAndCharSet) -> TypefaceInfo {
        TypefaceInfo {
            asset_id: Some(info.asset_id.into()),
            font_index: Some(info.font_index),
            family: Some(info.family),
            style: Some(info.style),
            languages: Some(info.languages),
            generic_family: info.generic_family,
            ..TypefaceInfo::EMPTY
        }
    }
}

/// Inspect data for a `Typeface`.
#[derive(Debug)]
pub struct TypefaceInspectData {
    /// The main `Node` for the typeface.
    node: finspect::Node,
    /// Numeric asset ID.
    asset_id: finspect::UintProperty,
    /// Path or URL to the asset.
    asset_location: Option<finspect::StringProperty>,
    /// Index of the typeface within the font asset.
    font_index: finspect::UintProperty,
    /// Style properties of the typeface.
    style: finspect::Node,
    /// Languages supported by the asset, as a sequence of BCP-47 language tags joined on ", ".
    languages: finspect::StringProperty,
    /// Number of code points covered by the typeface.
    code_point_count: finspect::UintProperty,
    /// Name of the font family. This should only be filled in in contexts where the typefaces are
    /// not already grouped by family (e.g. fallback chain).
    family_name: Option<finspect::StringProperty>,
}

impl TypefaceInspectData {
    #![allow(dead_code)]

    /// Creates a new `TypefaceInspectData`, which contains a `Node` with details.
    ///
    /// * `parent_node`: The node that will contain this node.
    /// * `node_name`: Arbitrary display name for this node that depends on the context in which the
    ///    node is displayed.
    /// * `typeface`: The typeface for which Inspect data should be generated.
    /// * `asset_location_lookup`: A closure for retrieving an asset's path or URL by asset ID.
    pub fn new(
        parent_node: &finspect::Node,
        node_name: &str,
        typeface: &Typeface,
        asset_location_lookup: &impl Fn(AssetId) -> Option<String>,
    ) -> Self {
        let node = parent_node.create_child(node_name);
        let asset_id = node.create_uint("asset_id", typeface.asset_id.0.into());
        let asset_location = (*asset_location_lookup)(typeface.asset_id)
            .map(|location| node.create_string("asset_location", &location));

        let font_index = node.create_uint("font_index", typeface.font_index.into());
        let style = {
            let style = node.create_child("style");
            style.record_string("slant", format!("{:?}", typeface.slant).to_kebab_case());
            style.record_uint("weight", typeface.weight.into());
            style.record_string("width", format!("{:?}", typeface.width).to_kebab_case());
            style
        };
        let languages = node.create_string("languages", typeface.languages.iter().join(", "));
        let code_point_count = node.create_uint("code_point_count", typeface.char_set.len() as u64);
        let family_name = None;
        TypefaceInspectData {
            node,
            asset_id,
            asset_location,
            font_index,
            style,
            languages,
            code_point_count,
            family_name,
        }
    }

    /// Creates a new `TypefaceInspectData`, which contains a `Node` with details. The node's name
    /// is a padded numeric string (because Inspect doesn't support node arrays).
    ///
    /// * `parent_node`: The node that will contain this node.
    /// * `node_index`: The index of the typeface node within the list in which it's being shown.
    /// * `node_count`: The total number of sibling typeface nodes.
    /// * `typeface`: The typeface for which Inspect data should be generated.
    /// * `asset_location_lookup`: A closure for retrieving an asset's path or URL by asset ID.
    pub fn with_numbered_node_name(
        parent_node: &finspect::Node,
        node_index: usize,
        node_count: usize,
        typeface: &Typeface,
        asset_location_lookup: &impl Fn(AssetId) -> Option<String>,
    ) -> Self {
        Self::new(parent_node, &zero_pad(node_index, node_count), typeface, asset_location_lookup)
    }

    /// Allows specifying a font family name, for use in Inspect contexts where it isn't obvious.
    pub fn with_family_name(mut self, family_name: &str) -> Self {
        let family_name = Some((&self.node).create_string("family_name", family_name));
        self.family_name = family_name;
        self
    }
}

#[cfg(test)]
mod tests {
    use {
        super::*,
        char_collection::char_collect,
        fidl_fuchsia_fonts::{Slant, Width, WEIGHT_NORMAL},
        finspect::assert_inspect_tree,
        maplit::btreeset,
    };

    #[test]
    fn test_typeface_new_empty_char_set_is_error() {
        let manifest_typeface = v2::Typeface {
            index: 0,
            style: v2::Style { slant: Slant::Upright, weight: WEIGHT_NORMAL, width: Width::Normal },
            languages: vec![],
            code_points: CharSet::new(vec![]),
        };

        assert!(Typeface::new(AssetId(0), manifest_typeface, None).is_err())
    }

    #[test]
    fn test_typeface_inspect_data() {
        let inspector = finspect::Inspector::new();

        let typeface = Typeface {
            asset_id: AssetId(5),
            font_index: 2,
            slant: Slant::Upright,
            weight: 300,
            width: Width::UltraCondensed,
            languages: btreeset!("es-ES".to_string(), "en-US".to_string()),
            char_set: char_collect!(0x0..=0xFF).into(),
            generic_family: Some(GenericFontFamily::Fantasy),
        };

        let inspect_data = TypefaceInspectData::with_numbered_node_name(
            inspector.root(),
            17,
            150,
            &typeface,
            &|asset_id| {
                if asset_id == AssetId(5) {
                    Some("/path/to/asset-5.ttf".to_string())
                } else {
                    None
                }
            },
        );

        assert_inspect_tree!(inspector, root: {
            "017": {
                asset_id: 5u64,
                asset_location: "/path/to/asset-5.ttf",
                font_index: 2u64,
                style: {
                    slant: "upright",
                    weight: 300u64,
                    width: "ultra-condensed",
                },
                languages: "en-US, es-ES",
                code_point_count: 256u64,
            },
        });

        let _inspect_data = inspect_data.with_family_name("Alpha");

        assert_inspect_tree!(inspector, root: {
            "017": contains {
                asset_id: 5u64,
                family_name: "Alpha",
            },
        });
    }
}