import pytest
import gc
import time
import shutil
import sys
import os
import stat
import tempfile

# Save the original rmtree function
_original_rmtree = shutil.rmtree


def force_remove_readonly(func, path, exc_info):
    """
    Error handler for shutil.rmtree to handle read-only files on Windows.
    """
    try:
        os.chmod(path, stat.S_IWRITE)
        func(path)
    except Exception:
        pass


def windows_safe_rmtree(path, ignore_errors=False, onerror=None, onexc=None):
    """
    Extremely aggressive Windows-safe wrapper for shutil.rmtree.
    Tries multiple strategies to remove directories locked by Git.
    """
    if not os.path.exists(path):
        return
    
    max_attempts = 15
    
    for attempt in range(max_attempts):
        try:
            # Force garbage collection
            gc.collect()
            
            # Progressive delays
            if attempt > 0:
                time.sleep(0.1 * attempt)
            
            # On Windows, try to unlock .git directory specifically
            if sys.platform == 'win32' and attempt > 2:
                try:
                    # Close any potential Git handles by forcing a subprocess call
                    import subprocess
                    git_dir = os.path.join(path, '.git')
                    if os.path.exists(git_dir):
                        # Try to run git gc to close handles
                        subprocess.run(['git', '-C', path, 'gc'], 
                                     capture_output=True, timeout=1, check=False)
                except:
                    pass
            
            # Try removal with read-only handler
            if attempt < max_attempts - 1:
                return _original_rmtree(path, onerror=force_remove_readonly)
            else:
                # Last attempt - just ignore all errors
                return _original_rmtree(path, ignore_errors=True)
                
        except (PermissionError, OSError) as e:
            if attempt == max_attempts - 1:
                # Final attempt - ignore everything
                try:
                    return _original_rmtree(path, ignore_errors=True)
                except:
                    # If even that fails, just give up silently on Windows
                    if sys.platform == 'win32':
                        pass
                    else:
                        raise
            
            # Wait longer between attempts
            time.sleep(0.2 * (attempt + 1))


# Monkey-patch shutil.rmtree globally
shutil.rmtree = windows_safe_rmtree


# On Windows, make TemporaryDirectory more lenient with cleanup
if sys.platform == 'win32':
    _original_temp_cleanup = tempfile.TemporaryDirectory.cleanup
    
    def lenient_cleanup(self):
        """Cleanup that ignores errors on Windows."""
        try:
            _original_temp_cleanup(self)
        except (PermissionError, OSError):
            # Ignore cleanup errors on Windows - temp files will be cleaned up by OS eventually
            pass
    
    tempfile.TemporaryDirectory.cleanup = lenient_cleanup


@pytest.fixture(autouse=True)
def cleanup_after_test():
    """Force cleanup after each test."""
    yield
    gc.collect()
    time.sleep(0.1)


@pytest.fixture(autouse=True)
def ensure_git_closes():
    """Ensure all Git Repo objects are properly closed."""
    try:
        from git import Repo
        
        # Keep track of all repos
        repos = []
        original_init = Repo.__init__
        
        def tracking_init(self, *args, **kwargs):
            result = original_init(self, *args, **kwargs)
            repos.append(self)
            return result
        
        Repo.__init__ = tracking_init
        
        yield
        
        # Restore
        Repo.__init__ = original_init
        
        # Close all repos
        for repo in repos:
            try:
                if hasattr(repo, 'close'):
                    repo.close()
            except:
                pass
        
        repos.clear()
        gc.collect()
        time.sleep(0.1)
    except ImportError:
        yield


@pytest.fixture(autouse=True, scope="session")
def configure_git():
    """Configure Git to be more Windows-friendly."""
    import subprocess
    
    configs = [
        ['git', 'config', '--global', 'core.fsmonitor', 'false'],
        ['git', 'config', '--global', 'core.preloadindex', 'false'],
        ['git', 'config', '--global', 'gc.auto', '0'],
    ]
    
    for cmd in configs:
        try:
            subprocess.run(cmd, capture_output=True, timeout=2, check=False)
        except:
            pass
    
    yield