dates

class DateTimeParser:
    """XML Datetime parser.

    Args:
        value: The datetime string
        fmt: The target format string

    Attributes:
        vlen: The length of the datetime string
        flen: The length of the format string
        vidx: The current position of the datetime string
        fidx: The current position of the format string
    """

    def __init__(self, value: str, fmt: str):
        """Initialize a DateTimeParser instance."""
        self.format = fmt
        self.value = value
        self.vlen = len(value)
        self.flen = len(fmt)
        self.vidx = 0
        self.fidx = 0

    def parse(self) -> Iterator[Optional[int]]:
        """Yield the parsed datetime string arguments."""
        try:
            while self.fidx < self.flen:
                char = self.next_format_char()

                if char != "%":
                    self.skip(char)
                else:
                    var = self.next_format_char()
                    yield from self.parse_var(var)

            if self.vidx != self.vlen:
                raise ValueError

        except Exception:
            raise ValueError(
                f"String '{self.value}' does not match format '{self.format}'"
            )

    def next_format_char(self) -> str:
        """Return the next format character to evaluate."""
        char = self.format[self.fidx]
        self.fidx += 1
        return char

    def has_more(self) -> bool:
        """Return whether the value is not fully parsed yet."""
        return self.vidx < self.vlen

    def peek(self) -> str:
        """Return the current evaluated character of the datetime string."""
        return self.value[self.vidx]

    def skip(self, char: str) -> None:
        """Validate and skip over the given char."""
        if not self.has_more() or self.peek() != char:
            raise ValueError

        self.vidx += 1

    def parse_var(self, var: str) -> Iterator[Optional[int]]:
        """Parse the given var from the datetime string."""
        if var in SIMPLE_TWO_DIGITS_FORMATS:
            yield self.parse_digits(2)
        elif var == "Y":
            yield self.parse_year()
        elif var == "S":
            yield self.parse_digits(2)

            yield self.parse_fractional_second()
        elif var == "z":
            yield self.parse_offset()
        else:
            raise ValueError

    def parse_year(self) -> int:
        """Parse the year argument."""
        negative = False
        if self.peek() == "-":
            self.vidx += 1
            negative = True

        start = self.vidx
        year = self.parse_minimum_digits(4)
        end = self.vidx
        raw = self.value[start:end]

        leading_zeros = len(raw) - len(raw.lstrip("0"))
        if (
            (leading_zeros == 1 and year > 999)
            or (leading_zeros == 2 and year > 99)
            or (leading_zeros == 3 and year > 9)
            or (leading_zeros == 4 and year > 0)
            or (leading_zeros > 4)
        ):
            raise ValueError

        if negative:
            return -year

        return year

    def parse_fractional_second(self) -> int:
        """Parse the fractional second argument."""
        if self.has_more() and self.peek() == ".":
            self.vidx += 1
            return self.parse_fixed_digits(9)

        return 0

    def parse_digits(self, digits: int) -> int:
        """Parse the given number of digits."""
        start = self.vidx
        self.vidx += digits
        return int(self.value[start : self.vidx])

    def parse_minimum_digits(self, min_digits: int) -> int:
        """Parse until the next character is not a digit."""
        start = self.vidx
        self.vidx += min_digits

        while self.has_more() and self.peek().isdigit():
            self.vidx += 1

        return int(self.value[start : self.vidx])

    def parse_fixed_digits(self, max_digits: int) -> int:
        """Parse a fixed number of digits."""
        start = self.vidx
        just = max_digits
        while max_digits and self.has_more() and self.peek().isdigit():
            self.vidx += 1
            max_digits -= 1

        return int(self.value[start : self.vidx].ljust(just, "0"))

    def parse_offset(self) -> Optional[int]:
        """Parse the xml timezone offset as minutes."""
        if not self.has_more():
            return None

        ctrl = self.peek()
        if ctrl == "Z":
            self.vidx += 1
            return 0

        if ctrl in ("-", "+"):
            self.vidx += 1
            offset = self.parse_digits(2) * 60
            self.skip(":")
            offset += self.parse_digits(2)
            offset *= -1 if ctrl == "-" else 1
            return offset

        raise ValueError