#![deny(missing_docs)]

//! Standard Bitmap Graphics Table (`sbix`).

//!

//! References:

//!

//! * [Microsoft](https://docs.microsoft.com/en-us/typography/opentype/spec/sbix)

//! * [Apple](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6sbix.html)

use super::{

    BitDepth, Bitmap, BitmapGlyph, EncapsulatedBitmap, EncapsulatedFormat, Metrics, OriginOffset,

};

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

use crate::binary::U32Be;

use crate::error::ParseError;

use crate::tag;

use crate::SafeFrom;

/// `sbix` table containing bitmaps.

pub struct Sbix<'a> {

    /// Drawing flags.

    ///

    /// * Bit 0: Set to 1.

    /// * Bit 1: Draw outlines.

    /// * Bits 2 to 15: reserved (set to 0).

    pub flags: u16,

    /// Bitmap data for different sizes.

    pub strikes: Vec<SbixStrike<'a>>,

}

/// A single strike (ppem/ppi) combination.

pub struct SbixStrike<'a> {

    scope: ReadScope<'a>,

    /// The PPEM size for which this strike was designed.

    pub ppem: u16,

    /// The device pixel density (in pixels-per-inch) for which this strike was designed.

    pub ppi: u16,

    /// Offset from the beginning of the strike data header to bitmap data for an individual glyph.

    glyph_data_offsets: ReadArray<'a, U32Be>,

}

/// An `sbix` bitmap glyph.

pub struct SbixGlyph<'a> {

    /// The horizontal (x-axis) offset from the left edge of the graphic to the glyph’s origin.

    ///

    /// That is, the x-coordinate of the point on the baseline at the left edge of the glyph.

    pub origin_offset_x: i16,

    /// The vertical (y-axis) offset from the bottom edge of the graphic to the glyph’s origin.

    ///

    /// That is, the y-coordinate of the point on the baseline at the left edge of the glyph.

    pub origin_offset_y: i16,

    /// Indicates the format of the embedded graphic data.

    ///

    /// One of `jpg `, `png ` or `tiff`; or the special formats `dupe` or `flip`.

    pub graphic_type: u32,

    /// The actual embedded graphic data.

    pub data: &'a [u8],

}

impl ReadBinaryDep for Sbix<'_> {

    type Args<'a> = usize; // num_glyphs

    type HostType<'a> = Sbix<'a>;

    /// Read the `sbix` table.

    ///

    /// `num_glyphs` should be read from the `maxp` table.

}

impl ReadBinaryDep for SbixStrike<'_> {

    type Args<'a> = usize; // num_glyphs

    type HostType<'a> = SbixStrike<'a>;

        // The glyph_data_offset array includes offsets for every glyph ID, plus one extra.

        // — https://docs.microsoft.com/en-us/typography/opentype/spec/sbix#strikes

}

impl ReadBinaryDep for SbixGlyph<'_> {

    type Args<'a> = usize; // data_len

    type HostType<'a> = SbixGlyph<'a>;

        // The length of the glyph data is the length of the glyph minus the preceding

        // header fields:

        // * u16 origin_offset_x  = 2

        // * u16 origin_offset_y  = 2

        // * u32 graphic_type     = 4

        // TOTAL:                 = 8

}

impl<'a> Sbix<'a> {

    /// Find a strike matching the desired parameters

        // A strike does not need to include data for every glyph, and does not need to include

        // data for the same set of glyphs as other strikes. If the application is using bitmap

        // data to draw text and there is bitmap data for a glyph in any strike, then the glyph

        // must be drawn using a bitmap from some strike.

        //

        // If the exact size is not available, implementations may choose a bitmap based on the

        // closest available larger size, or the closest available integer-multiple larger size, or

        // on some other basis. The only cases in which a glyph is not drawn using a bitmap are if

        // the application has not requested that text be drawn using bitmap data or if there is no

        // bitmap data for the glyph in any strike.

        //

        // — https://docs.microsoft.com/en-us/typography/opentype/spec/sbix#strikes

                }

            }

        }

}

impl<'a> SbixStrike<'a> {

    /// Read a glyph from this strike specified by `glyph_index`.

            Some(0) => {

                // If this is zero, there is no bitmap data for that glyph in this strike.

                // — https://docs.microsoft.com/en-us/typography/opentype/spec/sbix#strikes

            }

            }

        }

        // The length of the bitmap data for each glyph is variable, and can be determined from the

        // difference between two consecutive offsets. Hence, the length of data for glyph N is

        // glyph_data_offset[N+1] - glyph_data_offset[N].

        // — https://docs.microsoft.com/en-us/typography/opentype/spec/sbix#strikes

}

impl<'a> From<(&SbixStrike<'a>, &SbixGlyph<'a>, u16, bool)> for BitmapGlyph {

}

impl From<u32> for EncapsulatedFormat {

        }

}

impl From<&SbixGlyph<'_>> for OriginOffset {

}

#[cfg(test)]

mod tests {

    use super::*;

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

    use crate::font_data::FontData;

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

    use crate::tag;

    use crate::tests::read_fixture;

    #[test]

    fn test_read_sbix() {

        let buffer = read_fixture("tests/fonts/woff1/chromacheck-sbix.woff");

        let scope = ReadScope::new(&buffer);

        let font_file = scope

            .read::<FontData<'_>>()

            .expect("unable to parse font file");

        let table_provider = font_file

            .table_provider(0)

            .expect("unable to create font provider");

        let maxp_data = table_provider

            .read_table_data(tag::MAXP)

            .expect("unable to read maxp table data");

        let maxp = ReadScope::new(&maxp_data).read::<MaxpTable>().unwrap();

        let sbix_data = table_provider

            .read_table_data(tag::SBIX)

            .expect("unable to read sbix table data");

        let sbix = ReadScope::new(&sbix_data)

            .read_dep::<Sbix<'_>>(usize::try_from(maxp.num_glyphs).unwrap())

            .unwrap();

        // Header

        assert_eq!(sbix.flags, 1);

        // Strikes

        assert_eq!(sbix.strikes.len(), 1);

        let strike = &sbix.strikes[0];

        assert_eq!(strike.ppem, 300);

        assert_eq!(strike.ppi, 72);

        // Glyphs

        let glyphs = (0..maxp.num_glyphs)

            .map(|glyph_index| strike.read_glyph(glyph_index))

            .collect::<Result<Vec<_>, _>>()

            .expect("unable to read glyph");

        assert_eq!(glyphs.len(), 2);

        assert!(glyphs[0].is_none());

        if let Some(ref glyph) = glyphs[1] {

            assert_eq!(glyph.origin_offset_x, 0);

            assert_eq!(glyph.origin_offset_y, 0);

            assert_eq!(glyph.graphic_type, tag::PNG);

            assert_eq!(glyph.data.len(), 224);

            assert_eq!(*glyph.data.last().unwrap(), 0x82);

        } else {

            panic!("expected Some(SbixGlyph) got None");

        }

    }

}