//! Parsing of the `OS/2` table.

//!

//! > The OS/2 table consists of a set of metrics and other data that are required in OpenType fonts.

//!

//! — <https://docs.microsoft.com/en-us/typography/opentype/spec/os2>

use std::convert::TryInto;

use crate::binary::read::{ReadBinaryDep, ReadCtxt};

use crate::binary::write::{WriteBinary, WriteContext};

use crate::binary::{I16Be, U16Be, U32Be};

use crate::error::{ParseError, WriteError};

use crate::tables::Fixed;

/// `OS/2` table

///

/// <https://docs.microsoft.com/en-us/typography/opentype/spec/os2>

#[derive(Clone)]

pub struct Os2 {

    pub version: u16,

    pub x_avg_char_width: i16,

    pub us_weight_class: u16,

    pub us_width_class: u16,

    pub fs_type: u16,

    pub y_subscript_x_size: i16,

    pub y_subscript_y_size: i16,

    pub y_subscript_x_offset: i16,

    pub y_subscript_y_offset: i16,

    pub y_superscript_x_size: i16,

    pub y_superscript_y_size: i16,

    pub y_superscript_x_offset: i16,

    pub y_superscript_y_offset: i16,

    pub y_strikeout_size: i16,

    pub y_strikeout_position: i16,

    pub s_family_class: i16,

    pub panose: [u8; 10],

    pub ul_unicode_range1: u32,

    pub ul_unicode_range2: u32,

    pub ul_unicode_range3: u32,

    pub ul_unicode_range4: u32,

    pub ach_vend_id: u32, // tag

    pub fs_selection: FsSelection,

    pub us_first_char_index: u16,

    pub us_last_char_index: u16,

    // Note: Documentation for OS/2 version 0 in Apple’s TrueType Reference Manual stops at the

    // usLastCharIndex field and does not include the last five fields of the table as it was

    // defined by Microsoft. Some legacy TrueType fonts may have been built with a shortened

    // version 0 OS/2 table. Applications should check the table length for a version 0 OS/2 table

    // before reading these fields.

    pub version0: Option<Version0>,

    pub version1: Option<Version1>,

    pub version2to4: Option<Version2to4>,

    pub version5: Option<Version5>,

}

#[derive(Clone)]

pub struct Version0 {

    pub s_typo_ascender: i16,

    pub s_typo_descender: i16,

    pub s_typo_line_gap: i16,

    pub us_win_ascent: u16,

    pub us_win_descent: u16,

}

#[derive(Clone)]

pub struct Version1 {

    pub ul_code_page_range1: u32,

    pub ul_code_page_range2: u32,

}

#[derive(Clone)]

pub struct Version2to4 {

    pub s_x_height: i16,

    pub s_cap_height: i16,

    pub us_default_char: u16,

    pub us_break_char: u16,

    pub us_max_context: u16,

}

#[derive(Clone)]

pub struct Version5 {

    pub us_lower_optical_point_size: u16,

    pub us_upper_optical_point_size: u16,

}

/// fsSelection field in `OS/2`

///

/// ```text

/// Bit #  macStyle bit  C definition     Description

/// 0      bit 1         ITALIC           Font contains italic or oblique glyphs, otherwise

///                                       they are upright.

/// 1                    UNDERSCORE       glyphs are underscored.

/// 2                    NEGATIVE         glyphs have their foreground and background reversed.

/// 3                    OUTLINED         Outline (hollow) glyphs, otherwise they are solid.

/// 4                    STRIKEOUT        glyphs are overstruck.

/// 5      bit 0         BOLD             glyphs are emboldened.

/// 6                    REGULAR          glyphs are in the standard weight/style for the font.

/// 7                    USE_TYPO_METRICS If set, it is strongly recommended that applications

///                                       use OS/2.sTypoAscender - OS/2.sTypoDescender +

///                                       OS/2.sTypoLineGap as the default line spacing for

///                                       this font.

/// 8                    WWS              The font has 'name' table strings consistent with a

///                                       weight/width/slope family without requiring use of

///                                       name IDs 21 and 22.

/// 9                    OBLIQUE          Font contains oblique glyphs.

/// 10–15                <reserved>       Reserved; set to 0.

/// ```

#[enumflags2::bitflags]

#[repr(u16)]

#[derive(Debug, Clone, Copy, Eq, PartialEq)]

#[allow(non_camel_case_types)]

pub enum FsSelectionFlag {

    ITALIC = 1 << 0,

    UNDERSCORE = 1 << 1,

    NEGATIVE = 1 << 2,

    OUTLINED = 1 << 3,

    STRIKEOUT = 1 << 4,

    BOLD = 1 << 5,

    REGULAR = 1 << 6,

    USE_TYPO_METRICS = 1 << 7,

    WWS = 1 << 8,

    OBLIQUE = 1 << 9,

    // 10–15 Reserved; set to 0.

}

pub type FsSelection = enumflags2::BitFlags<FsSelectionFlag>;

impl Os2 {

    /// Map a width value to an OS/2 width class

        const WIDTH_CLASS_MAP: &[(Fixed, u16)] = &[

            // using from_raw so it works in const context

            (Fixed::from_raw(3276800), 1),  // 50.0

            (Fixed::from_raw(4096000), 2),  // 62.5

            (Fixed::from_raw(4915200), 3),  // 75.0

            (Fixed::from_raw(5734400), 4),  // 87.5

            (Fixed::from_raw(6553600), 5),  // 100.0

            (Fixed::from_raw(7372800), 6),  // 112.5

            (Fixed::from_raw(8192000), 7),  // 125.0

            (Fixed::from_raw(9830400), 8),  // 150.0

            (Fixed::from_raw(13107200), 9), // 200.0

        ];

        // Map the value to one of the width classes. Width is a percentage and can be

        // anything > 1 but classes are only defined for 50% to 200%.

                // get the values at i and i-1, choose the one it's closer to

                } else {

                }

            }

        }

}

impl ReadBinaryDep for Os2 {

    type HostType<'a> = Self;

    type Args<'a> = usize;

    // The format of this table has changed over time. The original TrueType specification had this

    // table at 68 bytes long. The first OpenType version had it at 78 bytes long, and the current

    // OpenType version is even larger. To determine which kind of table your software is dealing

    // with, it's best both to consider the table's version and its size.

        // NOTE(unwrap): Safe as slice is guaranteed to have 10 elements

        // Read version specific fields

        } else {

        };

        } else {

        };

        } else {

        };

        } else {

        };

}

impl WriteBinary<&Self> for Os2 {

    type Output = ();

        // TODO: make impossible states unrepresentable

        // The way the data is structured means that it's possible to have say a v5 struct present

        // but the preceding ones absent, which is invalid.

        } else {

        };

}

impl WriteBinary<&Self> for Version0 {

    type Output = ();

}

impl WriteBinary<&Self> for Version1 {

    type Output = ();

}

impl WriteBinary<&Self> for Version2to4 {

    type Output = ();

}

impl WriteBinary<&Self> for Version5 {

    type Output = ();

}

/// Constant array defining Unicode ranges and their corresponding bit index in the 128-bit mask.

///

/// Each tuple contains:

/// - the start of the range (inclusive),

/// - the end of the range (inclusive),

/// - the bit index (i.e. which bit should be set).

const UNICODE_RANGES: &[(u32, u32, u32)] = &[

    (0x0000, 0x007F, 0),  // Basic Latin

    (0x0080, 0x00FF, 1),  // Latin-1 Supplement

    (0x0100, 0x017F, 2),  // Latin Extended-A

    (0x0180, 0x024F, 3),  // Latin Extended-B

    (0x0250, 0x02AF, 4),  // IPA Extensions

    (0x02B0, 0x02FF, 5),  // Spacing Modifier Letters

    (0x0300, 0x036F, 6),  // Combining Diacritical Marks

    (0x0370, 0x03FF, 7),  // Greek and Coptic

    (0x0400, 0x04FF, 9),  // Cyrillic

    (0x0530, 0x058F, 10), // Armenian

    (0x0590, 0x05FF, 11), // Hebrew

    (0x0600, 0x06FF, 12), // Arabic

    (0x0700, 0x074F, 13), // Syriac

    (0x0750, 0x077F, 14), // Arabic Supplement

    (0x0780, 0x07BF, 15), // Thaana

    (0x07C0, 0x07FF, 16), // NKo

    (0x0800, 0x083F, 17), // Samaritan

    (0x0840, 0x085F, 18), // Mandaic

    (0x0860, 0x086F, 19), // Syriac Supplement

    (0x08A0, 0x08FF, 20), // Arabic Extended-A

    (0x0900, 0x097F, 21), // Devanagari

    (0x0980, 0x09FF, 22), // Bengali

    (0x0A00, 0x0A7F, 23), // Gurmukhi

    (0x0A80, 0x0AFF, 24), // Gujarati

    (0x0B00, 0x0B7F, 25), // Oriya

    (0x0B80, 0x0BFF, 26), // Tamil

    (0x0C00, 0x0C7F, 27), // Telugu

    (0x0C80, 0x0CFF, 28), // Kannada

    (0x0D00, 0x0D7F, 29), // Malayalam

    (0x0D80, 0x0DFF, 30), // Sinhala

    (0x0E00, 0x0E7F, 31), // Thai

    (0x0E80, 0x0EFF, 32), // Lao

    (0x0F00, 0x0FFF, 33), // Tibetan

    (0x1000, 0x109F, 34), // Myanmar

    (0x10A0, 0x10FF, 35), // Georgian

    (0x1100, 0x11FF, 36), // Hangul Jamo

    (0x1E00, 0x1EFF, 37), // Latin Extended Additional

    (0x1F00, 0x1FFF, 38), // Greek Extended

];

/// Map a Unicode codepoint to a 128-bit mask for the ulUnicodeRange field.

///

/// This function iterates over the array of defined ranges and returns a mask with the bit

/// corresponding to the Unicode block set if the input codepoint falls within that range.

/// If no range matches, it returns 0.

    }

#[cfg(test)]

mod tests {

    use super::*;

    #[test]

    #[cfg(feature = "prince")]

    fn test_read() {

        // Imports are in here to stop warnings when prince feature is not enabled

        use crate::binary::read::ReadScope;

        use crate::tables::{FontTableProvider, OpenTypeFont};

        use crate::tag;

        use crate::tests::read_fixture;

        let buffer = read_fixture("../../../tests/data/fonts/HardGothicNormal.ttf");

        let opentype_file = ReadScope::new(&buffer).read::<OpenTypeFont<'_>>().unwrap();

        let provider = opentype_file.table_provider(0).unwrap();

        let os_2_data = provider.read_table_data(tag::OS_2).unwrap();

        let os_2 = ReadScope::new(&os_2_data)

            .read_dep::<Os2>(os_2_data.len())

            .expect("unable to parse OS/2 table");

        assert_eq!(os_2.version, 1);

        assert!(os_2.version0.is_some());

        assert!(os_2.version1.is_some());

        assert!(os_2.version2to4.is_none());

        assert!(os_2.version5.is_none());

    }

    #[test]

    #[cfg(feature = "prince")]

    fn test_write() {

        // Imports are in here to stop warnings when prince feature is not enabled

        use crate::binary::read::ReadScope;

        use crate::binary::write::WriteBuffer;

        use crate::tables::{FontTableProvider, OpenTypeFont};

        use crate::tag;

        use crate::tests::read_fixture;

        let buffer = read_fixture("../../../tests/data/fonts/HardGothicNormal.ttf");

        let opentype_file = ReadScope::new(&buffer).read::<OpenTypeFont<'_>>().unwrap();

        let provider = opentype_file.table_provider(0).unwrap();

        let os_2_data = provider.read_table_data(tag::OS_2).unwrap();

        let os_2 = ReadScope::new(&os_2_data)

            .read_dep::<Os2>(os_2_data.len())

            .expect("unable to parse OS/2 table");

        let mut out = WriteBuffer::new();

        Os2::write(&mut out, &os_2).unwrap();

        let written = out.into_inner();

        assert_eq!(written.as_slice(), &*os_2_data);

    }

    #[test]

    fn map_weight_class() {

        assert_eq!(Os2::value_to_width_class(Fixed::from(0.)), 1);

        assert_eq!(Os2::value_to_width_class(Fixed::from(1.)), 1);

        assert_eq!(Os2::value_to_width_class(Fixed::from(50.)), 1);

        assert_eq!(Os2::value_to_width_class(Fixed::from(51.)), 1);

        assert_eq!(Os2::value_to_width_class(Fixed::from(60.)), 2);

        assert_eq!(Os2::value_to_width_class(Fixed::from(150.)), 8);

        assert_eq!(Os2::value_to_width_class(Fixed::from(300.)), 9);

    }

}