jayver 1.0.0

//! Jayhart Version type and implementations.

use std::{
    convert::TryFrom,
    fmt::{Display, Formatter, Result as FmtResult},
    str::FromStr,
};

use nom::{combinator::all_consuming, Parser};
#[cfg(feature = "serialization")]
use serde::{Deserialize, Serialize};
use time::{Date, OffsetDateTime, Weekday};

use crate::{
    error::{Error, Result},
    parser::parse_version,
};

/// ISO week-numbering year minus 2000.
pub type Year = i32;
/// ISO 8601 Week number.
pub type Week = u8;
/// Micro patch number.
pub type Patch = u32;

/// Represents a JayVer version in YY.WW.PATCH format.
///
/// - YY: ISO week-numbering year minus 2000 (e.g., 25 for 2025)
/// - WW: ISO 8601 week number (1-53)
/// - PATCH: Incremental number starting at 0
///
/// # Examples
///
/// ```
/// use jayver::Version;
///
/// let v = Version::parse("25.16.0").unwrap();
/// assert_eq!(v.year, 25); // Year 2025 (25 + 2000)
/// assert_eq!(v.week, 16);
/// assert_eq!(v.patch, 0);
/// ```
///
/// Using year 2000 (represented as 0):
///
/// ```
/// use jayver::Version;
///
/// let v = Version::parse("0.1.0").unwrap();
/// assert_eq!(v.year, 0); // Year 2000 (0 + 2000)
/// assert_eq!(Version::full_year(v.year), 2000);
/// assert_eq!(v.week, 1);
/// assert_eq!(v.patch, 0);
/// ```
///
/// Pre-2000 years are represented as negative numbers:
///
/// ```
/// use jayver::Version;
///
/// // Pre-2000 years are represented as negative numbers
/// let v = Version::parse("-5.20.0").unwrap();
/// assert_eq!(v.year, -5); // Year 1995 (-5 + 2000)
/// assert_eq!(Version::full_year(v.year), 1995);
/// assert_eq!(v.week, 20);
/// assert_eq!(v.patch, 0);
/// ```
///
/// Compare versions chronologically:
///
/// ```
/// use jayver::Version;
///
/// let v1 = Version::parse("25.10.0").unwrap();
/// let v2 = Version::parse("25.20.0").unwrap();
/// let v3 = Version::parse("26.1.0").unwrap();
///
/// assert!(v1 < v2); // Week 10 is before week 20 in the same year
/// assert!(v2 < v3); // Year 25 (2025) is before year 26 (2026)
/// ```
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[cfg_attr(feature = "serialization", derive(Serialize, Deserialize))]
pub struct Version {
    /// Year component (ISO week-numbering year - 2000)
    pub year: Year,
    /// ISO Week component (1-53)
    pub week: Week,
    /// Patch component
    pub patch: Patch,
}

impl Version {
    /// Create a new Version with validation.
    ///
    /// The `year` parameter should be the ISO week-numbering year minus 2000.
    ///
    /// Returns an error if the year/week combination is invalid.
    ///
    /// # Examples
    ///
    /// ```
    /// use jayver::Version;
    ///
    /// let v = Version::new(25, 16, 0).unwrap(); // Year 2025, week 16
    /// assert_eq!(v.to_string(), "25.16.0");
    ///
    /// // Invalid week
    /// assert!(Version::new(25, 54, 0).is_err());
    /// ```
    pub fn new(year: Year, week: Week, patch: Patch) -> Result<Self> {
        // Validate week range
        if !(1..=53).contains(&week) {
            return Err(Error::InvalidWeek {
                week,
            });
        }

        // Ensure this is a valid ISO week
        let full_year = Self::full_year(year);
        match Date::from_iso_week_date(full_year, week, Weekday::Monday) {
            Ok(_) => Ok(Self {
                year,
                week,
                patch,
            }),
            Err(_) => Err(Error::InvalidYearWeek {
                year,
                week,
            }),
        }
    }

    /// Parse a version string.
    ///
    /// # Examples
    ///
    /// ```
    /// use jayver::Version;
    ///
    /// let v = Version::parse("25.16.0").unwrap();
    /// assert_eq!(v.year, 25); // Year 2025
    /// ```
    pub fn parse<S>(text: S) -> Result<Self>
    where
        S: AsRef<str>,
    {
        let text = text.as_ref();
        text.parse().map_err(|_| Error::invalid_version(text))
    }

    /// Create a version representing the current date with patch 0.
    ///
    /// # Examples
    ///
    /// ```
    /// use jayver::Version;
    ///
    /// let today = Version::today();
    /// println!("Today's version: {}", today);
    /// ```
    pub fn today() -> Self {
        let now = OffsetDateTime::now_utc();
        let year = now.year();
        let week = now.iso_week();

        // Always subtract 2000 from the year
        let short_year = Self::short_year(year);

        Self {
            year: short_year,
            week,
            patch: 0,
        }
    }

    /// Increment the patch component.
    ///
    /// # Examples
    ///
    /// ```
    /// use jayver::Version;
    ///
    /// let mut v = Version::parse("25.16.0").unwrap();
    /// v.increment_patch();
    /// assert_eq!(v.patch, 1);
    /// ```
    pub fn increment_patch(&mut self) -> &mut Self {
        self.patch += 1;
        self
    }

    /// Move to the next week with patch reset to 0.
    ///
    /// # Examples
    ///
    /// ```
    /// use jayver::Version;
    ///
    /// let mut v = Version::parse("25.16.5").unwrap();
    /// v.next_week().unwrap();
    /// assert_eq!(v.week, 17);
    /// assert_eq!(v.patch, 0);
    /// ```
    pub fn next_week(&mut self) -> Result<&mut Self> {
        self.week += 1;

        // Handle week rollover to next year
        if self.week > 53 {
            self.year += 1;
            self.week = 1;
        }

        // Validate the new year/week combination
        let full_year = Self::full_year(self.year);
        match Date::from_iso_week_date(full_year, self.week, Weekday::Monday) {
            Ok(_) => {
                self.patch = 0;
                Ok(self)
            },
            Err(_) => {
                // If invalid, try the next week until we find a valid one
                self.week += 1;
                if self.week > 53 {
                    self.year += 1;
                    self.week = 1;
                }
                self.patch = 0;
                Ok(self)
            },
        }
    }

    /// Convert a full ISO week-numbering year (e.g., 2025) to short form (e.g.,
    /// 25)
    ///
    /// # Examples
    ///
    /// ```
    /// use jayver::Version;
    ///
    /// assert_eq!(Version::short_year(2025), 25);
    /// assert_eq!(Version::short_year(1995), -5);
    /// ```
    pub fn short_year(year: Year) -> Year {
        year - 2000
    }

    /// Convert a short year (e.g., 25) to full ISO week-numbering year (e.g.,
    /// 2025)
    ///
    /// # Examples
    ///
    /// ```
    /// use jayver::Version;
    ///
    /// assert_eq!(Version::full_year(25), 2025);
    /// assert_eq!(Version::full_year(-5), 1995);
    /// ```
    pub fn full_year(year: Year) -> Year {
        year + 2000
    }

    /// Return true if this version is from the same week as another version.
    ///
    /// # Examples
    ///
    /// ```
    /// use jayver::Version;
    ///
    /// let v1 = Version::parse("25.16.0").unwrap();
    /// let v2 = Version::parse("25.16.5").unwrap();
    /// assert!(v1.same_week(&v2));
    /// ```
    pub fn same_week(&self, other: &Self) -> bool {
        self.year == other.year && self.week == other.week
    }
}

impl FromStr for Version {
    type Err = Error;

    fn from_str(s: &str) -> Result<Self> {
        if s.is_empty() {
            return Err(Error::invalid_version("empty string"));
        }

        Version::try_from(s)
    }
}

impl TryFrom<&str> for Version {
    type Error = Error;

    fn try_from(s: &str) -> Result<Self> {
        all_consuming(parse_version)
            .parse(s)
            .map(|(_, version)| version)
            .map_err(|e| match e {
                nom::Err::Error(err) | nom::Err::Failure(err) => Error::from_nom(s, err),
                nom::Err::Incomplete(_) => Error::format(s),
            })
    }
}

impl Display for Version {
    fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
        write!(f, "{}.{}.{}", self.year, self.week, self.patch)
    }
}

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

    #[test]
    fn test_version_parse() {
        let v: Version = "25.12.3".parse().unwrap();
        assert_eq!(v, Version {
            year: 25,
            week: 12,
            patch: 3
        });
    }

    #[test]
    fn test_version_from_str_invalid() {
        assert!("25.54.1".parse::<Version>().is_err());
        assert!("invalid.version".parse::<Version>().is_err());
    }

    #[test]
    fn test_version_display() {
        let version = Version {
            year: 25,
            week: 12,
            patch: 3,
        };
        assert_eq!(version.to_string(), "25.12.3");
    }

    #[test]
    fn test_version_ordering() {
        let v1 = Version {
            year: 25,
            week: 10,
            patch: 1,
        };
        let v2 = Version {
            year: 25,
            week: 10,
            patch: 2,
        };
        let v3 = Version {
            year: 25,
            week: 11,
            patch: 1,
        };
        let v4 = Version {
            year: 26,
            week: 1,
            patch: 1,
        };

        assert!(v1 < v2);
        assert!(v2 < v3);
        assert!(v3 < v4);
    }

    #[test]
    fn test_today() {
        let today = Version::today();
        // This test is time-dependent, but we can at least ensure
        // the basic properties are valid
        assert!(today.week >= 1 && today.week <= 53);
        assert_eq!(today.patch, 0);
    }

    #[test]
    fn test_increment_patch() {
        let mut v = Version {
            year: 25,
            week: 10,
            patch: 1,
        };
        v.increment_patch();
        assert_eq!(v.patch, 2);
    }

    #[test]
    fn test_next_week() {
        let mut v = Version {
            year: 25,
            week: 10,
            patch: 5,
        };
        v.next_week().unwrap();
        assert_eq!(v.week, 11);
        assert_eq!(v.patch, 0);
    }

    #[test]
    fn test_next_week_year_rollover() {
        let mut v = Version {
            year: 25,
            week: 52,
            patch: 1,
        };
        v.next_week().unwrap();
        // Either week 53 of year 25 or week 1 of year 26,
        // depending on the calendar
        assert!((v.year == 25 && v.week == 53) || (v.year == 26 && v.week == 1));
        assert_eq!(v.patch, 0);
    }

    #[test]
    fn test_full_year() {
        assert_eq!(Version::full_year(25), 2025);
        assert_eq!(Version::full_year(-5), 1995);
    }

    #[test]
    fn test_short_year() {
        assert_eq!(Version::short_year(2025), 25);
        assert_eq!(Version::short_year(1995), -5);
    }

    #[test]
    fn test_same_week() {
        let v1 = Version {
            year: 25,
            week: 10,
            patch: 1,
        };
        let v2 = Version {
            year: 25,
            week: 10,
            patch: 5,
        };
        let v3 = Version {
            year: 25,
            week: 11,
            patch: 1,
        };

        assert!(v1.same_week(&v2));
        assert!(!v1.same_week(&v3));
    }

    #[test]
    fn test_year_2000() {
        // Test year 2000 (represented as 0)
        let version = Version::parse("0.1.0").unwrap();
        assert_eq!(version.year, 0);
        assert_eq!(Version::full_year(version.year), 2000);

        // Test creation and validation
        let created = Version::new(0, 1, 0).unwrap();
        assert_eq!(created.to_string(), "0.1.0");

        // Ensure proper ordering
        let v1 = Version::parse("0.52.0").unwrap();
        let v2 = Version::parse("1.1.0").unwrap();
        assert!(v1 < v2);
    }
}