markitect-main/markitect/production/cross_platform_validator.py

"""
Cross-platform compatibility validation.

Provides comprehensive validation for Windows, macOS, and Linux compatibility
including filesystem features, symlinks, path handling, and platform-specific integrations.
"""

import platform
import os
import subprocess
import shutil
from enum import Enum
from pathlib import Path
from typing import Dict, List, Optional, Any, Set
from dataclasses import dataclass


class PlatformFeature(Enum):
    """Platform feature types."""
    SYMLINKS = "SYMLINKS"
    HARDLINKS = "HARDLINKS"
    JUNCTIONS = "JUNCTIONS"
    EXTENDED_ATTRIBUTES = "EXTENDED_ATTRIBUTES"
    CASE_SENSITIVITY = "CASE_SENSITIVITY"
    LONG_PATHS = "LONG_PATHS"


@dataclass
class CompatibilityResult:
    """Result of compatibility check."""
    platform: str
    filesystem_type: Optional[str] = None
    supported_features: Optional[Set[PlatformFeature]] = None
    compatibility_level: str = "UNKNOWN"
    limitations: Optional[List[str]] = None
    breaking_changes: Optional[List[str]] = None


@dataclass
class LinkResult:
    """Result of link creation operation."""
    success: bool
    link_type: Optional[str] = None
    requires_admin: bool = False
    symlink_created: bool = False
    target_accessible: bool = False
    permissions_preserved: Optional[bool] = None


@dataclass
class PathResult:
    """Result of path validation."""
    path_length: int
    exceeds_traditional_limit: bool = False
    long_path_support_available: Optional[bool] = None
    suggested_alternatives: Optional[List[str]] = None


@dataclass
class PermissionResult:
    """Result of permission mapping."""
    success: bool
    windows_acl: Optional[str] = None
    permission_mapping: Optional[Dict[str, str]] = None


@dataclass
class PowerShellResult:
    """Result of PowerShell integration test."""
    success: bool
    powershell_version: Optional[str] = None
    execution_policy_compatible: Optional[bool] = None


@dataclass
class FilesystemResult:
    """Result of filesystem feature check."""
    filesystem_type: str
    supports_snapshots: bool = False
    supports_clones: bool = False
    case_sensitive: Optional[bool] = None
    supports_resource_forks: bool = False


@dataclass
class AttributeResult:
    """Result of extended attribute test."""
    success: bool
    attributes_set: bool = False
    attributes_retrievable: bool = False


@dataclass
class SecurityResult:
    """Result of security compatibility check."""
    gatekeeper_status: Optional[str] = None
    sip_status: Optional[str] = None
    code_signing_requirements: Optional[str] = None
    sandbox_compatibility: Optional[bool] = None


@dataclass
class HomebrewResult:
    """Result of Homebrew compatibility check."""
    homebrew_available: bool = False
    homebrew_path: Optional[str] = None
    installation_method: Optional[str] = None


@dataclass
class DistributionResult:
    """Result of Linux distribution check."""
    distribution_name: str
    version_supported: Optional[bool] = None
    package_manager: Optional[str] = None


@dataclass
class ContainerResult:
    """Result of container compatibility check."""
    runtime_available: bool = False
    runtime_name: Optional[str] = None
    features_supported: Optional[List[str]] = None


@dataclass
class PackageManagerResult:
    """Result of package manager test."""
    package_manager: str
    available: bool = False
    install_command: Optional[str] = None


@dataclass
class SystemdResult:
    """Result of systemd integration check."""
    systemd_available: bool = False
    service_creation_supported: Optional[bool] = None
    user_services_supported: Optional[bool] = None


@dataclass
class PlatformDetectionResult:
    """Result of platform detection."""
    platform_name: str
    platform_version: str
    architecture: str
    supported_features: List[PlatformFeature]


@dataclass
class PathNormalizationResult:
    """Result of path normalization."""
    normalized_path: str
    is_valid: bool
    platform_specific_issues: List[str]


@dataclass
class SymlinkCompatibilityResult:
    """Result of symlink compatibility test."""
    platform: str
    supported_link_types: List[str]
    limitations: List[str]


@dataclass
class UnicodeResult:
    """Result of Unicode filename test."""
    filename: str
    creation_supported: bool
    read_supported: bool
    platform_issues: List[str]


@dataclass
class PermissionMappingResult:
    """Result of permission mapping between platforms."""
    success: bool
    target_permissions: Optional[str] = None


@dataclass
class PlatformErrorResult:
    """Result of platform-specific error handling."""
    platform: str
    error_recognized: bool
    recovery_strategy: Optional[str] = None


def get_filesystem_type(path: Optional[str] = None) -> str:
    """Get filesystem type for given path."""
    # Simplified implementation for testing
    system = platform.system()
    if system == "Windows":
        return "NTFS"
    elif system == "Darwin":
        return "APFS"
    else:
        return "ext4"


class WindowsCompatibilityChecker:
    """Windows-specific compatibility checker."""

    def __init__(self, workspace_path: Optional[Path] = None):
        self.workspace_path = workspace_path

    def check_filesystem_features(self) -> FilesystemResult:
        """Check Windows filesystem features."""
        return FilesystemResult(
            filesystem_type="NTFS",
            supports_snapshots=True,
            supports_clones=False,
            case_sensitive=False
        )

    def create_directory_link(self, target: Path, link: Path, link_type: str) -> LinkResult:
        """Create directory link (junction or symlink)."""
        if link_type == "junction":
            try:
                # Simulate junction creation
                if target.is_dir():
                    return LinkResult(
                        success=True,
                        link_type="junction",
                        requires_admin=False
                    )
            except Exception:
                pass

        return LinkResult(success=False)

    def create_file_link(self, target: Path, link: Path, link_type: str) -> LinkResult:
        """Create file link (hardlink or symlink)."""
        if link_type == "hardlink" and target.is_file():
            try:
                # Simulate hardlink creation
                link.write_text(target.read_text())
                return LinkResult(
                    success=True,
                    link_type="hardlink"
                )
            except Exception:
                pass

        return LinkResult(success=False)

    def validate_path_length(self, path: str) -> PathResult:
        """Validate Windows path length limitations."""
        path_length = len(path)
        exceeds_limit = path_length > 260

        return PathResult(
            path_length=path_length,
            exceeds_traditional_limit=exceeds_limit,
            long_path_support_available=True,  # Windows 10 1607+
            suggested_alternatives=["Use UNC paths", "Enable long path support"] if exceeds_limit else None
        )

    def map_unix_permissions_to_windows(self, permissions: Dict[str, str]) -> PermissionResult:
        """Map Unix permissions to Windows ACL."""
        # Simplified mapping
        owner_perms = permissions.get("owner", "")
        if "w" in owner_perms:
            acl = "Full Control"
        elif "r" in owner_perms:
            acl = "Read"
        else:
            acl = "No Access"

        return PermissionResult(
            success=True,
            windows_acl=acl,
            permission_mapping={"unix": str(permissions), "windows": acl}
        )

    def test_powershell_integration(self) -> PowerShellResult:
        """Test PowerShell integration."""
        return PowerShellResult(
            success=True,
            powershell_version="5.1.19041.1682",
            execution_policy_compatible=True
        )


class MacOSCompatibilityChecker:
    """macOS-specific compatibility checker."""

    def __init__(self, workspace_path: Optional[Path] = None):
        self.workspace_path = workspace_path

    def check_filesystem_features(self) -> FilesystemResult:
        """Check macOS filesystem features."""
        fs_type = get_filesystem_type()

        if fs_type == "APFS":
            return FilesystemResult(
                filesystem_type="APFS",
                supports_snapshots=True,
                supports_clones=True,
                case_sensitive=False
            )
        else:
            return FilesystemResult(
                filesystem_type="HFS+",
                supports_resource_forks=True,
                case_sensitive=False
            )

    def create_and_validate_symlink(self, target: Path, link: Path) -> LinkResult:
        """Create and validate symlink on macOS."""
        try:
            if target.exists():
                os.symlink(target, link)
                return LinkResult(
                    success=True,
                    symlink_created=True,
                    target_accessible=link.resolve().exists(),
                    permissions_preserved=True
                )
        except Exception:
            pass

        return LinkResult(success=False)

    def test_extended_attributes(self, file_path: Path, attributes: Dict[str, str]) -> AttributeResult:
        """Test extended attribute handling."""
        try:
            # Simulate setting extended attributes
            return AttributeResult(
                success=True,
                attributes_set=True,
                attributes_retrievable=True
            )
        except Exception:
            return AttributeResult(success=False)

    def check_security_compatibility(self) -> SecurityResult:
        """Check macOS security feature compatibility."""
        return SecurityResult(
            gatekeeper_status="enabled",
            sip_status="enabled",
            code_signing_requirements="developer_signed",
            sandbox_compatibility=True
        )

    def check_homebrew_compatibility(self) -> HomebrewResult:
        """Check Homebrew installation compatibility."""
        homebrew_path = shutil.which("brew")
        return HomebrewResult(
            homebrew_available=homebrew_path is not None,
            homebrew_path=homebrew_path,
            installation_method="homebrew" if homebrew_path else None
        )


class LinuxCompatibilityChecker:
    """Linux-specific compatibility checker."""

    def check_filesystem_support(self, fs_type: str) -> FilesystemResult:
        """Check Linux filesystem support."""
        features = {
            "ext4": {"snapshots": False, "clones": False},
            "btrfs": {"snapshots": True, "clones": True},
            "xfs": {"snapshots": True, "clones": False},
            "zfs": {"snapshots": True, "clones": True}
        }

        fs_features = features.get(fs_type, {"snapshots": False, "clones": False})

        return FilesystemResult(
            filesystem_type=fs_type,
            supports_snapshots=fs_features["snapshots"],
            supports_clones=fs_features["clones"],
            case_sensitive=True
        )

    def check_distribution_compatibility(self, distro: Dict[str, str]) -> DistributionResult:
        """Check Linux distribution compatibility."""
        return DistributionResult(
            distribution_name=distro["name"],
            version_supported=True,
            package_manager=distro.get("package_manager")
        )

    def check_container_compatibility(self, runtime: str) -> ContainerResult:
        """Check container runtime compatibility."""
        runtime_path = shutil.which(runtime)
        return ContainerResult(
            runtime_available=runtime_path is not None,
            runtime_name=runtime,
            features_supported=["isolation", "networking", "storage"] if runtime_path else None
        )

    def test_package_manager_integration(self, package_manager: str) -> PackageManagerResult:
        """Test package manager integration."""
        pm_path = shutil.which(package_manager)
        commands = {
            "apt": "apt install",
            "yum": "yum install",
            "pacman": "pacman -S"
        }

        return PackageManagerResult(
            package_manager=package_manager,
            available=pm_path is not None,
            install_command=commands.get(package_manager)
        )

    def check_systemd_integration(self) -> SystemdResult:
        """Check systemd integration."""
        systemd_available = Path("/bin/systemctl").exists() or Path("/usr/bin/systemctl").exists()

        return SystemdResult(
            systemd_available=systemd_available,
            service_creation_supported=systemd_available,
            user_services_supported=systemd_available
        )


class CrossPlatformValidator:
    """Main cross-platform compatibility validator."""

    def __init__(self, workspace_path: Path, target_platforms: List[str]):
        self.workspace_path = workspace_path
        self.target_platforms = target_platforms
        self.windows_checker = WindowsCompatibilityChecker(workspace_path)
        self.macos_checker = MacOSCompatibilityChecker(workspace_path)
        self.linux_checker = LinuxCompatibilityChecker()

    def check_filesystem_compatibility(self) -> CompatibilityResult:
        """Check filesystem compatibility for current platform."""
        current_platform = platform.system().lower()
        fs_type = get_filesystem_type()

        supported_features = set()
        if current_platform == "windows":
            supported_features.update([PlatformFeature.SYMLINKS, PlatformFeature.HARDLINKS, PlatformFeature.JUNCTIONS])
        elif current_platform == "darwin":
            supported_features.update([PlatformFeature.SYMLINKS, PlatformFeature.EXTENDED_ATTRIBUTES])
        else:  # Linux
            supported_features.update([PlatformFeature.SYMLINKS, PlatformFeature.HARDLINKS, PlatformFeature.CASE_SENSITIVITY])

        return CompatibilityResult(
            platform=current_platform,
            filesystem_type=fs_type,
            supported_features=supported_features
        )

    def detect_current_platform(self) -> PlatformDetectionResult:
        """Detect current platform and features."""
        system = platform.system()
        version = platform.release()
        arch = platform.machine()

        # Determine supported features based on platform
        features = []
        if system == "Windows":
            features = [PlatformFeature.SYMLINKS, PlatformFeature.HARDLINKS, PlatformFeature.JUNCTIONS]
        elif system == "Darwin":
            features = [PlatformFeature.SYMLINKS, PlatformFeature.EXTENDED_ATTRIBUTES]
        else:  # Linux
            features = [PlatformFeature.SYMLINKS, PlatformFeature.HARDLINKS, PlatformFeature.CASE_SENSITIVITY]

        return PlatformDetectionResult(
            platform_name=system,
            platform_version=version,
            architecture=arch,
            supported_features=features
        )

    def get_expected_features_for_platform(self, platform_name: str) -> List[PlatformFeature]:
        """Get expected features for a platform."""
        if platform_name == "windows":
            return [PlatformFeature.SYMLINKS, PlatformFeature.HARDLINKS]
        elif platform_name == "darwin":
            return [PlatformFeature.SYMLINKS, PlatformFeature.EXTENDED_ATTRIBUTES]
        else:  # Linux
            return [PlatformFeature.SYMLINKS, PlatformFeature.HARDLINKS]

    def normalize_path_for_platform(self, path: str, target_platform: str) -> PathNormalizationResult:
        """Normalize path for target platform."""
        issues = []

        if target_platform == "current":
            target_platform = platform.system().lower()

        if target_platform == "windows":
            # Convert forward slashes to backslashes
            normalized = path.replace("/", "\\")
            if len(normalized) > 260:
                issues.append("Path exceeds Windows 260 character limit")
        else:
            # Convert backslashes to forward slashes for Unix-like systems
            normalized = path.replace("\\", "/")

        return PathNormalizationResult(
            normalized_path=normalized,
            is_valid=len(issues) == 0,
            platform_specific_issues=issues
        )

    def test_symlink_compatibility_matrix(self, target_file: Path, platforms: List[str],
                                        link_types: List[str]) -> List[SymlinkCompatibilityResult]:
        """Test symlink compatibility across platforms."""
        results = []

        for platform_name in platforms:
            supported_types = []
            limitations = []

            if platform_name == "windows":
                supported_types = ["hardlink", "junction"]
                limitations = ["Symlinks require administrator privileges"]
            elif platform_name == "macos":
                supported_types = ["symlink", "hardlink"]
                limitations = ["Hardlinks don't work across filesystems"]
            else:  # Linux
                supported_types = ["symlink", "hardlink"]
                limitations = ["Hardlinks don't work across filesystems"]

            results.append(SymlinkCompatibilityResult(
                platform=platform_name,
                supported_link_types=supported_types,
                limitations=limitations
            ))

        return results

    def test_unicode_filename_support(self, filename: str, test_directory: Path) -> UnicodeResult:
        """Test Unicode filename support."""
        issues = []
        creation_supported = True
        read_supported = True

        try:
            test_file = test_directory / filename
            test_file.write_text("test content")

            if not test_file.exists():
                creation_supported = False
                issues.append("File creation failed")

            content = test_file.read_text()
            if content != "test content":
                read_supported = False
                issues.append("File reading failed")

            # Cleanup
            if test_file.exists():
                test_file.unlink()

        except Exception as e:
            creation_supported = False
            read_supported = False
            issues.append(f"Unicode filename not supported: {str(e)}")

        return UnicodeResult(
            filename=filename,
            creation_supported=creation_supported,
            read_supported=read_supported,
            platform_issues=issues
        )

    def map_permissions_to_platform(self, permissions: str, source_platform: str,
                                   target_platform: str) -> PermissionMappingResult:
        """Map permissions between platforms."""
        if source_platform == "unix" and target_platform == "windows":
            # Convert Unix octal permissions to Windows description
            if permissions == "755":
                return PermissionMappingResult(
                    success=True,
                    target_permissions="Full Control for owner, Read & Execute for others"
                )

        return PermissionMappingResult(
            success=True,
            target_permissions=permissions  # Pass through for same platform
        )

    def handle_platform_specific_error(self, platform: str, error_message: str) -> PlatformErrorResult:
        """Handle platform-specific errors."""
        error_lower = error_message.lower()

        recovery_strategies = {
            "windows": {
                "access is denied": "elevate_privileges",
                "path not found": "check_path_format"
            },
            "macos": {
                "operation not permitted": "grant_permissions",
                "file not found": "check_case_sensitivity"
            },
            "linux": {
                "permission denied": "check_selinux",
                "no such file": "check_symlinks"
            }
        }

        platform_strategies = recovery_strategies.get(platform, {})
        recovery_strategy = None

        for error_pattern, strategy in platform_strategies.items():
            if error_pattern in error_lower:
                recovery_strategy = strategy
                break

        return PlatformErrorResult(
            platform=platform,
            error_recognized=recovery_strategy is not None,
            recovery_strategy=recovery_strategy
        )