SuperClaude/setup/services/files.py

"""
Cross-platform file management for SuperClaude installation system
"""

import shutil
import stat
from typing import List, Optional, Callable, Dict, Any
from pathlib import Path
import fnmatch
import hashlib


class FileService:
    """Cross-platform file operations manager"""
    
    def __init__(self, dry_run: bool = False):
        """
        Initialize file manager
        
        Args:
            dry_run: If True, only simulate file operations
        """
        self.dry_run = dry_run
        self.copied_files: List[Path] = []
        self.created_dirs: List[Path] = []
        
    def copy_file(self, source: Path, target: Path, preserve_permissions: bool = True) -> bool:
        """
        Copy single file with permission preservation
        
        Args:
            source: Source file path
            target: Target file path
            preserve_permissions: Whether to preserve file permissions
            
        Returns:
            True if successful, False otherwise
        """
        if not source.exists():
            raise FileNotFoundError(f"Source file not found: {source}")
        
        if not source.is_file():
            raise ValueError(f"Source is not a file: {source}")
        
        if self.dry_run:
            print(f"[DRY RUN] Would copy {source} -> {target}")
            return True
        
        try:
            # Ensure target directory exists
            target.parent.mkdir(parents=True, exist_ok=True)
            
            # Copy file
            if preserve_permissions:
                shutil.copy2(source, target)
            else:
                shutil.copy(source, target)
            
            self.copied_files.append(target)
            return True
            
        except Exception as e:
            print(f"Error copying {source} to {target}: {e}")
            return False
    
    def copy_directory(self, source: Path, target: Path, ignore_patterns: Optional[List[str]] = None) -> bool:
        """
        Recursively copy directory with gitignore-style patterns
        
        Args:
            source: Source directory path
            target: Target directory path
            ignore_patterns: List of patterns to ignore (gitignore style)
            
        Returns:
            True if successful, False otherwise
        """
        if not source.exists():
            raise FileNotFoundError(f"Source directory not found: {source}")
        
        if not source.is_dir():
            raise ValueError(f"Source is not a directory: {source}")
        
        ignore_patterns = ignore_patterns or []
        default_ignores = ['.git', '.gitignore', '__pycache__', '*.pyc', '.DS_Store']
        all_ignores = ignore_patterns + default_ignores
        
        if self.dry_run:
            print(f"[DRY RUN] Would copy directory {source} -> {target}")
            return True
        
        try:
            # Create ignore function
            def ignore_func(directory: str, contents: List[str]) -> List[str]:
                ignored = []
                for item in contents:
                    item_path = Path(directory) / item
                    rel_path = item_path.relative_to(source)
                    
                    # Check against ignore patterns
                    for pattern in all_ignores:
                        if fnmatch.fnmatch(item, pattern) or fnmatch.fnmatch(str(rel_path), pattern):
                            ignored.append(item)
                            break
                
                return ignored
            
            # Copy tree
            shutil.copytree(source, target, ignore=ignore_func, dirs_exist_ok=True)
            
            # Track created directories and files
            for item in target.rglob('*'):
                if item.is_dir():
                    self.created_dirs.append(item)
                else:
                    self.copied_files.append(item)
            
            return True
            
        except Exception as e:
            print(f"Error copying directory {source} to {target}: {e}")
            return False
    
    def ensure_directory(self, directory: Path, mode: int = 0o755) -> bool:
        """
        Create directory and parents if they don't exist
        
        Args:
            directory: Directory path to create
            mode: Directory permissions (Unix only)
            
        Returns:
            True if successful, False otherwise
        """
        if self.dry_run:
            print(f"[DRY RUN] Would create directory {directory}")
            return True
        
        try:
            directory.mkdir(parents=True, exist_ok=True, mode=mode)
            
            if directory not in self.created_dirs:
                self.created_dirs.append(directory)
            
            return True
            
        except Exception as e:
            print(f"Error creating directory {directory}: {e}")
            return False
    
    def remove_file(self, file_path: Path) -> bool:
        """
        Remove single file
        
        Args:
            file_path: Path to file to remove
            
        Returns:
            True if successful, False otherwise
        """
        if not file_path.exists():
            return True  # Already gone
        
        if self.dry_run:
            print(f"[DRY RUN] Would remove file {file_path}")
            return True
        
        try:
            if file_path.is_file():
                file_path.unlink()
            else:
                print(f"Warning: {file_path} is not a file, skipping")
                return False
            
            # Remove from tracking
            if file_path in self.copied_files:
                self.copied_files.remove(file_path)
            
            return True
            
        except Exception as e:
            print(f"Error removing file {file_path}: {e}")
            return False
    
    def remove_directory(self, directory: Path, recursive: bool = False) -> bool:
        """
        Remove directory
        
        Args:
            directory: Directory path to remove
            recursive: Whether to remove recursively
            
        Returns:
            True if successful, False otherwise
        """
        if not directory.exists():
            return True  # Already gone
        
        if self.dry_run:
            action = "recursively remove" if recursive else "remove"
            print(f"[DRY RUN] Would {action} directory {directory}")
            return True
        
        try:
            if recursive:
                shutil.rmtree(directory)
            else:
                directory.rmdir()  # Only works if empty
            
            # Remove from tracking
            if directory in self.created_dirs:
                self.created_dirs.remove(directory)
            
            return True
            
        except Exception as e:
            print(f"Error removing directory {directory}: {e}")
            return False
    
    def resolve_home_path(self, path: str) -> Path:
        """
        Convert path with ~ to actual home path on any OS
        
        Args:
            path: Path string potentially containing ~
            
        Returns:
            Resolved Path object
        """
        return Path(path).expanduser().resolve()
    
    def make_executable(self, file_path: Path) -> bool:
        """
        Make file executable (Unix/Linux/macOS)
        
        Args:
            file_path: Path to file to make executable
            
        Returns:
            True if successful, False otherwise
        """
        if not file_path.exists():
            return False
        
        if self.dry_run:
            print(f"[DRY RUN] Would make {file_path} executable")
            return True
        
        try:
            # Get current permissions
            current_mode = file_path.stat().st_mode
            
            # Add execute permissions for owner, group, and others
            new_mode = current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
            
            file_path.chmod(new_mode)
            return True
            
        except Exception as e:
            print(f"Error making {file_path} executable: {e}")
            return False
    
    def get_file_hash(self, file_path: Path, algorithm: str = 'sha256') -> Optional[str]:
        """
        Calculate file hash
        
        Args:
            file_path: Path to file
            algorithm: Hash algorithm (md5, sha1, sha256, etc.)
            
        Returns:
            Hex hash string or None if error
        """
        if not file_path.exists() or not file_path.is_file():
            return None
        
        try:
            hasher = hashlib.new(algorithm)
            
            with open(file_path, 'rb') as f:
                # Read in chunks for large files
                for chunk in iter(lambda: f.read(8192), b""):
                    hasher.update(chunk)
            
            return hasher.hexdigest()
            
        except Exception:
            return None
    
    def verify_file_integrity(self, file_path: Path, expected_hash: str, algorithm: str = 'sha256') -> bool:
        """
        Verify file integrity using hash
        
        Args:
            file_path: Path to file to verify
            expected_hash: Expected hash value
            algorithm: Hash algorithm used
            
        Returns:
            True if file matches expected hash, False otherwise
        """
        actual_hash = self.get_file_hash(file_path, algorithm)
        return actual_hash is not None and actual_hash.lower() == expected_hash.lower()
    
    def get_directory_size(self, directory: Path) -> int:
        """
        Calculate total size of directory in bytes
        
        Args:
            directory: Directory path
            
        Returns:
            Total size in bytes
        """
        if not directory.exists() or not directory.is_dir():
            return 0
        
        total_size = 0
        try:
            for file_path in directory.rglob('*'):
                if file_path.is_file():
                    total_size += file_path.stat().st_size
        except Exception:
            pass  # Skip files we can't access
        
        return total_size
    
    def find_files(self, directory: Path, pattern: str = '*', recursive: bool = True) -> List[Path]:
        """
        Find files matching pattern
        
        Args:
            directory: Directory to search
            pattern: Glob pattern to match
            recursive: Whether to search recursively
            
        Returns:
            List of matching file paths
        """
        if not directory.exists() or not directory.is_dir():
            return []
        
        try:
            if recursive:
                return list(directory.rglob(pattern))
            else:
                return list(directory.glob(pattern))
        except Exception:
            return []
    
    def backup_file(self, file_path: Path, backup_suffix: str = '.backup') -> Optional[Path]:
        """
        Create backup copy of file
        
        Args:
            file_path: Path to file to backup
            backup_suffix: Suffix to add to backup file
            
        Returns:
            Path to backup file or None if failed
        """
        if not file_path.exists() or not file_path.is_file():
            return None
        
        backup_path = file_path.with_suffix(file_path.suffix + backup_suffix)
        
        if self.copy_file(file_path, backup_path):
            return backup_path
        return None
    
    def get_free_space(self, path: Path) -> int:
        """
        Get free disk space at path in bytes
        
        Args:
            path: Path to check (can be file or directory)
            
        Returns:
            Free space in bytes
        """
        try:
            if path.is_file():
                path = path.parent
            
            stat_result = shutil.disk_usage(path)
            return stat_result.free
        except Exception:
            return 0
    
    def cleanup_tracked_files(self) -> None:
        """Remove all files and directories created during this session"""
        if self.dry_run:
            print("[DRY RUN] Would cleanup tracked files")
            return
        
        # Remove files first
        for file_path in reversed(self.copied_files):
            try:
                if file_path.exists():
                    file_path.unlink()
            except Exception:
                pass
        
        # Remove directories (in reverse order of creation)
        for directory in reversed(self.created_dirs):
            try:
                if directory.exists() and not any(directory.iterdir()):
                    directory.rmdir()
            except Exception:
                pass
        
        self.copied_files.clear()
        self.created_dirs.clear()
    
    def get_operation_summary(self) -> Dict[str, Any]:
        """
        Get summary of file operations performed
        
        Returns:
            Dict with operation statistics
        """
        return {
            'files_copied': len(self.copied_files),
            'directories_created': len(self.created_dirs),
            'dry_run': self.dry_run,
            'copied_files': [str(f) for f in self.copied_files],
            'created_directories': [str(d) for d in self.created_dirs]
        }