// 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::font_info;
use super::manifest;
use fidl_fuchsia_fonts as fonts;
use std::collections::BTreeSet;
use std::sync::Arc;

pub type LanguageSet = BTreeSet<String>;

pub struct Font {
    pub asset_id: u32,
    pub font_index: u32,
    pub slant: fonts::Slant,
    pub weight: u32,
    pub width: u32,
    pub language: LanguageSet,
    pub info: font_info::FontInfo,
    pub fallback_group: fonts::FallbackGroup,
}

impl Font {
    pub fn new(
        asset_id: u32, manifest: manifest::Font, info: font_info::FontInfo,
        fallback_group: fonts::FallbackGroup,
    ) -> Font {
        Font {
            asset_id,
            font_index: manifest.index,
            weight: manifest.weight,
            width: manifest.width,
            slant: manifest.slant,
            language: manifest
                .language
                .iter()
                .map(|x| x.to_ascii_lowercase())
                .collect(),
            info,
            fallback_group,
        }
    }
}

struct FontAndLangScore<'a> {
    font: &'a Font,
    lang_score: usize,
}

// Returns value in the range [0, 2*request_lang.len()]. First half is used
// for exact matches, the second half is for partial matches.
fn get_lang_match_score(font: &Font, request_lang: &[String]) -> usize {
    let mut best_partial_match_pos = None;
    for i in 0..request_lang.len() {
        let lang = &request_lang[i];

        // Iterate all language in the font that start with |lang|.
        for font_lang in font
            .language
            .range::<String, std::ops::RangeFrom<&String>>(lang..)
        {
            if !font_lang.starts_with(lang.as_str()) {
                break;
            }

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

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

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

impl<'a> FontAndLangScore<'a> {
    fn new(font: &'a Font, request: &fonts::Request) -> FontAndLangScore<'a> {
        let lang_score = get_lang_match_score(font, request.language.as_ref().unwrap_or(&vec![]));
        FontAndLangScore { font, lang_score }
    }
}

const FONT_WIDTH_NORMAL: u32 = 5;

// Selects between fonts |a| and |b| for the |request|. Fonts are passed in
// FontAndLangScore so the language match score is calculated only once for each
// font. If |a| and |b| are equivalent then |a| is returned.
// The style matching logic follows the CSS3 Fonts spec (see Section 5.2,
// Item 4: https://www.w3.org/TR/css-fonts-3/#font-style-matching ) with 2
// additions:
//   1. Fonts with higher language match score are preferred. The score value
//      is expected to be pre-calculated by get_lang_match_score(). Note that if
//      the request specifies a character then the fonts are expected to be
//      already filtered based on that character, i.e. they both contain that
//      character, so this function doesn't need to verify it.
//   2. If the request specifies |fallback_group| then fonts with the same
//      |fallback_group| are preferred.
fn select_best_match<'a, 'b>(
    mut a: FontAndLangScore<'a>, mut b: FontAndLangScore<'a>, request: &'b fonts::Request,
) -> FontAndLangScore<'a> {
    if a.lang_score != b.lang_score {
        if a.lang_score < b.lang_score {
            return a;
        } else {
            return b;
        }
    }

    if (request.fallback_group != fonts::FallbackGroup::None)
        & (a.font.fallback_group != b.font.fallback_group)
    {
        if a.font.fallback_group == request.fallback_group {
            return a;
        } else if b.font.fallback_group == request.fallback_group {
            return b;
        }
        // If fallback_group of a and b doesn't match the request then
        // fall-through to compare them based on style parameters.
    }

    // Select based on width, see CSS3 Section 5.2, Item 4.a.
    if a.font.width != b.font.width {
        // Reorder a and b, so a has lower width.
        if a.font.width > b.font.width {
            std::mem::swap(&mut a, &mut b)
        }
        if request.width <= FONT_WIDTH_NORMAL {
            if b.font.width <= request.width {
                return b;
            } else {
                return a;
            }
        } else {
            if a.font.width >= request.width {
                return a;
            } else {
                return b;
            }
        }
    }

    // Select based on slant, CSS3 Section 5.2, Item 4.b.
    match (request.slant, a.font.slant, b.font.slant) {
        // If both fonts have the same slant then fall through to select based
        // on weight.
        (_, a_s, b_s) if a_s == b_s => (),

        // If we have a font that matches the request then use it.
        (r_s, a_s, _) if r_s == a_s => return a,
        (r_s, _, b_s) if r_s == b_s => return b,

        // In case italic or oblique font is requested pick italic or
        // oblique.
        (fonts::Slant::Italic, fonts::Slant::Oblique, _) => return a,
        (fonts::Slant::Italic, _, fonts::Slant::Oblique) => return b,

        (fonts::Slant::Oblique, fonts::Slant::Italic, _) => return a,
        (fonts::Slant::Oblique, _, fonts::Slant::Italic) => return b,

        // In case upright font is requested, but we have only italic and
        // oblique then fall through to select based on weight.
        (fonts::Slant::Upright, _, _) => (),

        // Patterns above cover all possible inputs, but exhaustiveness
        // checker doesn't see it.
        _ => (),
    }

    // Select based on weight, CSS3 Section 5.2, Item 4.c.
    if a.font.weight != b.font.weight {
        // Reorder a and b, so a has lower weight.
        if a.font.weight > b.font.weight {
            std::mem::swap(&mut a, &mut b)
        }

        if a.font.weight == request.weight {
            return a;
        }
        if b.font.weight == request.weight {
            return b;
        }

        if request.weight < 400 {
            // If request.weight < 400, then fonts with
            // weights <= request.weight are preferred.
            if b.font.weight <= request.weight {
                return b;
            } else {
                return a;
            }
        } else if request.weight > 500 {
            // If request.weight > 500, then fonts with
            // weights >= request.weight are preferred.
            if a.font.weight >= request.weight {
                return a;
            } else {
                return b;
            }
        } else {
            // request.weight is 400 or 500.
            if b.font.weight <= 500 {
                if (a.font.weight as i32 - request.weight as i32).abs()
                    < (b.font.weight as i32 - request.weight as i32).abs()
                {
                    return a;
                } else {
                    return b;
                }
            } else {
                return a;
            }
        }
    }

    // If a and b are equivalent then give priority according to the order in
    // the manifest.
    a
}

pub struct FontCollection {
    // Some fonts may be in more than one collections. Particularly fallback fonts
    // are added to the family collection and also to the fallback collection.
    fonts: Vec<Arc<Font>>,
}

impl FontCollection {
    pub fn new() -> FontCollection {
        FontCollection { fonts: vec![] }
    }

    pub fn match_request<'a, 'b>(&'a self, request: &'b fonts::Request) -> Option<&'a Font> {
        if (request.flags & fonts::REQUEST_FLAG_EXACT_MATCH) > 0 {
            return self
                .fonts
                .iter()
                .find(|font| {
                    (font.width == request.width)
                        & (font.weight == request.weight)
                        & (font.slant == request.slant)
                        & (request.language.as_ref().map_or(true, |value| {
                            value.is_empty()
                                || value
                                    .iter()
                                    .find(|lang| font.language.contains(*lang))
                                    .is_some()
                        }))
                        & ((request.character == 0) | font.info.charset.contains(request.character))
                })
                .map(|f| f as &Font);
        }

        fn fold<'a, 'b>(
            best: Option<FontAndLangScore<'a>>, x: &'a Font, request: &'b fonts::Request,
        ) -> Option<FontAndLangScore<'a>> {
            let x = FontAndLangScore::new(x, request);
            match best {
                Some(b) => Some(select_best_match(b, x, request)),
                None => Some(x),
            }
        }

        self.fonts
            .iter()
            .filter(|f| (request.character == 0) | f.info.charset.contains(request.character))
            .fold(None, |best, x| fold(best, x, request))
            .map(|a| a.font)
    }

    pub fn is_empty(&self) -> bool {
        self.fonts.is_empty()
    }

    pub fn add_font(&mut self, font: Arc<Font>) {
        self.fonts.push(font);
    }

    pub fn get_styles<'a>(&'a self) -> impl Iterator<Item = fonts::Style> + 'a {
        self.fonts.iter().map(|f| fonts::Style {
            width: f.width,
            slant: f.slant,
            weight: f.weight,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::font_info::{CharSet, FontInfo};
    use super::*;
    use fidl_fuchsia_fonts::{self as fonts, FallbackGroup, Slant::*};

    fn make_fake_font_collection(mut fonts: Vec<Font>) -> FontCollection {
        let mut result = FontCollection::new();
        for (i, mut font) in fonts.drain(..).enumerate() {
            // Assign fake asset_id to each font
            font.asset_id = i as u32;
            result.add_font(Arc::new(font));
        }

        result
    }

    fn make_fake_font(
        width: u32, slant: fonts::Slant, weight: u32, lang: &[&str], charset: &[u32],
        fallback_group: FallbackGroup,
    ) -> Font {
        Font::new(
            0,
            manifest::Font {
                asset: std::path::PathBuf::new(),
                index: 0,
                slant,
                weight,
                width,
                language: lang.iter().map(|s| s.to_string()).collect(),
            },
            FontInfo {
                charset: CharSet::new(charset.to_vec()),
            },
            fallback_group,
        )
    }

    fn request_font<'a, 'b>(
        collection: &'a FontCollection, width: u32, slant: fonts::Slant, weight: u32,
        lang: Option<&'b [&'b str]>, flags: u32, fallback_group: FallbackGroup,
    ) -> Option<&'a Font> {
        let request = fonts::Request {
            family: None,
            weight: weight,
            width: width,
            slant: slant,
            character: 0,
            language: lang.map(|l| l.iter().map(|s| s.to_ascii_lowercase()).collect()),
            fallback_group: fallback_group,
            flags: flags,
        };

        collection.match_request(&request)
    }

    fn make_fake_font_style(width: u32, slant: fonts::Slant, weight: u32) -> Font {
        make_fake_font(width, slant, weight, &[], &[], FallbackGroup::None)
    }

    fn request_style(
        collection: &FontCollection, width: u32, slant: fonts::Slant, weight: u32,
    ) -> &Font {
        request_font(
            collection,
            width,
            slant,
            weight,
            None,
            0,
            FallbackGroup::None,
        )
        .unwrap()
    }

    #[test]
    fn test_font_matching_width() {
        let collection = make_fake_font_collection(vec![
            make_fake_font_style(2, Upright, 600),
            make_fake_font_style(3, Italic, 100),
            make_fake_font_style(8, Oblique, 400),
        ]);

        // width is more important than other style parameters.
        assert!(request_style(&collection, 3, Italic, 400).width == 3);

        // For width <= 5 lower widths are preferred.
        assert!(request_style(&collection, 2, Italic, 400).width == 2);
        assert!(request_style(&collection, 4, Italic, 400).width == 3);

        // For width > 4 higher widths are preferred.
        assert!(request_style(&collection, 6, Italic, 400).width == 8);

        // Otherwise expect font with the closest width.
        assert!(request_style(&collection, 1, Italic, 400).width == 2);
        assert!(request_style(&collection, 9, Italic, 400).width == 8);
    }

    #[test]
    fn test_font_matching_slant() {
        let collection = make_fake_font_collection(vec![
            make_fake_font_style(5, Upright, 600),
            make_fake_font_style(5, Italic, 100),
            make_fake_font_style(5, Oblique, 400),
        ]);

        // slant is more important than weight.
        assert!(request_style(&collection, 3, Upright, 400).slant == Upright);
        assert!(request_style(&collection, 3, Italic, 400).slant == Italic);
        assert!(request_style(&collection, 3, Oblique, 400).slant == Oblique);

        let collection = make_fake_font_collection(vec![
            make_fake_font_style(5, Upright, 600),
            make_fake_font_style(5, Oblique, 400),
        ]);

        // Oblique is selected when Italic is requested.
        assert!(request_style(&collection, 3, Italic, 400).slant == Oblique);
    }

    #[test]
    fn test_font_matching_weight() {
        let collection = make_fake_font_collection(vec![
            make_fake_font_style(5, Upright, 700),
            make_fake_font_style(5, Upright, 200),
            make_fake_font_style(5, Upright, 400),
        ]);

        // Exact match.
        assert!(request_style(&collection, 3, Upright, 200).weight == 200);
        assert!(request_style(&collection, 3, Upright, 400).weight == 400);
        assert!(request_style(&collection, 3, Upright, 700).weight == 700);

        // For weight < 400 lower weights are preferred.
        assert!(request_style(&collection, 3, Upright, 300).weight == 200);

        // For weight > 500 higher weights are preferred.
        assert!(request_style(&collection, 3, Upright, 600).weight == 700);

        // For request.weight = 500 the font with weight == 400 is preferred.
        assert!(request_style(&collection, 3, Upright, 500).weight == 400);

        // Otherwise expect font with the closest weight.
        assert!(request_style(&collection, 3, Upright, 100).weight == 200);
        assert!(request_style(&collection, 3, Upright, 800).weight == 700);
    }

    fn request_style_exact(
        collection: &FontCollection, width: u32, slant: fonts::Slant, weight: u32,
    ) -> Option<&Font> {
        request_font(
            collection,
            width,
            slant,
            weight,
            None,
            fonts::REQUEST_FLAG_EXACT_MATCH,
            FallbackGroup::None,
        )
    }

    #[test]
    fn test_font_matching_exact() {
        let collection = make_fake_font_collection(vec![
            make_fake_font_style(2, Upright, 600),
            make_fake_font_style(3, Italic, 100),
            make_fake_font_style(8, Oblique, 400),
        ]);

        assert!(
            request_style_exact(&collection, 3, Italic, 100)
                .unwrap()
                .asset_id
                == 1
        );

        assert!(request_style_exact(&collection, 4, Italic, 100).is_none());
        assert!(request_style_exact(&collection, 3, Upright, 100).is_none());
        assert!(request_style_exact(&collection, 3, Italic, 300).is_none());
    }

    fn make_fake_font_lang(lang: &[&str]) -> Font {
        make_fake_font(5, Upright, 400, lang, &[], FallbackGroup::None)
    }

    fn request_lang<'a, 'b>(collection: &'a FontCollection, lang: &'b [&'b str]) -> &'a Font {
        request_font(
            collection,
            5,
            Upright,
            400,
            Some(lang),
            0,
            FallbackGroup::None,
        )
        .unwrap()
    }

    #[test]
    fn test_font_matching_lang() {
        let collection = make_fake_font_collection(vec![
            make_fake_font_lang(&["a"]),
            make_fake_font_lang(&["b-C"]),
            make_fake_font_lang(&["b-D", "b-E"]),
            make_fake_font_lang(&["fooo"]),
            make_fake_font_lang(&["foo-BAR"]),
        ]);

        // Exact matches.
        assert!(request_lang(&collection, &["a"]).asset_id == 0);
        assert!(request_lang(&collection, &["b-C"]).asset_id == 1);
        assert!(request_lang(&collection, &["b-E"]).asset_id == 2);

        // Verify that request language order is respected.
        assert!(request_lang(&collection, &["b-C", "a"]).asset_id == 1);

        // Partial match: the first matching font is returned first.
        assert!(request_lang(&collection, &["b"]).asset_id == 1);

        // Exact match overrides preceding partial match.
        assert!(request_lang(&collection, &["b", "a"]).asset_id == 0);

        // Partial match should match a whole BCP47 segment.
        assert!(request_lang(&collection, &["foo"]).asset_id == 4);
    }

    fn make_fake_font_fallback_group(fallback_group: FallbackGroup) -> Font {
        make_fake_font(5, Upright, 400, &[], &[], fallback_group)
    }

    fn request_fallback_group(collection: &FontCollection, fallback_group: FallbackGroup) -> &Font {
        request_font(collection, 5, Upright, 400, None, 0, fallback_group).unwrap()
    }

    #[test]
    fn test_font_matching_fallback_group() {
        let collection = make_fake_font_collection(vec![
            make_fake_font_fallback_group(FallbackGroup::Serif),
            make_fake_font_fallback_group(FallbackGroup::SansSerif),
            make_fake_font_fallback_group(FallbackGroup::Monospace),
        ]);

        assert!(request_fallback_group(&collection, FallbackGroup::Serif).asset_id == 0);
        assert!(request_fallback_group(&collection, FallbackGroup::SansSerif).asset_id == 1);
        assert!(request_fallback_group(&collection, FallbackGroup::Monospace).asset_id == 2);

        // First font is returned when there is no exact match.
        assert!(request_fallback_group(&collection, FallbackGroup::Cursive).asset_id == 0);
    }
}