actions/validate-inputs/validators/version.py

"""Version validators for various versioning schemes."""

from __future__ import annotations

import re

from .base import BaseValidator


class VersionValidator(BaseValidator):
    """Validator for version strings (SemVer, CalVer, language-specific)."""

    # Common version patterns
    VERSION_X_Y_Z_PATTERN = r"^\d+\.\d+(\.\d+)?$"

    def validate_inputs(self, inputs: dict[str, str]) -> bool:
        """Validate version-related inputs."""
        valid = True

        for input_name, value in inputs.items():
            if "version" in input_name.lower():
                # Determine version type from input name
                if "dotnet" in input_name:
                    valid &= self.validate_dotnet_version(value, input_name)
                elif "terraform" in input_name or "tflint" in input_name:
                    valid &= self.validate_terraform_version(value, input_name)
                elif "node" in input_name:
                    valid &= self.validate_node_version(value, input_name)
                elif "python" in input_name:
                    valid &= self.validate_python_version(value, input_name)
                elif "php" in input_name:
                    valid &= self.validate_php_version(value, input_name)
                elif "go" in input_name:
                    valid &= self.validate_go_version(value, input_name)
                else:
                    # Default to semantic version
                    valid &= self.validate_semantic_version(value, input_name)

        return valid

    def get_required_inputs(self) -> list[str]:
        """Version validators typically don't define required inputs."""
        return []

    def get_validation_rules(self) -> dict:
        """Return version validation rules."""
        return {
            "semantic": "X.Y.Z format with optional pre-release and build metadata",
            "calver": "Calendar-based versioning (YYYY.MM.DD, etc.)",
            "dotnet": ".NET version format",
            "terraform": "Terraform version format",
            "node": "Node.js version format",
            "python": "Python 3.x version",
            "php": "PHP 7.4-9.x version",
            "go": "Go 1.x version",
        }

    def validate_semantic_version(self, version: str, name: str = "version") -> bool:
        """Validate semantic version format.

        Args:
            version: The version string to validate
            name: The input name for error messages

        Returns:
            True if valid, False otherwise
        """
        if not version or version.strip() == "":
            return True  # Version is often optional

        # Remove 'v' or 'V' prefix if present (case-insensitive)
        clean_version = version
        if clean_version.lower().startswith("v"):
            clean_version = clean_version[1:]

        # Examples: 1.0.0, 2.1.3-beta, 3.0.0-rc.1, 1.2.3+20130313144700
        semver_pattern = (
            r"^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)"  # MAJOR.MINOR.PATCH
            r"(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)"  # Pre-release
            r"(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?"
            r"(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$"  # Build metadata
        )

        if re.match(semver_pattern, clean_version):
            return True

        # Also allow simple X.Y format for flexibility
        simple_pattern = r"^(0|[1-9]\d*)\.(0|[1-9]\d*)$"
        if re.match(simple_pattern, clean_version):
            return True

        # Also allow single digit version (e.g., "1", "2")
        single_digit_pattern = r"^(0|[1-9]\d*)$"
        if re.match(single_digit_pattern, clean_version):
            return True

        self.add_error(
            f'Invalid semantic version: "{version}" in {name}. '
            "Expected format: MAJOR.MINOR.PATCH (e.g., 1.2.3, 2.0.0-beta)",
        )
        return False

    # Compatibility aliases for tests and backward compatibility
    def validate_semver(self, version: str, name: str = "version") -> bool:
        """Alias for validate_semantic_version."""
        return self.validate_semantic_version(version, name)

    def validate_calver(self, version: str, name: str = "version") -> bool:
        """Alias for validate_calver_version."""
        return self.validate_calver_version(version, name)

    def validate_version(self, version: str, version_type: str, name: str = "version") -> bool:
        """Generic version validation based on type."""
        if version_type == "semantic":
            return self.validate_semantic_version(version, name)
        if version_type == "calver":
            return self.validate_calver_version(version, name)
        if version_type == "flexible":
            return self.validate_flexible_version(version, name)
        if version_type == "dotnet":
            return self.validate_dotnet_version(version, name)
        if version_type == "terraform":
            return self.validate_terraform_version(version, name)
        if version_type == "node":
            return self.validate_node_version(version, name)
        if version_type == "python":
            return self.validate_python_version(version, name)
        if version_type == "php":
            return self.validate_php_version(version, name)
        if version_type == "go":
            return self.validate_go_version(version, name)
        # Allow "latest" as special case
        if version.strip().lower() == "latest":
            return True
        # Default to semantic version
        return self.validate_semantic_version(version, name)  # Version is often optional

    def validate_strict_semantic_version(self, version: str, name: str = "version") -> bool:
        """Validate strict semantic version format (X.Y.Z required).

        Args:
            version: The version string to validate
            name: The input name for error messages

        Returns:
            True if valid, False otherwise
        """
        if not version or version.strip() == "":
            self.add_error(f"Version cannot be empty in {name}")
            return False

        # Allow "latest" as special case
        if version.strip().lower() == "latest":
            return True

        # Remove common prefixes for validation
        clean_version = version.lstrip("v")

        # Strict semantic version pattern
        pattern = r"^\d+\.\d+\.\d+(-[\dA-Za-z.-]+)?(\+[\dA-Za-z.-]+)?$"

        if re.match(pattern, clean_version):
            return True

        self.add_error(
            f'Invalid strict semantic version format: "{version}" in {name}. Must be X.Y.Z',
        )
        return False

    def validate_calver_version(self, version: str, name: str = "version") -> bool:
        """Validate CalVer (Calendar Versioning) format.

        Args:
            version: The version string to validate
            name: The input name for error messages

        Returns:
            True if valid, False otherwise
        """
        if not version or version.strip() == "":
            return True  # Version is often optional

        # Remove common prefixes for validation
        clean_version = version.lstrip("v")

        # CalVer patterns
        calver_patterns = [
            r"^\d{4}\.\d{1,2}\.\d{1,2}$",  # YYYY.MM.DD
            r"^\d{4}\.\d{1,2}\.\d{3,}$",  # YYYY.MM.PATCH
            r"^\d{4}\.0\d\.0\d$",  # YYYY.0M.0D
            r"^\d{2}\.\d{1,2}\.\d+$",  # YY.MM.MICRO
            r"^\d{4}\.\d{1,2}$",  # YYYY.MM
            r"^\d{4}-\d{2}-\d{2}$",  # YYYY-MM-DD
        ]

        for pattern in calver_patterns:
            match = re.match(pattern, clean_version)
            # Additional validation for date components
            if match and self._validate_calver_date_parts(clean_version, pattern):
                return True

        self.add_error(
            f'Invalid CalVer format: "{version}" in {name}. '
            "Expected formats like YYYY.MM.DD, YY.MM.MICRO, etc.",
        )
        return False

    def _parse_calver_year(self, year_part: str) -> int | None:
        """Parse year from CalVer version part.

        Returns:
            Year as integer, or None if not a valid year format
        """
        if len(year_part) == 4:
            return int(year_part)
        if len(year_part) == 2:
            # For YY format, assume 2000s
            return 2000 + int(year_part)
        return None  # Not a date-based CalVer

    def _is_valid_month(self, month: int) -> bool:
        """Check if month is in valid range (1-12)."""
        return 1 <= month <= 12

    def _is_leap_year(self, year: int) -> bool:
        """Check if year is a leap year."""
        return (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)

    def _get_max_day_for_month(self, month: int, year: int) -> int:
        """Get maximum valid day for given month and year.

        Args:
            month: Month (1-12)
            year: Year (for leap year calculation)

        Returns:
            Maximum valid day for the month
        """
        if month in [4, 6, 9, 11]:  # April, June, September, November
            return 30
        if month == 2:  # February
            return 29 if self._is_leap_year(year) else 28
        return 31  # All other months

    def _is_valid_day(self, day: int, month: int, year: int) -> bool:
        """Check if day is valid for the given month and year."""
        if not (1 <= day <= 31):
            return False
        max_day = self._get_max_day_for_month(month, year)
        return day <= max_day

    def _should_validate_day(self, pattern: str, third_part: str) -> bool:
        """Determine if third part should be validated as a day.

        Args:
            pattern: The CalVer pattern that matched
            third_part: The third part of the version string

        Returns:
            True if the third part represents a day and should be validated
        """
        # YYYY.MM.DD and YYYY-MM-DD formats have day as third part
        if r"\d{1,2}$" in pattern or r"\d{2}$" in pattern:
            # Check if it looks like a day (1-2 digits)
            return third_part.isdigit() and len(third_part) <= 2
        # YYYY.MM.PATCH format has patch number (3+ digits), not a day
        if r"\d{3,}" in pattern:
            return False
        # YYYY.0M.0D format is a date format
        return r"0\d" in pattern

    def _validate_calver_date_parts(self, version: str, pattern: str) -> bool:
        """Validate date components in CalVer version.

        Args:
            version: The version string to validate
            pattern: The regex pattern that matched (helps determine format type)

        Returns:
            True if date components are valid, False otherwise
        """
        # Handle different separators
        parts = version.split("-") if "-" in version else version.split(".")

        # Need at least year and month
        if len(parts) < 2:
            return True

        # Parse and validate year
        year = self._parse_calver_year(parts[0])
        if year is None:
            return True  # Not a date-based CalVer

        # Validate month
        month = int(parts[1])
        if not self._is_valid_month(month):
            return False

        # Validate day if present and pattern indicates it's a day (not patch number)
        if len(parts) >= 3 and self._should_validate_day(pattern, parts[2]):
            day = int(parts[2])
            if not self._is_valid_day(day, month, year):
                return False

        return True

    def validate_flexible_version(self, version: str, name: str = "version") -> bool:
        """Validate either CalVer or SemVer format.

        Args:
            version: The version string to validate
            name: The input name for error messages

        Returns:
            True if valid, False otherwise
        """
        if not version or version.strip() == "":
            return True  # Version is often optional

        # Allow "latest" as special case
        if version.strip().lower() == "latest":
            return True

        # Save current errors
        original_errors = self.errors.copy()

        # Try CalVer first if it looks like CalVer
        clean_version = version.lstrip("v")
        looks_like_calver = (
            re.match(r"^\d{4}\.", clean_version)
            or re.match(r"^\d{4}-", clean_version)
            or (re.match(r"^\d{2}\.\d", clean_version) and int(clean_version.split(".")[0]) >= 20)
        )

        if looks_like_calver:
            self.errors = []
            if self.validate_calver_version(version, name):
                self.errors = original_errors
                return True
            # If it looks like CalVer but fails, don't try SemVer
            self.errors = original_errors
            self.add_error(f'Invalid CalVer format: "{version}" in {name}')
            return False

        # Try SemVer
        self.errors = []
        if self.validate_semantic_version(version, name):
            self.errors = original_errors
            return True

        # Failed both
        self.errors = original_errors
        self.add_error(
            f'Invalid version format: "{version}" in {name}. '
            "Expected either CalVer (e.g., 2024.3.1) or SemVer (e.g., 1.2.3)",
        )
        return False

    def validate_dotnet_version(self, value: str, name: str = "dotnet-version") -> bool:
        """Validate .NET version format."""
        return self._validate_language_version(
            value,
            name,
            {
                "name": ".NET",
                "major_range": (3, 20),
                "pattern": r"^\d+(\.\d+(\.\d+)?)?(-[\dA-Za-z-]+(\.\dA-Za-z-]+)*)?$",
                "check_leading_zeros": True,
            },
        )

    def validate_terraform_version(self, value: str, name: str = "terraform-version") -> bool:
        """Validate Terraform version format."""
        if not value or value.strip() == "":
            return True

        if value.strip().lower() == "latest":
            return True

        clean_version = value.lstrip("v")
        pattern = r"^\d+\.\d+\.\d+(-[\w.-]+)?$"

        if re.match(pattern, clean_version):
            return True

        self.add_error(f'Invalid Terraform version format: "{value}" in {name}')
        return False

    def validate_node_version(self, value: str, name: str = "node-version") -> bool:
        """Validate Node.js version format."""
        if not value or value.strip() == "":
            return True

        # Check for special Node.js keywords (case-insensitive)
        value_lower = value.strip().lower()
        node_keywords = ["latest", "lts", "current", "node"]
        if value_lower in node_keywords or value_lower.startswith("lts/"):
            return True

        # Remove v prefix (case-insensitive)
        clean_version = value
        if clean_version.lower().startswith("v"):
            clean_version = clean_version[1:]

        pattern = r"^\d+(\.\d+(\.\d+)?)?$"

        if re.match(pattern, clean_version):
            return True

        self.add_error(f'Invalid Node.js version format: "{value}" in {name}')
        return False

    def validate_python_version(self, value: str, name: str = "python-version") -> bool:
        """Validate Python version format (3.8-3.15)."""
        return self._validate_language_version(
            value,
            name,
            {
                "name": "Python",
                "major_range": 3,
                "minor_range": (8, 15),
                "pattern": self.VERSION_X_Y_Z_PATTERN,
            },
        )

    def validate_php_version(self, value: str, name: str = "php-version") -> bool:
        """Validate PHP version format (7.4-9.x)."""
        # First do basic validation
        if not value or value.strip() == "":
            self.add_error(f"{name} cannot be empty")
            return False

        clean_value = value.strip()

        # Reject v prefix
        if clean_value.startswith("v"):
            self.add_error(
                f'Invalid PHP version format: "{value}" in {name}. '
                'Version prefix "v" is not allowed',
            )
            return False

        # Check format
        if not re.match(self.VERSION_X_Y_Z_PATTERN, clean_value):
            self.add_error(
                f'Invalid PHP version format: "{value}" in {name}. Must be X.Y or X.Y.Z format',
            )
            return False

        # Parse version
        parts = clean_value.split(".")
        major = int(parts[0])
        minor = int(parts[1])

        # Check major version range (7-9)
        if major < 7 or major > 9:
            self.add_error(
                f'PHP version "{value}" in {name}. Major version should be between 7 and 9',
            )
            return False

        # Check minor version ranges per major version
        # PHP 7: 7.0-7.4 are the only released versions, but allow higher for testing
        # PHP 8: Allow any minor version for future compatibility
        # PHP 9: Allow any minor for future compatibility
        # Only restrict if the minor version is unreasonably high (>99)
        if minor > 99:
            self.add_error(
                f'PHP version "{value}" in {name}. Minor version {minor} is unreasonably high',
            )
            return False

        return True

    def validate_go_version(self, value: str, name: str = "go-version") -> bool:
        """Validate Go version format (1.18-1.30)."""
        return self._validate_language_version(
            value,
            name,
            {
                "name": "Go",
                "major_range": 1,
                "minor_range": (18, 30),
                "pattern": self.VERSION_X_Y_Z_PATTERN,
            },
        )

    def _check_version_prefix(
        self, value: str, clean_value: str, name: str, lang_name: str
    ) -> bool:
        """Check if version has invalid 'v' prefix."""
        if clean_value.startswith("v"):
            self.add_error(
                f'Invalid {lang_name} version format: "{value}" in {name}. '
                'Version prefix "v" is not allowed',
            )
            return False
        return True

    def _check_version_format(self, value: str, clean_value: str, name: str, config: dict) -> bool:
        """Check if version matches expected format pattern."""
        if not re.match(config["pattern"], clean_value):
            self.add_error(
                f'Invalid {config["name"]} version format: "{value}" in {name}. '
                "Must be X.Y or X.Y.Z format",
            )
            return False
        return True

    def _check_leading_zeros(self, value: str, parts: list[str], name: str, lang_name: str) -> bool:
        """Check for invalid leading zeros in version parts."""
        for part in parts:
            if part.startswith("0") and len(part) > 1:
                self.add_error(
                    f'Invalid {lang_name} version format: "{value}" in {name}. '
                    "Leading zeros are not allowed",
                )
                return False
        return True

    def _validate_major_version(
        self,
        major: int,
        value: str,
        name: str,
        major_range: int | tuple[int, int] | None,
        lang_name: str,
    ) -> bool:
        """Validate major version against allowed range."""
        if isinstance(major_range, int):
            if major != major_range:
                self.add_error(
                    f'{lang_name} version "{value}" in {name}. '
                    f"{lang_name} major version should be {major_range}",
                )
                return False
        elif major_range:
            min_major, max_major = major_range
            if major < min_major or major > max_major:
                self.add_error(
                    f'{lang_name} version "{value}" in {name}. '
                    f"Major version should be between {min_major} and {max_major}",
                )
                return False
        return True

    def _validate_minor_version(
        self,
        minor: int,
        value: str,
        name: str,
        minor_range: tuple[int, int] | None,
        lang_name: str,
    ) -> bool:
        """Validate minor version against allowed range."""
        if minor_range:
            min_minor, max_minor = minor_range
            if minor < min_minor or minor > max_minor:
                self.add_error(
                    f'{lang_name} version "{value}" in {name}. '
                    f"Minor version should be between {min_minor} and {max_minor}",
                )
                return False
        return True

    def _validate_language_version(self, value: str, name: str, config: dict) -> bool:
        """Consolidated language version validation."""
        if not value or value.strip() == "":
            if config.get("required", False):
                self.add_error(f'Input "{name}" is required and cannot be empty')
                return False
            return True

        clean_value = value.strip()
        lang_name = config["name"]

        # Check for invalid 'v' prefix
        if not self._check_version_prefix(value, clean_value, name, lang_name):
            return False

        # Check version format matches pattern
        if not self._check_version_format(value, clean_value, name, config):
            return False

        # Parse version components
        parts = clean_value.split(".")
        major = int(parts[0])
        minor = int(parts[1]) if len(parts) > 1 else 0

        # Check for leading zeros if required
        if config.get("check_leading_zeros") and not self._check_leading_zeros(
            value, parts, name, lang_name
        ):
            return False

        # Validate major version range
        major_valid = self._validate_major_version(
            major, value, name, config.get("major_range"), lang_name
        )
        if not major_valid:
            return False

        # Validate minor version range
        return self._validate_minor_version(
            minor, value, name, config.get("minor_range"), lang_name
        )