#!/usr/bin/env python3
import os
import json
import subprocess
import argparse
from pathlib import Path
import fnmatch

class TreeClone:
    def __init__(self):
        self.default_exclude_dirs = {'.git', '__pycache__', 'node_modules', '.DS_Store', '.vscode'}
        self.noclone_filename = '.noclone'
    
    def parse_noclone_file(self, noclone_path):
        """Parse .noclone file and return patterns to exclude."""
        patterns = []
        
        try:
            with open(noclone_path, 'r') as f:
                for line in f:
                    line = line.strip()
                    # Skip empty lines and comments
                    if line and not line.startswith('#'):
                        patterns.append(line)
        except FileNotFoundError:
            pass
        
        return patterns
    
    def collect_noclone_patterns(self, root_path):
        """Collect all .noclone patterns from root and subdirectories."""
        all_patterns = {}
        root = Path(root_path)
        
        # Find all .noclone files in the directory tree
        for noclone_file in root.rglob(self.noclone_filename):
            # Get patterns from this .noclone file
            patterns = self.parse_noclone_file(noclone_file)
            if patterns:
                # Store patterns with their directory context
                relative_dir = noclone_file.parent.relative_to(root)
                all_patterns[str(relative_dir)] = patterns
        
        return all_patterns
    
    def should_exclude_item(self, item_path, root_path, noclone_patterns):
        """Check if an item should be excluded based on .noclone patterns."""
        # Check default exclusions
        if any(excluded in item_path.parts for excluded in self.default_exclude_dirs):
            return True
        
        root = Path(root_path)
        relative_path = item_path.relative_to(root)
        
        # Check patterns from all applicable .noclone files
        for pattern_dir, patterns in noclone_patterns.items():
            pattern_path = Path(pattern_dir)
            
            # Check if this pattern directory applies to our item
            try:
                # If the item is in this directory or a subdirectory
                if pattern_path == Path('.') or pattern_path in relative_path.parents or pattern_path == relative_path.parent:
                    # Test each pattern
                    for pattern in patterns:
                        # Support both file names and paths
                        if fnmatch.fnmatch(item_path.name, pattern) or fnmatch.fnmatch(str(relative_path), pattern):
                            return True
            except ValueError:
                # relative_path calculation failed, skip this pattern
                continue
        
        return False
    
    def capture_with_tree(self, directory, output_file):
        """Capture using tree command if available."""
        try:
            result = subprocess.run(
                ['tree', '-J', directory], 
                capture_output=True, 
                text=True, 
                check=True
            )
            structure = json.loads(result.stdout)
            
            with open(output_file, 'w') as f:
                json.dump(structure, f, indent=2)
            
            return True
        except (subprocess.CalledProcessError, FileNotFoundError, json.JSONDecodeError):
            return False
    
    def capture_manual(self, directory, output_file, include_files=True, max_depth=None):
        """Manual capture without tree command, respecting .noclone files."""
        root = Path(directory)
        
        # Collect all .noclone patterns
        noclone_patterns = self.collect_noclone_patterns(root)
        
        print(f"Found .noclone patterns: {noclone_patterns}")
        
        def scan_directory(path, current_depth=0):
            if max_depth is not None and current_depth > max_depth:
                return []
                
            items = []
            try:
                for item in sorted(path.iterdir()):
                    # Check if item should be excluded
                    if self.should_exclude_item(item, root, noclone_patterns):
                        print(f"Excluding: {item.relative_to(root)}")
                        continue
                        
                    if item.is_dir():
                        children = scan_directory(item, current_depth + 1)
                        items.append({
                            'name': item.name,
                            'type': 'directory',
                            'children': children
                        })
                    elif include_files:
                        items.append({
                            'name': item.name,
                            'type': 'file'
                        })
            except PermissionError:
                pass
            
            return items
        
        structure = {
            'root': root.name,
            'noclone_patterns': noclone_patterns,
            'structure': scan_directory(root)
        }
        
        with open(output_file, 'w') as f:
            json.dump(structure, f, indent=2)
    
    def recreate_structure(self, structure_file, target_directory, create_files=True):
        """Recreate directory structure from JSON."""
        with open(structure_file, 'r') as f:
            structure = json.load(f)
        
        target = Path(target_directory)
        
        def create_items(items, current_path):
            for item in items:
                item_path = current_path / item['name']
                
                if item['type'] == 'directory':
                    item_path.mkdir(parents=True, exist_ok=True)
                    print(f"📁 {item_path}")
                    
                    if 'children' in item:
                        create_items(item['children'], item_path)
                        
                elif item['type'] == 'file' and create_files:
                    item_path.touch()
                    print(f"📄 {item_path}")
        
        root_path = target / structure['root']
        root_path.mkdir(parents=True, exist_ok=True)
        
        # Recreate .noclone files if they were captured
        if 'noclone_patterns' in structure:
            for pattern_dir, patterns in structure['noclone_patterns'].items():
                noclone_path = root_path / pattern_dir / self.noclone_filename
                noclone_path.parent.mkdir(parents=True, exist_ok=True)
                
                with open(noclone_path, 'w') as f:
                    f.write("# .noclone file - patterns to exclude from cloning\n")
                    for pattern in patterns:
                        f.write(f"{pattern}\n")
                
                print(f"📝 Created .noclone: {noclone_path}")
        
        if 'structure' in structure:
            create_items(structure['structure'], root_path)
        
        return root_path
    
    def create_sample_noclone(self, directory):
        """Create a sample .noclone file with common patterns."""
        noclone_path = Path(directory) / self.noclone_filename
        
        sample_content = """# .noclone file - patterns to exclude from TreeClone
# Lines starting with # are comments
# Supports glob patterns like *.log, temp*, etc.

# Common files to exclude
*.log
*.tmp
*.cache
*.pid
.env
.env.local

# Directories to exclude
temp/
logs/
cache/
build/
dist/
coverage/

# IDE and editor files
.vscode/
.idea/
*.swp
*.swo
*~

# OS files
.DS_Store
Thumbs.db
desktop.ini

# Add your custom patterns below:
"""
        
        with open(noclone_path, 'w') as f:
            f.write(sample_content)
        
        print(f"Created sample .noclone file at: {noclone_path}")
        return noclone_path

def main():
    parser = argparse.ArgumentParser(description='TreeClone - Directory structure cloning tool')
    subparsers = parser.add_subparsers(dest='command', help='Available commands')
    
    # Capture command
    capture_parser = subparsers.add_parser('capture', help='Capture directory structure')
    capture_parser.add_argument('directory', help='Directory to capture')
    capture_parser.add_argument('-o', '--output', default='structure.json', help='Output file')
    capture_parser.add_argument('--no-files', action='store_true', help='Only capture directories')
    capture_parser.add_argument('--max-depth', type=int, help='Maximum depth')
    
    # Recreate command
    recreate_parser = subparsers.add_parser('recreate', help='Recreate directory structure')
    recreate_parser.add_argument('structure_file', help='JSON structure file')
    recreate_parser.add_argument('target_directory', help='Target directory')
    recreate_parser.add_argument('--no-files', action='store_true', help='Only create directories')
    
    # Init command for creating sample .noclone
    init_parser = subparsers.add_parser('init', help='Create sample .noclone file')
    init_parser.add_argument('directory', nargs='?', default='.', help='Directory to create .noclone in')
    
    args = parser.parse_args()
    
    tool = TreeClone()
    
    if args.command == 'capture':
        print(f"Capturing structure of {args.directory}...")
        
        # Always use manual capture to respect .noclone files
        print("Using manual capture to respect .noclone files...")
        tool.capture_manual(
            args.directory, 
            args.output, 
            include_files=not args.no_files,
            max_depth=args.max_depth
        )
        
        print(f"Structure saved to {args.output}")
        
    elif args.command == 'recreate':
        print(f"Recreating structure from {args.structure_file}...")
        created_path = tool.recreate_structure(
            args.structure_file,
            args.target_directory,
            create_files=not args.no_files
        )
        print(f"Structure recreated at: {created_path}")
    
    elif args.command == 'init':
        print(f"Creating sample .noclone file in {args.directory}...")
        tool.create_sample_noclone(args.directory)
        print("Edit the .noclone file to customize exclusion patterns.")
    
    else:
        parser.print_help()

if __name__ == '__main__':
    main()