//! Implementation of `syn::parse::Parse` for styles, and associated helper data/functions.
// TODO make all parsers use HyphenWord where appropriate.
// TODO make all error messages nice
// TODO 100% test coverage
// TODO see if I can get https://github.com/rust-lang/rust/issues/67544 accepted. then change "em" to
// em and "ex" to ex.
// TODO Split out extra "Dynamic" layer for each type for use in proc macro (so we can have `{ <arbitary
// rust code> }`)
use crate::*;
use proc_macro2::Span;
use std::{
    cell::RefCell,
    collections::BTreeSet,
    fmt::{self, Write},
    ops::RangeBounds,
    str,
};
use syn::{
    ext::IdentExt,
    parse::{discouraged::Speculative, Parse, ParseStream},
    punctuated::Punctuated,
    spanned::Spanned,
    Ident, Token,
};

use super::{DynamicStyle, DynamicStyles, Styles};

impl Parse for DynamicStyles {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let punc = s.parse_terminated::<_, Token![;]>(<DynamicStyle as Parse>::parse)?;
        Ok(DynamicStyles::from(punc.into_iter().collect::<Vec<_>>()))
    }
}

impl Parse for Styles {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let punc = s.parse_terminated::<_, Token![;]>(<Style as Parse>::parse)?;
        Ok(Styles::from(punc.into_iter().collect::<Vec<_>>()))
    }
}

impl Parse for DynamicStyle {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        // Pass through brackets
        if s.peek(syn::token::Brace) {
            Ok(DynamicStyle::Dynamic(s.parse()?))
        } else {
            Ok(DynamicStyle::Literal(s.parse()?))
        }
    }
}

impl Parse for Style {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        if s.peek(syn::LitStr) {
            let unchecked: syn::LitStr = s.parse()?;
            return Ok(Style::Unchecked(unchecked.value()));
        }

        let name: HyphenWord = s.parse()?;
        if name.try_match("dummy") {
            return Ok(Style::Dummy);
        }

        s.parse::<Token![:]>()?;

        let output = if name.try_match("align-content") {
            Style::AlignContent(s.parse()?)
        } else if name.try_match("align-items") {
            Style::AlignItems(s.parse()?)
        } else if name.try_match("align-self") {
            Style::AlignSelf(s.parse()?)
        // all
        // background
        } else if name.try_match("background-attachment") {
            Style::BackgroundAttachment(s.parse()?)
        } else if name.try_match("background-blend-mode") {
            Style::BackgroundBlendMode(s.parse()?)
        } else if name.try_match("background-clip") {
            Style::BackgroundClip(s.parse()?)
        } else if name.try_match("background-color") {
            Style::BackgroundColor(s.parse()?)
        } else if name.try_match("background-image") {
            Style::BackgroundImage(s.parse()?)
        } else if name.try_match("background-origin") {
            Style::BackgroundOrigin(s.parse()?)
        } else if name.try_match("background-position") {
            Style::BackgroundPosition(s.parse()?)
        } else if name.try_match("background-repeat") {
            Style::BackgroundRepeat(s.parse()?)
        } else if name.try_match("background-size") {
            Style::BackgroundSize(s.parse()?)
        } else if name.try_match("border") {
            Style::Border(s.parse()?)
        } else if name.try_match("border-bottom") {
            Style::BorderBottom(s.parse()?)
        } else if name.try_match("border-bottom-color") {
            Style::BorderBottomColor(s.parse()?)
        } else if name.try_match("border-bottom-left-radius") {
            Style::BorderBottomLeftRadius(s.parse()?)
        } else if name.try_match("border-bottom-right-radius") {
            Style::BorderBottomRightRadius(s.parse()?)
        } else if name.try_match("border-bottom-style") {
            Style::BorderBottomStyle(s.parse()?)
        } else if name.try_match("border-bottom-width") {
            Style::BorderBottomWidth(s.parse()?)
        } else if name.try_match("border-collapse") {
            Style::BorderCollapse(s.parse()?)
        } else if name.try_match("border-color") {
            Style::BorderColor(s.parse()?)
        // border-image
        // border-image-outset
        // border-image-repeat
        // border-image-slice
        // border-image-source
        // border-image-width
        } else if name.try_match("border-left") {
            Style::BorderLeft(s.parse()?)
        } else if name.try_match("border-left-color") {
            Style::BorderLeftColor(s.parse()?)
        } else if name.try_match("border-left-style") {
            Style::BorderLeftStyle(s.parse()?)
        } else if name.try_match("border-left-width") {
            Style::BorderLeftWidth(s.parse()?)
        } else if name.try_match("border-radius") {
            Style::BorderRadius(s.parse()?)
        } else if name.try_match("border-right") {
            Style::BorderRight(s.parse()?)
        } else if name.try_match("border-right-color") {
            Style::BorderRightColor(s.parse()?)
        } else if name.try_match("border-right-style") {
            Style::BorderRightStyle(s.parse()?)
        } else if name.try_match("border-right-width") {
            Style::BorderRightWidth(s.parse()?)
        // border-spacing
        } else if name.try_match("border-style") {
            Style::BorderStyle(s.parse()?)
        } else if name.try_match("border-top") {
            Style::BorderTop(s.parse()?)
        } else if name.try_match("border-top-color") {
            Style::BorderTopColor(s.parse()?)
        } else if name.try_match("border-top-left-radius") {
            Style::BorderTopLeftRadius(s.parse()?)
        } else if name.try_match("border-top-right-radius") {
            Style::BorderTopRightRadius(s.parse()?)
        } else if name.try_match("border-top-style") {
            Style::BorderTopStyle(s.parse()?)
        } else if name.try_match("border-top-width") {
            Style::BorderTopWidth(s.parse()?)
        } else if name.try_match("border-width") {
            Style::BorderWidth(s.parse()?)
        } else if name.try_match("bottom") {
            Style::Bottom(s.parse()?)
        // box-decoration-break
        } else if name.try_match("box-shadow") {
            Style::BoxShadow(s.parse()?)
        } else if name.try_match("box-sizing") {
            Style::BoxSizing(s.parse()?)
        // break-after
        // break-before
        // break-inside
        // caption-side
        // caret-color
        } else if name.try_match("clear") {
            Style::Clear(s.parse()?)
        // clip
        // clip-path
        // clip-rule
        } else if name.try_match("column-count") {
            Style::ColumnCount(s.parse()?)
        } else if name.try_match("color") {
            Style::Color(s.parse()?)
        // contain
        // content
        // counter-increment
        // counter-reset
        // cue
        // cue-after
        // cue-before
        } else if name.try_match("cursor") {
            Style::Cursor(s.parse()?)
        // direction
        } else if name.try_match("display") {
            Style::Display(s.parse()?)
        // elevation
        // empty-cells
        // flex
        } else if name.try_match("flex-basis") {
            Style::FlexBasis(s.parse()?)
        } else if name.try_match("flex-direction") {
            Style::FlexDirection(s.parse()?)
        // flex-flow
        } else if name.try_match("flex-grow") {
            let number: Number = s.parse()?;
            if !number.suffix.is_empty() {
                return Err(syn::Error::new(number.span, "expected number"));
            }
            Style::FlexGrow(number.value)
        } else if name.try_match("flex-shrink") {
            let number: Number = s.parse()?;
            if !number.suffix.is_empty() {
                return Err(syn::Error::new(number.span, "expected number"));
            }
            Style::FlexShrink(number.value)
        } else if name.try_match("flex-wrap") {
            Style::FlexWrap(s.parse()?)
        } else if name.try_match("float") {
            Style::Float(s.parse()?)
        // font
        } else if name.try_match("font-family") {
            Style::FontFamily(s.parse()?)
        // font-feature-settings
        // font-kerning
        } else if name.try_match("font-size") {
            Style::FontSize(s.parse()?)
        // font-size-adjust
        // font-stretch
        } else if name.try_match("font-style") {
            Style::FontStyle(s.parse()?)
        // font-synthesis
        // font-variant
        // font-variant-caps
        // font-variant-east-asian
        // font-variant-ligatures
        // font-variant-numeric
        // font-variant-position
        } else if name.try_match("font-weight") {
            Style::FontWeight(s.parse()?)
        // glyph-orientation-vertical
        // grid
        // grid-area
        // grid-auto-columns
        // grid-auto-flow
        // grid-auto-rows
        // grid-column
        // grid-column-end
        // grid-column-start
        // grid-row
        // grid-row-end
        // grid-row-start
        // grid-template
        // grid-template-areas
        // grid-template-columns
        // grid-template-rows
        } else if name.try_match("height") {
            Style::Height(s.parse()?)
        // image-orientation
        // image-rendering
        // isolation
        } else if name.try_match("justify-content") {
            Style::JustifyContent(s.parse()?)
        } else if name.try_match("left") {
            Style::Left(s.parse()?)
        // letter-spacing
        } else if name.try_match("line-height") {
            Style::LineHeight(s.parse()?)
        // list-style
        // list-style-image
        // list-style-position
        } else if name.try_match("list-style-type") {
            Style::ListStyleType(s.parse()?)
        } else if name.try_match("margin") {
            Style::Margin(s.parse()?)
        } else if name.try_match("margin-bottom") {
            Style::MarginBottom(s.parse()?)
        } else if name.try_match("margin-left") {
            Style::MarginLeft(s.parse()?)
        } else if name.try_match("margin-right") {
            Style::MarginRight(s.parse()?)
        } else if name.try_match("margin-top") {
            Style::MarginTop(s.parse()?)
        // mask
        // mask-border
        // mask-border-mode
        // mask-border-outset
        // mask-border-repeat
        // mask-border-slice
        // mask-border-source
        // mask-border-width
        // mask-clip
        // mask-composite
        // mask-image
        // mask-mode
        // mask-origin
        // mask-position
        // mask-repeat
        // mask-size
        // mask-type
        } else if name.try_match("max-height") {
            Style::MaxHeight(s.parse()?)
        } else if name.try_match("max-width") {
            Style::MaxWidth(s.parse()?)
        } else if name.try_match("min-height") {
            Style::MinHeight(s.parse()?)
        } else if name.try_match("min-width") {
            Style::MinWidth(s.parse()?)
        // mix-blend-mode
        } else if name.try_match("object-fit") {
            Style::ObjectFit(s.parse()?)
        // object-position
        // opacity
        // order
        // orphans
        // outline
        // outline-color
        // outline-offset
        // outline-style
        // outline-width
        } else if name.try_match("overflow") {
            Style::Overflow(s.parse()?)
        } else if name.try_match("overflow-x") {
            Style::OverflowX(s.parse()?)
        } else if name.try_match("overflow-y") {
            Style::OverflowY(s.parse()?)
        } else if name.try_match("padding") {
            Style::Padding(s.parse()?)
        } else if name.try_match("padding-bottom") {
            Style::PaddingBottom(s.parse()?)
        } else if name.try_match("padding-left") {
            Style::PaddingLeft(s.parse()?)
        } else if name.try_match("padding-right") {
            Style::PaddingRight(s.parse()?)
        } else if name.try_match("padding-top") {
            Style::PaddingTop(s.parse()?)
        // page-break-after
        // page-break-before
        // page-break-inside
        // pause
        // pause-after
        // pause-before
        // pitch
        // pitch-range
        // play-during
        } else if name.try_match("position") {
            Style::Position(s.parse()?)
        // quotes
        } else if name.try_match("resize") {
            Style::Resize(s.parse()?)
        // richness
        } else if name.try_match("right") {
            Style::Right(s.parse()?)
        // scroll-margin
        // scroll-margin-block
        // scroll-margin-block-end
        // scroll-margin-block-start
        // scroll-margin-bottom
        // scroll-margin-inline
        // scroll-margin-inline-end
        // scroll-margin-inline-start
        // scroll-margin-left
        // scroll-margin-right
        // scroll-margin-top
        // scroll-padding
        // scroll-padding-block
        // scroll-padding-block-end
        // scroll-padding-block-start
        // scroll-padding-bottom
        // scroll-padding-inline
        // scroll-padding-inline-end
        // scroll-padding-inline-start
        // scroll-padding-left
        // scroll-padding-right
        // scroll-padding-top
        // scroll-snap-align
        // scroll-snap-stop
        // scroll-snap-type
        // shape-image-threshold
        // shape-margin
        // shape-outside
        // speak
        // speak-header
        // speak-numeral
        // speak-punctuation
        // speech-rate
        // stress
        // table-layout
        } else if name.try_match("text-align") {
            Style::TextAlign(s.parse()?)
        // text-combine-upright
        // text-decoration
        // text-decoration-color
        // text-decoration-line
        // text-decoration-style
        // text-emphasis
        // text-emphasis-color
        // text-emphasis-position
        // text-emphasis-style
        // text-indent
        // text-orientation
        // text-overflow
        // text-shadow
        // text-transform
        // text-underline-position
        } else if name.try_match("top") {
            Style::Top(s.parse()?)
        // transform
        // transform-box
        // transform-origin
        // unicode-bidi
        // vertical-align
        // visibility
        // voice-family
        // volume
        } else if name.try_match("white-space") {
            Style::WhiteSpace(s.parse()?)
        } else if name.try_match("widows") {
            Style::Widows(integer(s, 1..)?)
        } else if name.try_match("width") {
            Style::Width(s.parse()?)
        // will-change
        // word-spacing
        // writing-mode
        // z-index
        } else {
            return Err(name.error());
        };

        if !finished_rule(s) {
            return Err(s.error("unexpected trailing tokens in style rule"));
        }

        Ok(output)
    }
}

impl Parse for AlignContent {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name: HyphenWord = s.parse()?;

        if name.try_match("flex-start") {
            Ok(AlignContent::FlexStart)
        } else if name.try_match("flex-end") {
            Ok(AlignContent::FlexEnd)
        } else if name.try_match("center") {
            Ok(AlignContent::Center)
        } else if name.try_match("space-between") {
            Ok(AlignContent::SpaceBetween)
        } else if name.try_match("space-around") {
            Ok(AlignContent::SpaceAround)
        } else if name.try_match("stretch") {
            Ok(AlignContent::Stretch)
        } else {
            Err(name.error())
        }
    }
}

#[test]
fn test_align_content() {
    for test in vec![
        "flex-start",
        "flex-end",
        "center",
        "space-between",
        "space-around",
        "stretch",
    ] {
        assert_eq!(
            &syn::parse_str::<AlignContent>(test).unwrap().to_string(),
            test
        );
    }
    assert_eq!(
        &syn::parse_str::<Style>("align-content:flex-start")
            .unwrap()
            .to_string(),
        "align-content:flex-start"
    );
}

impl Parse for AlignItems {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("normal") {
            Ok(AlignItems::Normal)
        } else if word.try_match("stretch") {
            Ok(AlignItems::Stretch)
        } else if word.try_match("center") {
            Ok(AlignItems::Center)
        } else if word.try_match("start") {
            Ok(AlignItems::Start)
        } else if word.try_match("end") {
            Ok(AlignItems::End)
        } else if word.try_match("flex-start") {
            Ok(AlignItems::FlexStart)
        } else if word.try_match("flex-end") {
            Ok(AlignItems::FlexEnd)
        } else if word.try_match("baseline") {
            Ok(AlignItems::Baseline)
        } else if word.try_match("first") {
            let word: HyphenWord = s.parse()?;
            if word.try_match("baseline") {
                Ok(AlignItems::FirstBaseline)
            } else {
                Err(word.error())
            }
        } else if word.try_match("last") {
            let word: HyphenWord = s.parse()?;
            if word.try_match("baseline") {
                Ok(AlignItems::LastBaseline)
            } else {
                Err(word.error())
            }
        } else if word.try_match("safe") {
            let word: HyphenWord = s.parse()?;
            if word.try_match("center") {
                Ok(AlignItems::SafeCenter)
            } else {
                Err(word.error())
            }
        } else if word.try_match("unsafe") {
            let word: HyphenWord = s.parse()?;
            if word.try_match("center") {
                Ok(AlignItems::UnsafeCenter)
            } else {
                Err(word.error())
            }
        } else {
            Err(word.error())
        }
    }
}

impl Parse for AlignSelf {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("auto") {
            Ok(AlignSelf::Auto)
        } else if word.try_match("normal") {
            Ok(AlignSelf::Normal)
        } else if word.try_match("center") {
            Ok(AlignSelf::Center)
        } else if word.try_match("start") {
            Ok(AlignSelf::Start)
        } else if word.try_match("self-start") {
            Ok(AlignSelf::SelfStart)
        } else if word.try_match("self-end") {
            Ok(AlignSelf::SelfEnd)
        } else if word.try_match("flex-start") {
            Ok(AlignSelf::FlexStart)
        } else if word.try_match("flex-end") {
            Ok(AlignSelf::FlexEnd)
        } else if word.try_match("baseline") {
            Ok(AlignSelf::Baseline)
        } else if word.try_match("first") {
            let word: HyphenWord = s.parse()?;
            if word.try_match("baseline") {
                Ok(AlignSelf::FirstBaseline)
            } else {
                Err(word.error())
            }
        } else if word.try_match("last") {
            let word: HyphenWord = s.parse()?;
            if word.try_match("baseline") {
                Ok(AlignSelf::LastBaseline)
            } else {
                Err(word.error())
            }
        } else if word.try_match("stretch") {
            Ok(AlignSelf::Stretch)
        } else if word.try_match("safe") {
            let word: HyphenWord = s.parse()?;
            if word.try_match("center") {
                Ok(AlignSelf::SafeCenter)
            } else {
                Err(word.error())
            }
        } else if word.try_match("unsafe") {
            let word: HyphenWord = s.parse()?;
            if word.try_match("center") {
                Ok(AlignSelf::UnsafeCenter)
            } else {
                Err(word.error())
            }
        } else {
            Err(word.error())
        }
    }
}

impl Parse for BackgroundAttachment {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("scroll") {
            Ok(BackgroundAttachment::Scroll)
        } else if word.try_match("fixed") {
            Ok(BackgroundAttachment::Fixed)
        } else if word.try_match("local") {
            Ok(BackgroundAttachment::Local)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for BlendMode {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("normal") {
            Ok(BlendMode::Normal)
        } else if word.try_match("multiply") {
            Ok(BlendMode::Multiply)
        } else if word.try_match("screen") {
            Ok(BlendMode::Screen)
        } else if word.try_match("overlay") {
            Ok(BlendMode::Overlay)
        } else if word.try_match("darken") {
            Ok(BlendMode::Darken)
        } else if word.try_match("lighten") {
            Ok(BlendMode::Lighten)
        } else if word.try_match("color-dodge") {
            Ok(BlendMode::ColorDodge)
        } else if word.try_match("color-burn") {
            Ok(BlendMode::ColorBurn)
        } else if word.try_match("hard-light") {
            Ok(BlendMode::HardLight)
        } else if word.try_match("soft-light") {
            Ok(BlendMode::SoftLight)
        } else if word.try_match("difference") {
            Ok(BlendMode::Difference)
        } else if word.try_match("exclusion") {
            Ok(BlendMode::Exclusion)
        } else if word.try_match("hue") {
            Ok(BlendMode::Hue)
        } else if word.try_match("saturation") {
            Ok(BlendMode::Saturation)
        } else if word.try_match("color") {
            Ok(BlendMode::Color)
        } else if word.try_match("luminosity") {
            Ok(BlendMode::Luminosity)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for BackgroundImage {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let peek = HyphenWord::peek_specific(s);
        if peek.as_ref().map(|s| s.as_str()) == Some("url") {
            let url;
            syn::parenthesized!(url in s);
            let url = url.parse::<syn::LitStr>()?;
            Ok(BackgroundImage::Url(url.value()))
        } else {
            let word: HyphenWord = s.parse()?;
            word.add_expected("url");
            if word.try_match("none") {
                Ok(BackgroundImage::None)
            } else {
                Err(word.error())
            }
        }
    }
}

impl Parse for BackgroundBox {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("border-box") {
            Ok(BackgroundBox::BorderBox)
        } else if word.try_match("padding-box") {
            Ok(BackgroundBox::PaddingBox)
        } else if word.try_match("content-box") {
            Ok(BackgroundBox::ContentBox)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for BackgroundPosition {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("top") {
            Ok(BackgroundPosition::Top)
        } else if word.try_match("bottom") {
            Ok(BackgroundPosition::Bottom)
        } else if word.try_match("left") {
            Ok(BackgroundPosition::Left)
        } else if word.try_match("right") {
            Ok(BackgroundPosition::Right)
        } else if word.try_match("center") {
            Ok(BackgroundPosition::Center)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for BackgroundRepeat {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("repeat-x") {
            Ok(BackgroundRepeat::RepeatX)
        } else if word.try_match("repeat-y") {
            Ok(BackgroundRepeat::RepeatY)
        } else if let Ok(v) = s.parse() {
            Ok(BackgroundRepeat::SingleOrDouble(v))
        } else {
            word.add_expected("repeat");
            word.add_expected("space");
            word.add_expected("round");
            word.add_expected("no-repeat");
            Err(word.error())
        }
    }
}

impl Parse for BgRepeatPart {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("repeat") {
            Ok(BgRepeatPart::Repeat)
        } else if word.try_match("space") {
            Ok(BgRepeatPart::Space)
        } else if word.try_match("round") {
            Ok(BgRepeatPart::Round)
        } else if word.try_match("no-repeat") {
            Ok(BgRepeatPart::NoRepeat)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for BackgroundSize {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("cover") {
            Ok(BackgroundSize::Cover)
        } else if word.try_match("contain") {
            Ok(BackgroundSize::Contain)
        } else if let Ok(v) = s.parse() {
            Ok(BackgroundSize::SingleOrDouble(v))
        } else {
            word.add_expected("<length>");
            word.add_expected("<percentage>");
            word.add_expected("auto");
            Err(word.error())
        }
    }
}

impl Parse for Border {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        fn line_width_error(span: Span) -> syn::Error {
            syn::Error::new(span, "the border width was specified more than once")
        }
        fn line_style_error(span: Span) -> syn::Error {
            syn::Error::new(span, "the border style was specified more than once")
        }
        fn color_error(span: Span) -> syn::Error {
            syn::Error::new(span, "the border color was specified more than once")
        }
        let mut border = Border::new();
        while !(border.is_full() || finished_rule(s)) {
            let mut matched_something = false; // prevents an infinite loop when no matches
            let width_fork = s.fork();
            match width_fork.parse::<LineWidth>() {
                Ok(line_width) => {
                    if border.has_line_width() {
                        return Err(line_width_error(width_fork.cursor().span()));
                    }
                    matched_something = true;
                    border.line_width = Some(line_width);
                    s.advance_to(&width_fork);
                }
                Err(_) => (),
            }
            let style_fork = s.fork();
            match style_fork.parse::<LineStyle>() {
                Ok(line_style) => {
                    if border.has_line_style() {
                        return Err(line_style_error(style_fork.cursor().span()));
                    }
                    matched_something = true;
                    border.line_style = Some(line_style);
                    s.advance_to(&style_fork);
                }
                Err(_) => (),
            }
            let color_fork = s.fork();
            match color_fork.parse::<Color>() {
                Ok(color) => {
                    if border.has_color() {
                        return Err(color_error(color_fork.cursor().span()));
                    }
                    matched_something = true;
                    border.color = Some(color);
                    s.advance_to(&color_fork);
                }
                Err(_) => (),
            }
            if !(matched_something || finished_rule(s)) {
                return Err(syn::Error::new(
                    s.cursor().span(),
                    "unexpected input - expected one of border-width, border-style, color",
                ));
            }
        }
        Ok(border)
    }
}

#[test]
fn test_border_color() {
    for (input, output) in vec![
        ("black", Rect::All(Color::Black)),
        (
            "#fff blue",
            Rect::VerticalHorizontal(Color::HexRGB(255, 255, 255), Color::Blue),
        ),
        (
            "blue hsl(20, 5%, 100%) white",
            Rect::TopHorizontalBottom(Color::Blue, Color::HSL(20.0, 5.0, 100.0), Color::White),
        ),
        (
            "hsla(20, 5%, 100%, 0.2) #fff #ccc white",
            Rect::TopRightBottomLeft(
                Color::HSLA(20.0, 5.0, 100.0, 0.2),
                Color::HexRGB(255, 255, 255),
                Color::HexRGB(204, 204, 204),
                Color::White,
            ),
        ),
    ] {
        assert_eq!(syn::parse_str::<Rect<Color>>(input).unwrap(), output);
    }
}

#[test]
fn test_border_width() {
    for (input, output) in vec![
        ("1px", BorderWidth::All(LineWidth::Length(Length::Px(1.0)))),
        (
            "1px 2\"em\"",
            BorderWidth::VerticalHorizontal(
                LineWidth::Length(Length::Px(1.0)),
                LineWidth::Length(Length::Em(2.0)),
            ),
        ),
        (
            "2\"em\" medium thick",
            BorderWidth::TopHorizontalBottom(
                LineWidth::Length(Length::Em(2.0)),
                LineWidth::Medium,
                LineWidth::Thick,
            ),
        ),
        (
            "2\"em\" medium 1px thick",
            BorderWidth::TopRightBottomLeft(
                LineWidth::Length(Length::Em(2.0)),
                LineWidth::Medium,
                LineWidth::Length(Length::Px(1.0)),
                LineWidth::Thick,
            ),
        ),
    ] {
        assert_eq!(syn::parse_str::<BorderWidth>(input).unwrap(), output);
    }

    for input in vec!["thi", "1px 1px 1px 1px 1px"] {
        assert!(syn::parse_str::<BorderWidth>(input).is_err());
    }
}

impl Parse for BorderCollapse {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("collapse") {
            Ok(BorderCollapse::Collapse)
        } else if word.try_match("separate") {
            Ok(BorderCollapse::Separate)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for BoxShadow {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        syn::custom_keyword!(none);
        if s.peek(none) {
            s.parse::<none>()?;
            Ok(BoxShadow::None)
        } else {
            Ok(BoxShadow::Shadows(s.parse()?))
        }
    }
}

impl Parse for BoxSizing {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("border-box") {
            Ok(BoxSizing::BorderBox)
        } else if word.try_match("content-box") {
            Ok(BoxSizing::ContentBox)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for Clear {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("none") {
            Ok(Clear::None)
        } else if word.try_match("left") {
            Ok(Clear::Left)
        } else if word.try_match("right") {
            Ok(Clear::Right)
        } else if word.try_match("both") {
            Ok(Clear::Both)
        } else if word.try_match("inline-start") {
            Ok(Clear::InlineStart)
        } else if word.try_match("inline-end") {
            Ok(Clear::InlineEnd)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for ColumnCount {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        if s.peek(syn::LitInt) {
            Ok(ColumnCount::Fixed(s.parse::<Integer<u32>>()?.into_inner()))
        } else {
            let word: HyphenWord = s.parse()?;
            word.add_expected("integer");
            if word.try_match("auto") {
                Ok(ColumnCount::Auto)
            } else {
                Err(word.error())
            }
        }
    }
}

#[test]
fn test_clear() {
    for (input, output) in vec![
        ("none", Clear::None),
        ("left", Clear::Left),
        ("right", Clear::Right),
        ("both", Clear::Both),
        ("inline-start", Clear::InlineStart),
        ("inline-end", Clear::InlineEnd),
    ] {
        assert_eq!(syn::parse_str::<Clear>(input).unwrap(), output);
    }
}

impl Parse for Cursor {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("auto") {
            Ok(Cursor::Auto)
        } else if word.try_match("default") {
            Ok(Cursor::Default)
        } else if word.try_match("none") {
            Ok(Cursor::None)
        } else if word.try_match("context-menu") {
            Ok(Cursor::ContextMenu)
        } else if word.try_match("help") {
            Ok(Cursor::Help)
        } else if word.try_match("pointer") {
            Ok(Cursor::Pointer)
        } else if word.try_match("progress") {
            Ok(Cursor::Progress)
        } else if word.try_match("wait") {
            Ok(Cursor::Wait)
        } else if word.try_match("cell") {
            Ok(Cursor::Cell)
        } else if word.try_match("crosshair") {
            Ok(Cursor::Crosshair)
        } else if word.try_match("text") {
            Ok(Cursor::Text)
        } else if word.try_match("vertical-text") {
            Ok(Cursor::VerticalText)
        } else if word.try_match("alias") {
            Ok(Cursor::Alias)
        } else if word.try_match("copy") {
            Ok(Cursor::Copy)
        } else if word.try_match("move") {
            Ok(Cursor::Move)
        } else if word.try_match("no-drop") {
            Ok(Cursor::NoDrop)
        } else if word.try_match("not-allowed") {
            Ok(Cursor::NotAllowed)
        } else if word.try_match("grab") {
            Ok(Cursor::Grab)
        } else if word.try_match("grabbing") {
            Ok(Cursor::Grabbing)
        } else if word.try_match("e-resize") {
            Ok(Cursor::EResize)
        } else if word.try_match("n-resize") {
            Ok(Cursor::NResize)
        } else if word.try_match("ne-resize") {
            Ok(Cursor::NEResize)
        } else if word.try_match("nw-resize") {
            Ok(Cursor::NWResize)
        } else if word.try_match("s-resize") {
            Ok(Cursor::SResize)
        } else if word.try_match("se-resize") {
            Ok(Cursor::SEResize)
        } else if word.try_match("sw-resize") {
            Ok(Cursor::SWResize)
        } else if word.try_match("w-resize") {
            Ok(Cursor::WResize)
        } else if word.try_match("ew-resize") {
            Ok(Cursor::EWResize)
        } else if word.try_match("ns-resize") {
            Ok(Cursor::NSResize)
        } else if word.try_match("nesw-resize") {
            Ok(Cursor::NESWResize)
        } else if word.try_match("nwse-resize") {
            Ok(Cursor::NWSEResize)
        } else if word.try_match("col-resize") {
            Ok(Cursor::ColResize)
        } else if word.try_match("row-resize") {
            Ok(Cursor::RowResize)
        } else if word.try_match("all-scroll") {
            Ok(Cursor::AllScroll)
        } else if word.try_match("zoom-in") {
            Ok(Cursor::ZoomIn)
        } else if word.try_match("zoom-out") {
            Ok(Cursor::ZoomOut)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for Display {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("block") {
            Ok(Display::Block)
        } else if word.try_match("flex") {
            Ok(Display::Flex)
        } else if word.try_match("inline") {
            Ok(Display::Inline)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for FlexBasis {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        syn::custom_keyword!(content);

        if s.peek(content) {
            s.parse::<content>()?;
            Ok(FlexBasis::Content)
        } else {
            let w: Width21 = s.parse()?;
            Ok(FlexBasis::Width(w))
        }
    }
}

impl Parse for FlexDirection {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("column") {
            Ok(FlexDirection::Column)
        } else if word.try_match("row") {
            Ok(FlexDirection::Row)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for FlexWrap {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("wrap") {
            Ok(FlexWrap::Wrap)
        } else if word.try_match("nowrap") {
            Ok(FlexWrap::Nowrap)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for Float {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("none") {
            Ok(Float::None)
        } else if word.try_match("left") {
            Ok(Float::Left)
        } else if word.try_match("right") {
            Ok(Float::Right)
        } else if word.try_match("inline-start") {
            Ok(Float::InlineStart)
        } else if word.try_match("inline-end") {
            Ok(Float::InlineEnd)
        } else {
            Err(word.error())
        }
    }
}

impl Parse for Font {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        if s.peek(syn::LitStr) {
            Ok(Font::Named(s.parse::<syn::LitStr>()?.value()))
        } else {
            let name: HyphenWord = s.parse()?;
            name.add_expected("named font");

            if name.try_match("serif") {
                Ok(Font::Serif)
            } else if name.try_match("sans-serif") {
                Ok(Font::SansSerif)
            } else if name.try_match("cursive") {
                Ok(Font::Cursive)
            } else if name.try_match("fantasy") {
                Ok(Font::Fantasy)
            } else if name.try_match("monospace") {
                Ok(Font::Fantasy)
            } else {
                Err(name.error())
            }
        }
    }
}

#[test]
fn test_font_family() {
    for (input, output) in vec![
        (
            "cursive",
            FontFamily {
                first: Font::Cursive,
                rest: vec![],
            },
        ),
        (
            "\"Amatic SC\", sans-serif",
            FontFamily {
                first: Font::Named("Amatic SC".to_string()),
                rest: vec![Font::SansSerif],
            },
        ),
    ] {
        assert_eq!(syn::parse_str::<FontFamily>(input).unwrap(), output);
    }

    for val in vec![
        "font-family:\"Font Awesome 5 Free\"",
        "font-family:\"Some Name\",\"Another Name\",serif",
    ] {
        assert_eq!(&syn::parse_str::<Style>(val).unwrap().to_string(), val);
    }
}

impl Parse for FontSize {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word_fork = s.fork();
        let name: HyphenWord = word_fork.parse()?;

        if name.try_match("xx-small") {
            s.advance_to(&word_fork);
            Ok(FontSize::XXSmall)
        } else if name.try_match("x-small") {
            s.advance_to(&word_fork);
            Ok(FontSize::XSmall)
        } else if name.try_match("small") {
            s.advance_to(&word_fork);
            Ok(FontSize::Small)
        } else if name.try_match("medium") {
            s.advance_to(&word_fork);
            Ok(FontSize::Medium)
        } else if name.try_match("large") {
            s.advance_to(&word_fork);
            Ok(FontSize::Large)
        } else if name.try_match("x-large") {
            s.advance_to(&word_fork);
            Ok(FontSize::XLarge)
        } else if name.try_match("xx-large") {
            s.advance_to(&word_fork);
            Ok(FontSize::XXLarge)
        } else if name.try_match("xxx-large") {
            s.advance_to(&word_fork);
            Ok(FontSize::XXXLarge)
        } else if name.try_match("larger") {
            s.advance_to(&word_fork);
            Ok(FontSize::Larger)
        } else if name.try_match("smaller") {
            s.advance_to(&word_fork);
            Ok(FontSize::Smaller)
        } else {
            s.parse().map(FontSize::LengthPercentage).map_err(|_| {
                name.add_expected("length");
                name.add_expected("percentage");
                name.error()
            })
        }
    }
}
impl Parse for FontStyle {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name: HyphenWord = s.parse()?;

        if name.try_match("normal") {
            Ok(FontStyle::Normal)
        } else if name.try_match("italic") {
            Ok(FontStyle::Italic)
        } else if name.try_match("oblique") {
            Ok(FontStyle::Oblique)
        } else {
            Err(name.error())
        }
    }
}

#[test]
fn test_font_style() {
    for (input, output) in vec![
        ("normal", FontStyle::Normal),
        ("italic", FontStyle::Italic),
        ("oblique", FontStyle::Oblique),
    ] {
        assert_eq!(syn::parse_str::<FontStyle>(input).unwrap(), output);
    }

    for input in vec!["norma", "normal trailing"] {
        assert!(syn::parse_str::<FontStyle>(input).is_err());
    }
}

impl Parse for FontWeight {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name: HyphenWord = s.parse()?;
        name.add_expected("number where 1 <= number <= 1000");

        if name.try_match("normal") {
            Ok(FontWeight::Normal)
        } else if name.try_match("bold") {
            Ok(FontWeight::Bold)
        } else if name.try_match("lighter") {
            Ok(FontWeight::Lighter)
        } else if name.try_match("bolder") {
            Ok(FontWeight::Bolder)
        } else {
            let n: Number = s.parse().map_err(|_| name.error())?;
            if n.suffix.is_empty() && n.value >= 1.0 && n.value <= 1000.0 {
                Ok(FontWeight::Number(n.value))
            } else {
                Err(name.error())
            }
        }
    }
}

#[test]
fn test_font_weight() {
    for (input, output) in vec![
        ("normal", FontWeight::Normal),
        ("bold", FontWeight::Bold),
        ("lighter", FontWeight::Lighter),
        ("bolder", FontWeight::Bolder),
        ("1", FontWeight::Number(1.0)),
        ("1.0", FontWeight::Number(1.0)),
        ("1000", FontWeight::Number(1000.0)),
        ("1000.0", FontWeight::Number(1000.0)),
        ("246.15", FontWeight::Number(246.15)),
    ] {
        match syn::parse_str::<FontWeight>(input) {
            Ok(v) => assert_eq!(v, output),
            Err(e) => panic!("error parsing {}: {}", input, e),
        }
    }
}

impl Parse for JustifyContent {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name: HyphenWord = s.parse()?;

        if name.try_match("flex-start") {
            Ok(JustifyContent::FlexStart)
        } else if name.try_match("flex-end") {
            Ok(JustifyContent::FlexEnd)
        } else if name.try_match("center") {
            Ok(JustifyContent::Center)
        } else if name.try_match("space-between") {
            Ok(JustifyContent::SpaceBetween)
        } else if name.try_match("space-around") {
            Ok(JustifyContent::SpaceAround)
        } else if name.try_match("start") {
            // - not in level 1 spec
            Ok(JustifyContent::FlexStart)
        } else if name.try_match("end") {
            // - not in level 1 spec
            Ok(JustifyContent::FlexEnd)
        } else {
            Err(name.error())
        }
    }
}

impl Parse for Length {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let neg = if s.peek(Token![-]) {
            s.parse::<Token![-]>()?;
            true
        } else {
            false
        };
        let n: Number = s.parse()?;
        Length::parse_from_number(n, neg)
    }
}

impl Length {
    fn parse_from_number(n: Number, neg: bool) -> syn::Result<Self> {
        let neg = if neg { -1.0 } else { 1.0 };
        if n.suffix == "em" {
            Ok(Length::Em(n.value * neg))
        } else if n.suffix == "ex" {
            Ok(Length::Ex(n.value * neg))
        } else if n.suffix == "in" {
            Ok(Length::In(n.value * neg))
        } else if n.suffix == "cm" {
            Ok(Length::Cm(n.value * neg))
        } else if n.suffix == "mm" {
            Ok(Length::Mm(n.value * neg))
        } else if n.suffix == "pt" {
            Ok(Length::Pt(n.value * neg))
        } else if n.suffix == "pc" {
            Ok(Length::Pc(n.value * neg))
        } else if n.suffix == "px" {
            Ok(Length::Px(n.value * neg))
        } else if n.suffix == "" && n.value == 0.0 {
            Ok(Length::Zero)
        } else {
            // No matches so return error
            Err(syn::Error::new(
                n.span,
                "expected one of `\"em\"`, `\"ex\"`, `in`, `cm`, `mm`, `pt`, `pc`, `px` after number, or 0",
            ))
        }
    }
}

impl Parse for LineStyle {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name = s.parse::<HyphenWord>()?;
        if name.try_match("none") {
            Ok(LineStyle::None)
        } else if name.try_match("hidden") {
            Ok(LineStyle::Hidden)
        } else if name.try_match("dotted") {
            Ok(LineStyle::Dotted)
        } else if name.try_match("dashed") {
            Ok(LineStyle::Dashed)
        } else if name.try_match("solid") {
            Ok(LineStyle::Solid)
        } else if name.try_match("double") {
            Ok(LineStyle::Double)
        } else if name.try_match("groove") {
            Ok(LineStyle::Groove)
        } else if name.try_match("ridge") {
            Ok(LineStyle::Ridge)
        } else if name.try_match("inset") {
            Ok(LineStyle::Inset)
        } else if name.try_match("outset") {
            Ok(LineStyle::Outset)
        } else {
            Err(name.error())
        }
    }
}

impl Parse for LineWidth {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name = s.parse::<HyphenWord>()?;
        if name.try_match("thin") {
            Ok(LineWidth::Thin)
        } else if name.try_match("medium") {
            Ok(LineWidth::Medium)
        } else if name.try_match("thick") {
            Ok(LineWidth::Thick)
        } else {
            match s.parse::<Length>() {
                Ok(l) => Ok(LineWidth::Length(l)),
                Err(_) => {
                    name.add_expected("length");
                    Err(name.error())
                }
            }
        }
    }
}

#[test]
fn test_parse_line_width() {
    assert_eq!(
        syn::parse_str::<LineWidth>("thin").unwrap(),
        LineWidth::Thin
    );
}

impl Parse for LineHeight {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        Ok(LineHeight(s.parse::<syn::LitFloat>()?.base10_parse()?))
    }
}

impl Parse for ListStyleType {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name: HyphenWord = s.parse()?;

        if name.try_match("disc") {
            Ok(ListStyleType::Disc)
        } else if name.try_match("circle") {
            Ok(ListStyleType::Circle)
        } else if name.try_match("square") {
            Ok(ListStyleType::Square)
        } else if name.try_match("decimal") {
            Ok(ListStyleType::Decimal)
        } else if name.try_match("decimal-leading-zero") {
            Ok(ListStyleType::DecimalLeadingZero)
        } else if name.try_match("lower-roman") {
            Ok(ListStyleType::LowerRoman)
        } else if name.try_match("upper-roman") {
            Ok(ListStyleType::UpperRoman)
        } else if name.try_match("lower-greek") {
            Ok(ListStyleType::LowerGreek)
        } else if name.try_match("upper-greek") {
            Ok(ListStyleType::UpperGreek)
        } else if name.try_match("lower-latin") {
            Ok(ListStyleType::LowerLatin)
        } else if name.try_match("upper-latin") {
            Ok(ListStyleType::UpperLatin)
        } else if name.try_match("armenian") {
            Ok(ListStyleType::Armenian)
        } else if name.try_match("georgian") {
            Ok(ListStyleType::Georgian)
        } else if name.try_match("lower-alpha") {
            Ok(ListStyleType::LowerAlpha)
        } else if name.try_match("upper-alpha") {
            Ok(ListStyleType::UpperAlpha)
        } else if name.try_match("none") {
            Ok(ListStyleType::None)
        } else {
            Err(name.error())
        }
    }
}

impl Parse for MaxWidthHeight {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name = s.parse::<HyphenWord>()?;
        name.add_expected("length");
        name.add_expected("percentage");
        if name.try_match("none") {
            Ok(MaxWidthHeight::None)
        } else if name.try_match("min-content") {
            Ok(MaxWidthHeight::MinContent)
        } else if name.try_match("max-content") {
            Ok(MaxWidthHeight::MaxContent)
        } else if name.try_match("fit-content") {
            let content;
            syn::parenthesized!(content in s);
            Ok(MaxWidthHeight::FitContent(content.parse()?))
        } else {
            s.parse()
                .map(|lp| MaxWidthHeight::LengthPercentage(lp))
                .map_err(|_| name.error())
        }
    }
}

#[test]
fn test_max_width_height() {
    let style: Style = syn::parse_str("max-width: 200px").unwrap();
    assert_eq!(&style.to_string(), "max-width:200px");
}

impl<T> Parse for Rect<T>
where
    T: Parse,
{
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let first = s.parse::<T>()?;
        let fork = s.fork();
        let second = match fork.parse::<T>() {
            Ok(v) => {
                s.advance_to(&fork);
                v
            }
            Err(_) => return Ok(Rect::All(first)),
        };
        let third = match fork.parse::<T>() {
            Ok(v) => {
                s.advance_to(&fork);
                v
            }
            Err(_) => return Ok(Rect::VerticalHorizontal(first, second)),
        };
        match fork.parse::<T>() {
            Ok(v) => {
                s.advance_to(&fork);
                Ok(Rect::TopRightBottomLeft(first, second, third, v))
            }
            Err(_) => Ok(Rect::TopHorizontalBottom(first, second, third)),
        }
    }
}

impl Parse for AutoLengthPercentage {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        syn::custom_keyword!(auto);
        if s.peek(auto) {
            s.parse::<auto>()?;
            Ok(AutoLengthPercentage::Auto)
        } else {
            Ok(AutoLengthPercentage::LengthPercentage(s.parse()?))
        }
    }
}

impl Parse for ObjectFit {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name: HyphenWord = s.parse()?;
        if name.try_match("fill") {
            Ok(ObjectFit::Fill)
        } else if name.try_match("none") {
            Ok(ObjectFit::None)
        } else if name.try_match("contain") {
            if s.is_empty() {
                Ok(ObjectFit::Contain { scale_down: false })
            } else {
                let scale_down_word: HyphenWord = s.parse()?;
                if scale_down_word.try_match("scale-down") {
                    Ok(ObjectFit::Contain { scale_down: true })
                } else {
                    Err(scale_down_word.error())
                }
            }
        } else if name.try_match("cover") {
            if HyphenWord::peek(s) {
                let scale_down_word: HyphenWord = s.parse()?;
                if scale_down_word.try_match("scale-down") {
                    Ok(ObjectFit::Cover { scale_down: true })
                } else {
                    Err(scale_down_word.error())
                }
            } else {
                Ok(ObjectFit::Cover { scale_down: false })
            }
        } else if name.try_match("scale-down") {
            if HyphenWord::peek(s) {
                let cover_contain: HyphenWord = s.parse()?;
                if cover_contain.try_match("cover") {
                    Ok(ObjectFit::Cover { scale_down: true })
                } else if cover_contain.try_match("contain") {
                    Ok(ObjectFit::Contain { scale_down: true })
                } else {
                    Err(cover_contain.error())
                }
            } else {
                // defaults to contain when cover/contain not present
                Ok(ObjectFit::Contain { scale_down: true })
            }
        } else {
            Err(name.error())
        }
    }
}

impl Parse for Overflow {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let first = s.parse::<OverflowXY>()?;
        Ok(match s.parse::<OverflowXY>() {
            Ok(second) => Overflow::XY(first, second),
            Err(_) => Overflow::Both(first),
        })
    }
}

impl Parse for OverflowXY {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name: HyphenWord = s.parse()?;

        if name.try_match("visible") {
            Ok(OverflowXY::Visible)
        } else if name.try_match("hidden") {
            Ok(OverflowXY::Hidden)
        } else if name.try_match("clip") {
            Ok(OverflowXY::Clip)
        } else if name.try_match("scroll") {
            Ok(OverflowXY::Scroll)
        } else if name.try_match("auto") {
            Ok(OverflowXY::Auto)
        } else {
            Err(name.error())
        }
    }
}

impl Parse for Position {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name: HyphenWord = s.parse()?;
        if name.try_match("static") {
            Ok(Position::Static)
        } else if name.try_match("relative") {
            Ok(Position::Relative)
        } else if name.try_match("absolute") {
            Ok(Position::Absolute)
        } else if name.try_match("fixed") {
            Ok(Position::Fixed)
        } else {
            Err(name.error())
        }
    }
}

#[test]
fn test_padding() {
    for (input, output) in vec![(
        "padding:1\"em\"",
        Style::Padding(Padding::All(Calc::Normal(LengthPercentage::Length(
            Length::Em(1.0),
        )))),
    )] {
        assert_eq!(syn::parse_str::<Style>(input).unwrap(), output);
    }
}

impl Parse for Percentage {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let n: Number = s.parse()?;
        if n.suffix == "%" {
            Ok(Percentage(n.value))
        } else {
            Err(syn::Error::new(n.span, "expected percentage"))
        }
    }
}

impl Parse for WhiteSpace {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name: HyphenWord = s.parse()?;
        if name.try_match("normal") {
            Ok(WhiteSpace::Normal)
        } else if name.try_match("pre") {
            Ok(WhiteSpace::Pre)
        } else if name.try_match("nowrap") {
            Ok(WhiteSpace::Nowrap)
        } else if name.try_match("pre-wrap") {
            Ok(WhiteSpace::PreWrap)
        } else if name.try_match("pre-line") {
            Ok(WhiteSpace::PreLine)
        } else {
            Err(name.error())
        }
    }
}

impl Parse for Width21 {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        syn::custom_keyword!(auto);

        if s.peek(auto) {
            s.parse::<auto>()?;
            Ok(Width21::Auto)
        } else {
            Ok(Width21::LengthPercentage(s.parse()?))
        }
    }
}

impl Parse for WidthHeight {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let fork = s.fork();
        let name: HyphenWord = fork.parse()?;

        if name.try_match("auto") {
            s.advance_to(&fork);
            Ok(WidthHeight::Auto)
        } else if name.try_match("min-content") {
            s.advance_to(&fork);
            Ok(WidthHeight::MinContent)
        } else if name.try_match("max-content") {
            s.advance_to(&fork);
            Ok(WidthHeight::MaxContent)
        } else if name.try_match("fit-content") {
            s.advance_to(&fork);
            let content;
            syn::parenthesized!(content in s);
            let lp = content.parse()?;
            if !content.is_empty() {
                Err(content.error("trailing tokens"))
            } else {
                Ok(WidthHeight::FitContent(lp))
            }
        } else {
            // todo error message
            Ok(WidthHeight::LengthPercentage(s.parse()?))
        }
    }
}

#[test]
fn test_width_height() {
    for (input, output) in vec![
        ("0", "0"),
        ("1px", "1px"),
        ("1\"em\"", "1em"),
        ("calc(100% - 60px)", "calc(100% - 60px)"),
    ] {
        match syn::parse_str::<WidthHeight>(input) {
            Ok(v) => assert_eq!(&v.to_string(), output),
            Err(e) => panic!("Error in \"{}\": {}", input, e),
        }
    }
}

impl Parse for LengthPercentage {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        if s.peek2(Token![%]) {
            Ok(LengthPercentage::Percentage(s.parse()?))
        } else {
            Ok(LengthPercentage::Length(s.parse()?))
        }
    }
}

#[test]
fn test_length_percentage() {
    for (input, output) in vec![
        ("1\"em\"", LengthPercentage::Length(Length::Em(1.0))),
        ("1.0px", LengthPercentage::Length(Length::Px(1.0))),
        ("0", LengthPercentage::Length(Length::Zero)),
    ] {
        assert_eq!(syn::parse_str::<LengthPercentage>(input).unwrap(), output);
    }
}

impl Parse for Resize {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let name: HyphenWord = s.parse()?;

        if name.try_match("none") {
            Ok(Resize::None)
        } else if name.try_match("both") {
            Ok(Resize::Both)
        } else if name.try_match("horizontal") {
            Ok(Resize::Horizontal)
        } else if name.try_match("vertical") {
            Ok(Resize::Vertical)
        } else {
            Err(name.error())
        }
    }
}

impl Parse for Shadow {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        syn::custom_keyword!(inset);
        let mut inset_val = false;
        let mut length: Option<ShadowLength> = None;
        let mut color: Option<Color> = None;
        // keep trying all three until we're done or there is an error
        loop {
            let mut parsed_something = false;
            // inset (easiest)
            if s.peek(inset) {
                let inset_tok = s.parse::<inset>()?;
                if inset_val {
                    return Err(syn::Error::new(
                        inset_tok.span(),
                        "`inset` must be specified 0 or 1 times",
                    ));
                }
                inset_val = true;
                parsed_something = true;
            }

            // color
            let fork = s.fork();
            if let Ok(parsed_color) = fork.parse::<Color>() {
                if color.is_some() {
                    return Err(s.error("color must be specified 0 or 1 times"));
                }
                color = Some(parsed_color);
                s.advance_to(&fork);
                parsed_something = true;
            }

            // length
            let fork = s.fork();
            if let Ok(parsed_length) = fork.parse::<ShadowLength>() {
                if length.is_some() {
                    return Err(s.error("shadow length must be specified once"));
                }
                length = Some(parsed_length);
                s.advance_to(&fork);
                parsed_something = true;
            }

            // if we've failed to parse anything, end the loop.
            if !parsed_something {
                break;
            }
        }
        if let Some(length) = length {
            Ok(Shadow {
                color,
                length,
                inset: inset_val,
            })
        } else {
            Err(s.error("expected color, length, or `inset`"))
        }
    }
}

impl Parse for ShadowLength {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let horizontal: Length = s.parse()?;
        let vertical: Length = s.parse()?;

        // blur
        let fork = s.fork();
        let blur = match fork.parse::<Length>() {
            Ok(blur) => {
                s.advance_to(&fork);
                blur
            }
            Err(_) => {
                return Ok(ShadowLength::Offsets {
                    horizontal,
                    vertical,
                });
            }
        };

        // spread
        let fork = s.fork();
        match fork.parse::<Length>() {
            Ok(spread) => {
                s.advance_to(&fork);

                Ok(ShadowLength::OffsetsBlurSpread {
                    horizontal,
                    vertical,
                    blur,
                    spread,
                })
            }
            Err(_) => Ok(ShadowLength::OffsetsBlur {
                horizontal,
                vertical,
                blur,
            }),
        }
    }
}

impl Parse for TextAlign {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let word: HyphenWord = s.parse()?;
        if word.try_match("left") {
            Ok(TextAlign::Left)
        } else if word.try_match("right") {
            Ok(TextAlign::Right)
        } else if word.try_match("center") {
            Ok(TextAlign::Center)
        } else if word.try_match("justify") {
            Ok(TextAlign::Justify)
        } else {
            Err(word.error())
        }
    }
}

// color
// =====

impl Parse for DynamicColor {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        Ok(if s.peek(syn::token::Brace) {
            DynamicColor::Dynamic(s.parse()?)
        } else {
            DynamicColor::Literal(s.parse()?)
        })
    }
}

impl Parse for Color {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        if s.peek(Token![#]) {
            return parse_hex_color(s);
        }
        let fn_name: HyphenWord = s.parse()?;
        if fn_name.try_match("hsl") {
            parse_hsl_color(s, false)
        } else if fn_name.try_match("hsla") {
            parse_hsl_color(s, true)
        } else {
            if let Some(name) = fn_name.word.as_ref() {
                if let Some(color) = Color::from_named(name) {
                    return Ok(color);
                }
            }
            fn_name.add_expected("named color");
            Err(fn_name.error())
        }
    }
}

fn parse_hex_color(s: ParseStream) -> syn::Result<Color> {
    const ERR_MSG: &'static str = "to avoid confusing rust, please enclose hex colors in `\"`";
    s.parse::<Token![#]>()?;
    if !(s.peek(syn::LitStr) || s.peek(Ident)) {
        return Err(s.error(ERR_MSG));
    }
    if s.peek(syn::LitStr) {
        let hex_str: syn::LitStr = s.parse()?;
        color::parse_hex(&hex_str.value()).ok_or(syn::Error::new(hex_str.span(), ERR_MSG))
    } else {
        let hex_str: Ident = s.parse()?;
        color::parse_hex(&hex_str.to_string()).ok_or(syn::Error::new(hex_str.span(), ERR_MSG))
    }
}

fn parse_hsl_color(s: ParseStream, with_alpha: bool) -> syn::Result<Color> {
    let content;
    syn::parenthesized!(content in s);
    let n: Number = content.parse()?;
    n.empty_suffix()?;
    let hue = n.value;
    if hue < 0.0 || hue >= 360.0 {
        return Err(syn::Error::new(
            n.span,
            "hue should be in the range `0 <= hue < 360`",
        ));
    }
    content.parse::<Token![,]>()?;
    let n: Number = content.parse()?;
    if n.suffix != "%" {
        return Err(syn::Error::new(
            n.span,
            "saturation should be a percentage (followed by `%`)",
        ));
    }
    let sat = n.value;
    if sat < 0.0 || sat > 100.0 {
        return Err(syn::Error::new(
            n.span,
            "saturation should be in the range `0 <= sat < 100`",
        ));
    }
    content.parse::<Token![,]>()?;
    let n: Number = content.parse()?;
    if n.suffix != "%" {
        return Err(syn::Error::new(
            n.span,
            "saturation should be a percentage (followed by `%`)",
        ));
    }
    let light = n.value;
    if light < 0.0 || light > 100.0 {
        return Err(syn::Error::new(
            n.span,
            "lightness should be in the range `0 <= light < 100`",
        ));
    }
    // since we parse content in parentheses, we can assume no trailing characers
    if !with_alpha {
        return if content.is_empty() {
            Ok(Color::HSL(hue, sat, light))
        } else {
            Err(content.error("trailing characters"))
        };
    }
    // we are a hsla
    content.parse::<Token![,]>()?;
    let n: Number = content.parse()?;
    n.empty_suffix()?;
    let alpha = n.value;
    if alpha < 0.0 || alpha > 1.0 {
        return Err(syn::Error::new(
            n.span,
            "alpha should be in the range `0 <= alpha < 1`",
        ));
    }
    if content.is_empty() {
        Ok(Color::HSLA(hue, sat, light, alpha))
    } else {
        Err(content.error("unexpected trailing characters"))
    }
}

#[test]
fn test_color() {
    for (input, output) in vec![
        ("#ffffffff", Color::HexRGBA(255, 255, 255, 255)),
        ("#ffffff", Color::HexRGB(255, 255, 255)),
        ("#fff", Color::HexRGB(255, 255, 255)),
        ("#\"fff\"", Color::HexRGB(255, 255, 255)),
        ("hsl(100, 50%, 50%)", Color::HSL(100.0, 50.0, 50.0)),
        ("hsla(60, 0%, 0%, 0.2)", Color::HSLA(60.0, 0.0, 0.0, 0.2)),
        ("black", Color::Black),
        ("yellow", Color::Yellow),
    ] {
        match syn::parse_str::<Color>(input) {
            Ok(c) => assert_eq!(c, output),
            Err(e) => panic!("error parsing color {}: {}", input, e),
        }
    }
}

// Util
// ====

impl<T> Parse for NonemptyCommaList<T>
where
    T: Parse,
{
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let punctuated = Punctuated::<T, Token![,]>::parse_separated_nonempty(s)?;
        let mut iter = punctuated.into_iter();
        let first = iter.next().unwrap();
        Ok(Self {
            first,
            rest: iter.collect(),
        })
    }
}

impl<T> Parse for SingleOrDouble<T>
where
    T: Parse,
{
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let first = T::parse(s)?;
        let fork = s.fork();
        Ok(match T::parse(&fork) {
            Ok(second) => {
                s.advance_to(&fork);
                SingleOrDouble::Double {
                    vert: first,
                    horiz: second,
                }
            }
            Err(_) => SingleOrDouble::Single(first),
        })
    }
}

/// Either a float or an int, converted in either case to f64.
///
/// A trailing percent (`%`) character will be consumed if the number has no suffix. This is valid
/// according to the CSS tokeniser spec.
///
/// TODO This only works for floats for now. Although JS only supports floats, integer literals are
/// used in css.
#[derive(Debug)]
struct Number {
    value: f64,
    suffix: String,
    span: Span,
}

impl Number {
    fn empty_suffix(&self) -> syn::Result<()> {
        if self.suffix != "" {
            Err(syn::Error::new(
                self.span,
                "unexpected characters after number",
            ))
        } else {
            Ok(())
        }
    }

    #[cfg(test)]
    fn check_value(&self, value: f64, suffix: &str) -> bool {
        self.value == value && self.suffix == suffix
    }
}

impl Parse for Number {
    fn parse(s: ParseStream) -> syn::Result<Number> {
        let lookahead = s.lookahead1();
        let (value, mut span, mut suffix) = if lookahead.peek(syn::LitFloat) {
            let tok = s.parse::<syn::LitFloat>()?;
            let num = tok.base10_parse()?;
            (num, tok.span(), tok.suffix().to_string())
        } else if lookahead.peek(syn::LitInt) {
            let tok = s.parse::<syn::LitInt>()?;
            // u32 chosen because it can be safely converted into f64
            let num = tok.base10_parse::<u32>()?;
            (num.into(), tok.span(), tok.suffix().to_string())
        } else {
            return Err(lookahead.error());
        };
        if suffix.is_empty() {
            // look for a `%` for the suffix
            if s.peek(Token![%]) {
                let tok = s.parse::<Token![%]>()?;
                if let Some(extra_span) = span.join(tok.span) {
                    span = extra_span;
                }
                suffix.push('%');
            // work-around using literal strings because the lexer can't support suffixes beginning
            // with `e` for floats: https://github.com/rust-lang/rust/issues/67544
            } else if s.peek(syn::LitStr) {
                let tok = s.parse::<syn::LitStr>()?;
                if let Some(extra_span) = span.join(tok.span()) {
                    span = extra_span;
                }
                suffix.push_str(&tok.value());
            }
        }
        Ok(Number {
            value,
            suffix,
            span,
        })
    }
}

#[test]
fn test_number() {
    for (input, value, suffix) in vec![
        ("200", 200.0, ""),
        ("200.0", 200.0, ""),
        ("0", 0.0, ""),
        ("0in", 0.0, "in"),
    ] {
        assert!(syn::parse_str::<Number>(input)
            .unwrap()
            .check_value(value, suffix),)
    }
}

/// Something like `word-separated-hyphens`
#[derive(Debug)]
struct HyphenWord {
    pub span: Span,
    pub word: Option<String>,
    /// List of tried matches - for building error.
    tried: TryList,
}

impl HyphenWord {
    pub fn new(span: Span, word: String) -> Self {
        HyphenWord {
            span,
            word: Some(word),
            tried: TryList::new(),
        }
    }

    /// This allows HyphenWords to be empty. In this case the token cursor will not advance and the
    /// returned word will be blank.
    pub fn new_no_word(span: Span) -> Self {
        HyphenWord {
            span,
            word: None,
            tried: TryList::new(),
        }
    }

    pub fn try_match(&self, other: &str) -> bool {
        if Some(other) == self.word.as_ref().map(|s| s.as_str()) {
            true
        } else {
            self.tried.add_literal(other);
            false
        }
    }

    pub fn add_expected(&self, ty: &str) {
        self.tried.add(ty);
    }

    /// Panics if there were no calls to `try_match` before calling this function.
    pub fn error(&self) -> syn::Error {
        self.tried.to_error(self.span)
    }

    /// This is cheaper than peek-specific
    pub fn peek(s: ParseStream) -> bool {
        s.peek(Ident)
    }

    /// Peek the next HyphenWord without advancing the parser.
    pub fn peek_specific(s: ParseStream) -> Option<String> {
        let fork = s.fork();
        match HyphenWord::parse(&fork) {
            Ok(hw) => Some(hw.word.unwrap()),
            Err(_) => None,
        }
    }
}

impl Parse for HyphenWord {
    fn parse(s: ParseStream) -> syn::Result<Self> {
        let fork = s.fork();
        let first = match fork.call(Ident::parse_any) {
            Ok(v) => {
                s.advance_to(&fork);
                v
            }
            Err(_) => return Ok(HyphenWord::new_no_word(s.cursor().span())),
        };
        let mut word = first.to_string();
        let mut span = first.span();
        // This is potentially unbounded. Probably not be a problem but making a note anyway.
        while s.peek(Token![-]) {
            let hyphen = s.parse::<Token![-]>()?;
            if let Some(joined) = span.join(hyphen.span) {
                span = joined;
            }
            let part = s.call(Ident::parse_any)?;
            write!(word, "-{}", part).unwrap();
            if let Some(joined) = span.join(part.span()) {
                span = joined;
            }
        }
        Ok(HyphenWord::new(span, word))
    }
}

#[test]
fn test_hyphen_word() {
    let word: HyphenWord = syn::parse_str("first-second-third").unwrap();
    assert_eq!(word.word, Some("first-second-third".to_string()));
    assert!(syn::parse_str::<HyphenWord>("first-second-").is_err());
    assert!(syn::parse_str::<HyphenWord>("a a").is_err());
}

/// Keeps track of a list of tokens that have been tried.
#[derive(Debug)]
pub struct TryList(RefCell<BTreeSet<String>>);

impl TryList {
    pub fn new() -> Self {
        TryList(RefCell::new(BTreeSet::new()))
    }

    /// Same as add, but with quotes
    pub fn add_literal(&self, lit: &str) {
        self.add(format!("`{}`", lit));
    }

    pub fn add(&self, ty: impl Into<String>) {
        self.0.borrow_mut().insert(ty.into());
    }

    fn to_error(&self, span: Span) -> syn::Error {
        let tried = self.0.borrow();
        let mut iter = tried.iter();
        let start = iter.next().unwrap().to_owned();
        let list = iter.fold(start, |mut acc, itm| {
            write!(acc, ", {}", itm).unwrap();
            acc
        });
        let error_msg = format!("expected one of {}", list);
        syn::Error::new(span, error_msg)
    }
}

/// Whether we are at the end of a rule. Either the stream will be empty, or there will be a
/// semi-colon.
fn finished_rule(s: ParseStream) -> bool {
    s.is_empty() || s.peek(Token![;])
}

// Parsing integers

#[derive(Debug, PartialEq)]
struct Integer<T> {
    value: T,
}

impl<T> Integer<T> {
    fn into_inner(self) -> T {
        self.value
    }
}

impl<T> Parse for Integer<T>
where
    T: str::FromStr + fmt::Display + PartialOrd<T>,
    <T as str::FromStr>::Err: fmt::Display,
{
    fn parse(s: ParseStream) -> syn::Result<Self> {
        Ok(Integer {
            value: integer(s, ..)?,
        })
    }
}

/// Parse an integer, with an optional allowed range.
fn integer<T, R>(s: ParseStream, range: R) -> syn::Result<T>
where
    R: RangeBounds<T> + fmt::Debug,
    T: str::FromStr + fmt::Display + PartialOrd<T>,
    <T as str::FromStr>::Err: fmt::Display,
{
    let fixed = s.parse::<syn::LitInt>()?;
    let span = fixed.span();
    if fixed.suffix().is_empty() {
        let fixed = fixed.base10_parse()?;
        if range.contains(&fixed) {
            Ok(fixed)
        } else {
            Err(syn::Error::new(
                span,
                format!(
                    "expected a number in the range {:?}, found {}",
                    range, fixed
                ),
            ))
        }
    } else {
        Err(syn::Error::new(span, "the number should not have a suffix"))
    }
}

#[test]
fn test_parse_integer() {
    let x: Integer<u8> = syn::parse_str("123").unwrap();
    assert_eq!(x.into_inner(), 123);
    let x: syn::Result<Integer<u8>> = syn::parse_str("256");
    assert!(x.is_err());
}

// tests

#[test]
fn downstream_bug1() {
    let s: Styles = syn::parse_str(
        "display: flex;
        flex-direction: column;
        flex-grow: 1;
        flex-shrink: 0;",
    )
    .unwrap();
    assert_eq!(
        s.rules,
        vec![
            Style::Display(Display::Flex),
            Style::FlexDirection(FlexDirection::Column),
            Style::FlexGrow(1.0),
            Style::FlexShrink(0.0)
        ]
    )
}

#[test]
#[ignore]
fn inline_logic() {
    todo!()
}

#[cfg(test)]
mod tests {
    use super::*;

    /// Use if you want to test that something parses, but not if it looks the same when
    /// stringified. Example "border: 1px" -> "border:1px" but we still might want to check that
    /// the former parses.
    fn parse(input: &str) -> Style {
        syn::parse_str(input).unwrap()
    }

    /// This function can be used to quickly write tests to check that a parse and a stringify are
    /// opposites.
    fn round_trip_style(input: &str) {
        assert_eq!(&parse(input).to_string(), input);
    }

    #[test]
    fn border_bottom_left_radius() {
        round_trip_style("border-bottom-left-radius:30% 3px");
    }

    #[test]
    fn border_bottom_right_radius() {
        round_trip_style("border-bottom-right-radius:0 0");
    }

    #[test]
    fn border_collapse() {
        round_trip_style("border-collapse:collapse");
    }

    #[test]
    fn border_width() {
        round_trip_style("border-width:1px");
        round_trip_style("border-width:0 2px 50pt 0");
    }
}