use std::borrow::Cow;

use pathfinder_geometry::transform2d::{Matrix2x2F, Transform2F};

use pathfinder_geometry::vector::Vector2F;

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

use crate::error::ParseError;

use crate::outline::{OutlineBuilder, OutlineSink};

use crate::tables::os2::Os2;

use crate::tables::variable_fonts::gvar::GvarTable;

use crate::tables::variable_fonts::OwnedTuple;

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

use crate::tag;

use super::{

    CompositeGlyphComponent, CompositeGlyphFlagExt, CompositeGlyphScale, Glyph, LocaGlyf,

    SimpleGlyph, COMPOSITE_GLYPH_RECURSION_LIMIT,

};

use contour::{Contour, CurvePoint};

/// Context for visiting possibly variable outlines of glyphs from the `glyf` table

///

/// ### Example

///

/// ```

/// use std::fmt::Write;

///

/// use allsorts::binary::read::ReadScope;

/// use allsorts::error::ParseError;

/// use allsorts::outline::OutlineBuilder;

/// use allsorts::outline::OutlineSink;

/// use allsorts::tables::glyf::GlyfVisitorContext;

/// use allsorts::tables::glyf::LocaGlyf;

/// use allsorts::tables::glyf::VariableGlyfContext;

/// use allsorts::tables::glyf::VariableGlyfContextStore;

/// use allsorts::tables::variable_fonts::avar::AvarTable;

/// use allsorts::tables::variable_fonts::fvar::FvarTable;

/// use allsorts::tables::Fixed;

/// use allsorts::tables::FontTableProvider;

/// use allsorts::tables::OpenTypeFont;

/// use allsorts::tag;

/// use pathfinder_geometry::line_segment::LineSegment2F;

/// use pathfinder_geometry::vector::Vector2F;

///

/// struct DebugVisitor {

///     outlines: String,

/// }

///

/// impl OutlineSink for DebugVisitor {

///     fn move_to(&mut self, to: Vector2F) {

///         writeln!(&mut self.outlines, "move_to({}, {})", to.x(), to.y()).unwrap();

///     }

///

///     fn line_to(&mut self, to: Vector2F) {

///         writeln!(&mut self.outlines, "line_to({}, {})", to.x(), to.y()).unwrap();

///     }

///

///     fn quadratic_curve_to(&mut self, control: Vector2F, to: Vector2F) {

///         writeln!(

///             &mut self.outlines,

///             "quad_to({}, {}, {}, {})",

///             control.x(),

///             control.y(),

///             to.x(),

///             to.y()

///         )

///         .unwrap();

///     }

///

///     fn cubic_curve_to(&mut self, control: LineSegment2F, to: Vector2F) {

///         writeln!(

///             &mut self.outlines,

///             "curve_to({}, {}, {}, {}, {}, {})",

///             control.from_x(),

///             control.from_y(),

///             control.to_x(),

///             control.to_y(),

///             to.x(),

///             to.y()

///         )

///         .unwrap();

///     }

///

///     fn close(&mut self) {

///         writeln!(&mut self.outlines, "close()").unwrap();

///     }

/// }

///

/// fn main() -> Result<(), Box<dyn std::error::Error>> {

///     let buffer = std::fs::read("tests/fonts/variable/Inter[slnt,wght].abc.ttf")?;

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

///     let font_file = scope.read::<OpenTypeFont<'_>>()?;

///     let provider = font_file.table_provider(0)?;

///

///     // Load the tables

///     let fvar_data = provider.read_table_data(tag::FVAR)?;

///     let fvar = ReadScope::new(&fvar_data).read::<FvarTable<'_>>().unwrap();

///     let avar_data = provider.table_data(tag::AVAR)?;

///     let avar = avar_data

///         .as_ref()

///         .map(|avar_data| ReadScope::new(avar_data).read::<AvarTable<'_>>())

///         .transpose()?;

///     let mut loca_glyf = LocaGlyf::load(&provider)?;

///     let store = VariableGlyfContextStore::read(&provider)?;

///

///     // Get the variation tuple

///     //   Subfamily: ExtraBold Italic

///     // Coordinates: [800.0, -10.0]

///     let user_tuple = [Fixed::from(800), Fixed::from(-10)];

///     let tuple = fvar.normalize(user_tuple.iter().copied(), avar.as_ref())?;

///

///     // Visit the outlines

///     let var_context = VariableGlyfContext::new(&store)?;

///     let mut context = GlyfVisitorContext::new(&mut loca_glyf, Some(var_context));

///     let mut visitor = DebugVisitor {

///         outlines: String::new(),

///     };

///

///     context

///         .visit(1, Some(&tuple), &mut visitor)

///         .expect("error visiting glyph outline");

///

///     let expected = "move_to(456, -26)

/// quad_to(310, -26, 204.5, 23.5)

/// quad_to(99, 73, 50.5, 174)

/// quad_to(2, 275, 27, 426)

/// quad_to(49, 554, 108.5, 641.5)

/// quad_to(168, 729, 255.5, 784)

/// quad_to(343, 839, 451, 868)

/// quad_to(559, 897, 677, 907)

/// quad_to(809, 919, 891.5, 933)

/// quad_to(974, 947, 1015, 972.5)

/// quad_to(1056, 998, 1065, 1044)

/// line_to(1065, 1049)

/// quad_to(1077, 1126, 1032, 1168)

/// quad_to(987, 1210, 897, 1210)

/// quad_to(801, 1210, 733, 1168)

/// quad_to(665, 1126, 638, 1052)

/// line_to(190, 1068)

/// quad_to(232, 1208, 334, 1318.5)

/// quad_to(436, 1429, 593.5, 1492.5)

/// quad_to(751, 1556, 958, 1556)

/// quad_to(1104, 1556, 1222, 1521.5)

/// quad_to(1340, 1487, 1421.5, 1421.5)

/// quad_to(1503, 1356, 1538, 1261)

/// quad_to(1573, 1166, 1553, 1044)

/// line_to(1378, 0)

/// line_to(918, 0)

/// line_to(954, 214)

/// line_to(942, 214)

/// quad_to(888, 136, 815.5, 82)

/// quad_to(743, 28, 653, 1)

/// quad_to(563, -26, 456, -26)

/// close()

/// move_to(662, 294)

/// quad_to(739, 294, 808, 326)

/// quad_to(877, 358, 924.5, 414.5)

/// quad_to(972, 471, 985, 546)

/// line_to(1008, 692)

/// quad_to(987, 681, 955, 672)

/// quad_to(923, 663, 887, 655.5)

/// quad_to(851, 648, 813.5, 641.5)

/// quad_to(776, 635, 742, 630)

/// quad_to(670, 619, 617, 596)

/// quad_to(564, 573, 532.5, 536.5)

/// quad_to(501, 500, 494, 450)

/// quad_to(482, 375, 529, 334.5)

/// quad_to(576, 294, 662, 294)

/// close()

/// ";

///     assert_eq!(visitor.outlines, expected);

///

///     Ok(())

/// }

/// ```

pub struct GlyfVisitorContext<'a, 'data> {

    glyf: &'a mut LocaGlyf,

    variable: Option<VariableGlyfContext<'data>>,

}

/// Tables required to visit variable glyphs

pub struct VariableGlyfContext<'data> {

    /// [gvar][crate::tables::variable_fonts::gvar::GvarTable] table

    gvar: GvarTable<'data>,

    /// [hmtx][crate::tables::HmtxTable] table

    hmtx: HmtxTable<'data>,

    /// [vmtx][crate::tables::HmtxTable] table

    vmtx: Option<HmtxTable<'data>>,

    /// [OS/2][crate::tables::os2::Os2] table

    os2: Os2,

    /// [hhea][crate::tables::HheaTable] table

    hhea: HheaTable,

}

/// Holds data for tables required to visit variable glyphs

///

/// This type is used in conjunction with [VariableGlyfContext]. It exists to hold the data

/// parsed and held by the context. In an ideal world this data could be held by the context

/// itself, but this required self-referencing types, which are annoying.

pub struct VariableGlyfContextStore<'a> {

    maxp: Cow<'a, [u8]>,

    gvar: Cow<'a, [u8]>,

    hhea: Cow<'a, [u8]>,

    hmtx: Cow<'a, [u8]>,

    vhea: Option<Cow<'a, [u8]>>,

    vmtx: Option<Cow<'a, [u8]>>,

    os2: Cow<'a, [u8]>,

}

#[derive(Copy, Clone)]

struct GlyfVisitorState {

    offset: Vector2F,

    scale: Option<CompositeGlyphScale>,

    depth: u8,

}

impl GlyfVisitorState {

}

impl<'a, 'data> GlyfVisitorContext<'a, 'data> {

    /// Construct a new context for visiting glyphs

    ///

    /// To apply variation to visited glyphs a [VariableGlyfContext] must be supplied along with

    /// a tuple when calling [visit][Self::visit].

                // Get a copy of the glyph that can be mutated in order to apply the variations

            }

        };

            }

            }

        }

            // Argument1 and argument2 can be either x and y offsets to be added to the glyph (the

            // ARGS_ARE_XY_VALUES flag is set), or two point numbers (the ARGS_ARE_XY_VALUES flag

            // is not set). In the latter case, the first point number indicates the point that is

            // to be matched to the new glyph. The second number indicates the new glyph’s

            // “matched” point. Once a glyph is added, its point numbers begin directly after the

            // last glyphs (endpoint of first glyph + 1).

            //

            // https://docs.microsoft.com/en-us/typography/opentype/spec/glyf#composite-glyph-description

                // NOTE: Casts are safe as max value of composite glyph is u16::MAX

                )

            } else {

                // TODO: support args as point numbers

            };

        }

}

impl<'a> VariableGlyfContextStore<'a> {

    /// Read the required tables from the supplied [FontTableProvider]

}

impl<'data> VariableGlyfContext<'data> {

    /// Construct a new `VariableGlyfContext` from the supplied store

    ///

    /// The resulting instance can be passed to [GlyfVisitorContext::new] in order to visit the outlines

    /// of a variable font.

}

impl OutlineBuilder for GlyfVisitorContext<'_, '_> {

    type Error = ParseError;

    type Output = ();

}

        // Determine origin of the contour and move to it

        // Consume the stream of points...

        // It's assumed that the current location is on curve each time through this loop

                        Some(CurvePoint::Control(_)) => {

                            // Can't happen as the Points iterator inserts on curve mid-points

                            // when two consecutive control points are encountered

                        }

                        None => {

                            // Wrap around to the first point

                        }

                    }

                }

            }

        }

    }

mod contour {

    use crate::tables::glyf::{Point, SimpleGlyphFlagExt, SimpleGlyphFlags};

    use pathfinder_geometry::vector::Vector2F;

    pub struct Contour<'points> {

        points_and_flags: &'points [(SimpleGlyphFlags, Point)],

    }

    #[derive(Debug, PartialEq)]

    pub enum CurvePoint {

        OnCurve(Vector2F),

        Control(Vector2F),

    }

    pub struct Points<'a, 'points> {

        contour: &'a Contour<'points>,

        i: usize,

        until: usize,

        mid: Option<Vector2F>,

    }

    impl<'points> Contour<'points> {

                    // Origin is the first point, so start on the second point

                }

                    // Origin is the last point, so start on the first point and consider

                    // the last point already processed

                }

                    // Origin is the mid-point between first and last control points.

                    // Start on the first point

                }

            }

    }

    impl Iterator for Points<'_, '_> {

        type Item = CurvePoint;

                    // Check the next point, wrapping around if needed

                            // Next point is a control point, yield mid point as on curve point

                            // after this one

                        }

                    }

                }

            };

    }

    impl CurvePoint {

            } else {

            }

    }

}

#[cfg(test)]

mod tests {

    use pathfinder_geometry::line_segment::LineSegment2F;

    use pathfinder_geometry::vector::vec2f;

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

    use crate::binary::write::{WriteBinaryDep, WriteBuffer};

    use crate::tables::glyf::tests::{composite_glyph_fixture, simple_glyph_fixture};

    use crate::tables::glyf::{GlyfRecord, GlyfTable, Point, SimpleGlyphFlag, SimpleGlyphFlags};

    use crate::tables::variable_fonts::avar::AvarTable;

    use crate::tables::variable_fonts::fvar::FvarTable;

    use crate::tables::{Fixed, IndexToLocFormat, OpenTypeFont};

    use crate::tests::read_fixture;

    use super::*;

    struct TestVisitor {}

    impl OutlineSink for TestVisitor {

        fn move_to(&mut self, to: Vector2F) {

            println!("move_to({}, {})", to.x(), to.y());

        }

        fn line_to(&mut self, to: Vector2F) {

            println!("line_to({}, {})", to.x(), to.y());

        }

        fn quadratic_curve_to(&mut self, control: Vector2F, to: Vector2F) {

            println!(

                "quad_to({}, {}, {}, {})",

                control.x(),

                control.y(),

                to.x(),

                to.y()

            );

        }

        fn cubic_curve_to(&mut self, control: LineSegment2F, to: Vector2F) {

            println!(

                "curve_to({}, {}, {}, {}, {}, {})",

                control.from_x(),

                control.from_y(),

                control.to_x(),

                control.to_y(),

                to.x(),

                to.y()

            );

        }

        fn close(&mut self) {

            println!("close()");

        }

    }

    #[test]

    fn iter_simple_glyph_contours() {

        let simple_glyph = simple_glyph_fixture();

        let contours = simple_glyph

            .contours()

            .map(|contour| contour.iter().map(|(_, point)| *point).collect::<Vec<_>>())

            .collect::<Vec<_>>();

        let expected = &[&[

            Point(433, 77),

            Point(499, 30),

            Point(625, 2),

            Point(756, -27),

            Point(915, -31),

            Point(891, -47),

            Point(862, -60),

            Point(832, -73),

            Point(819, -103),

        ]];

        assert_eq!(&contours, expected);

    }

    #[test]

    fn iter_points() {

        let points_and_flags: &[(SimpleGlyphFlags, Point)] = &[

            (SimpleGlyphFlag::ON_CURVE_POINT.into(), Point::zero()),

            (SimpleGlyphFlags::empty(), Point(10, 40)), // control

            (SimpleGlyphFlags::empty(), Point(30, 40)), // control

            (SimpleGlyphFlag::ON_CURVE_POINT.into(), Point(40, 10)),

        ];

        let contour = Contour::new(points_and_flags);

        let points = contour.points().collect::<Vec<_>>();

        let expected = &[

            CurvePoint::Control(vec2f(10., 40.)),

            CurvePoint::OnCurve(vec2f(20., 40.)), // mid point

            CurvePoint::Control(vec2f(30., 40.)),

            CurvePoint::OnCurve(vec2f(40., 10.)),

        ];

        assert_eq!(contour.origin(), vec2f(0., 0.));

        assert_eq!(&points, expected);

    }

    #[test]

    fn outlines() {

        let glyphs = GlyfTable {

            records: vec![

                GlyfRecord::Parsed(Glyph::Simple(simple_glyph_fixture())),

                GlyfRecord::Parsed(Glyph::Composite(composite_glyph_fixture(&[]))),

                GlyfRecord::Parsed(Glyph::Simple(simple_glyph_fixture())),

                GlyfRecord::Parsed(Glyph::Simple(simple_glyph_fixture())),

                GlyfRecord::Parsed(Glyph::Simple(simple_glyph_fixture())),

                GlyfRecord::Parsed(Glyph::Simple(simple_glyph_fixture())),

            ],

        };

        let mut buf = WriteBuffer::new();

        let loca = GlyfTable::write_dep(&mut buf, glyphs, IndexToLocFormat::Short)

            .expect("unable to write glyf table");

        let glyf = buf.into_inner().into_boxed_slice();

        let mut loca_glyf = LocaGlyf::loaded(loca, glyf);

        let mut visitor = TestVisitor {};

        let mut context = GlyfVisitorContext::new(&mut loca_glyf, None);

        context

            .visit(1, None, &mut visitor)

            .expect("error visiting glyph outline");

    }

    #[test]

    fn variable_outlines() -> Result<(), ParseError> {

        let buffer = read_fixture("tests/fonts/variable/Inter[slnt,wght].abc.ttf");

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

        let font_file = scope.read::<OpenTypeFont<'_>>()?;

        let provider = font_file.table_provider(0)?;

        // Load the tables

        let fvar_data = provider.read_table_data(tag::FVAR)?;

        let fvar = ReadScope::new(&fvar_data).read::<FvarTable<'_>>().unwrap();

        let avar_data = provider.table_data(tag::AVAR)?;

        let avar = avar_data

            .as_ref()

            .map(|avar_data| ReadScope::new(avar_data).read::<AvarTable<'_>>())

            .transpose()?;

        let mut loca_glyf = LocaGlyf::load(&provider)?;

        let store = VariableGlyfContextStore::read(&provider)?;

        // Get the variation tuple

        //   Subfamily: ExtraBold Italic

        // Coordinates: [800.0, -10.0]

        let user_tuple = [Fixed::from(800), Fixed::from(-10)];

        let tuple = fvar.normalize(user_tuple.iter().copied(), avar.as_ref())?;

        // Visit the outlines

        let var_context = VariableGlyfContext::new(&store)?;

        let mut context = GlyfVisitorContext::new(&mut loca_glyf, Some(var_context));

        let mut visitor = TestVisitor {};

        context

            .visit(1, Some(&tuple), &mut visitor)

            .expect("error visiting glyph outline");

        Ok(())

    }

}