"""
Code Transformation API

High-level code transformation operations for refactoring and code quality.
"""

import ast
import re
from pathlib import Path
from typing import List, Dict, Optional, Callable
from .filesystem import read_file, write_file, search_replace


def rename_identifier(
    pattern: str,
    old_name: str,
    new_name: str,
    file_pattern: str = "**/*.py",
    regex: bool = False
) -> Dict[str, any]:
    """
    Rename identifier across all matching files.

    Args:
        pattern: Base directory pattern
        old_name: Current identifier name
        new_name: New identifier name
        file_pattern: File glob pattern
        regex: Use regex matching

    Returns:
        Dict with files modified and counts
    """
    base_path = Path(pattern) if Path(pattern).is_dir() else Path.cwd()
    files = list(base_path.glob(file_pattern))

    results = []
    total_replacements = 0

    for file_path in files:
        if not file_path.is_file():
            continue

        try:
            content = read_file(str(file_path))

            # Use word boundaries for identifier replacement
            if regex:
                pattern_str = old_name
            else:
                # Match whole words only (identifier boundaries)
                pattern_str = rf'\b{re.escape(old_name)}\b'

            new_content, count = re.subn(pattern_str, new_name, content)

            if count > 0:
                write_file(str(file_path), new_content, create_backup=True)
                results.append({
                    "file": str(file_path),
                    "replacements": count,
                    "status": "modified"
                })
                total_replacements += count

        except Exception as e:
            results.append({
                "file": str(file_path),
                "status": "error",
                "error": str(e)
            })

    return {
        "files_modified": len([r for r in results if r["status"] == "modified"]),
        "total_replacements": total_replacements,
        "details": results
    }


def add_type_hints(
    file_path: str,
    function_name: Optional[str] = None
) -> Dict[str, any]:
    """
    Add basic type hints to functions.

    Note: This is a simple implementation. For production use,
    consider using tools like MonkeyType or PyAnnotate.

    Args:
        file_path: Path to Python file
        function_name: Specific function to annotate (None for all)

    Returns:
        Dict with status and functions modified
    """
    # This is a placeholder for a more sophisticated implementation
    # A full implementation would use AST manipulation to add type hints
    # based on analysis or type inference

    return {
        "status": "not_implemented",
        "message": "Type hint addition requires sophisticated type inference. "
                   "Consider using tools like MonkeyType or manual annotation."
    }


def remove_debug_statements(
    file_path: str,
    statements: Optional[List[str]] = None
) -> Dict[str, any]:
    """
    Remove debug print statements and logging from code.

    Args:
        file_path: Path to Python file
        statements: List of patterns to remove (default: common debug patterns)

    Returns:
        Dict with status and lines removed
    """
    if statements is None:
        statements = [
            r'^\s*print\(',
            r'^\s*console\.log\(',
            r'^\s*debugger;?',
            r'^\s*import pdb.*',
            r'^\s*pdb\.set_trace\(',
            r'^\s*breakpoint\(',
        ]

    content = read_file(file_path)
    lines = content.splitlines(keepends=True)

    new_lines = []
    removed_count = 0

    for line in lines:
        should_remove = False
        for pattern in statements:
            if re.search(pattern, line):
                should_remove = True
                removed_count += 1
                break

        if not should_remove:
            new_lines.append(line)

    if removed_count > 0:
        write_file(file_path, ''.join(new_lines), create_backup=True)

    return {
        "status": "success",
        "file": file_path,
        "lines_removed": removed_count
    }


def convert_to_async(
    file_path: str,
    function_name: str
) -> Dict[str, any]:
    """
    Convert a synchronous function to async.

    Note: This is a basic implementation that adds async/await keywords.
    Manual review is recommended for complex cases.

    Args:
        file_path: Path to Python file
        function_name: Function to convert

    Returns:
        Dict with status
    """
    content = read_file(file_path)

    # Simple pattern-based conversion
    # Replace 'def function_name' with 'async def function_name'
    pattern = rf'(\s*)def\s+{re.escape(function_name)}\s*\('
    replacement = r'\1async def ' + function_name + '('

    new_content, count = re.subn(pattern, replacement, content)

    if count > 0:
        write_file(file_path, new_content, create_backup=True)
        return {
            "status": "success",
            "file": file_path,
            "message": f"Converted {function_name} to async. Manual review recommended for await calls."
        }
    else:
        return {
            "status": "not_found",
            "message": f"Function {function_name} not found in {file_path}"
        }


def apply_transformation(
    file_path: str,
    transform_fn: Callable[[str], str],
    create_backup: bool = True
) -> Dict[str, any]:
    """
    Apply custom transformation function to file.

    Args:
        file_path: Path to file
        transform_fn: Function that takes content and returns transformed content
        create_backup: Create backup before modifying

    Returns:
        Dict with status
    """
    try:
        content = read_file(file_path)
        transformed = transform_fn(content)

        if content != transformed:
            write_file(file_path, transformed, create_backup=create_backup)
            return {
                "status": "success",
                "file": file_path,
                "modified": True
            }
        else:
            return {
                "status": "success",
                "file": file_path,
                "modified": False,
                "message": "No changes after transformation"
            }

    except Exception as e:
        return {
            "status": "error",
            "file": file_path,
            "error": str(e)
        }


def batch_refactor(operations: List[Dict]) -> List[Dict]:
    """
    Execute multiple refactoring operations in sequence.

    Args:
        operations: List of operation dicts with:
            - type: 'rename', 'remove_debug', 'custom'
            - ... type-specific parameters

    Returns:
        List of result dicts
    """
    results = []

    for op in operations:
        try:
            op_type = op.get('type')

            if op_type == 'rename':
                result = rename_identifier(
                    pattern=op.get('pattern', '.'),
                    old_name=op['old_name'],
                    new_name=op['new_name'],
                    file_pattern=op.get('file_pattern', '**/*.py')
                )
                results.append(result)

            elif op_type == 'remove_debug':
                result = remove_debug_statements(
                    file_path=op['file_path'],
                    statements=op.get('statements')
                )
                results.append(result)

            elif op_type == 'search_replace':
                result = search_replace(
                    file_pattern=op['file_pattern'],
                    search=op['search'],
                    replace=op['replace'],
                    regex=op.get('regex', False)
                )
                results.append(result)

            elif op_type == 'custom':
                result = apply_transformation(
                    file_path=op['file_path'],
                    transform_fn=op['transform_fn']
                )
                results.append(result)

            else:
                results.append({
                    "status": "error",
                    "error": f"Unknown operation type: {op_type}"
                })

        except Exception as e:
            results.append({
                "status": "error",
                "operation": op.get('type', 'unknown'),
                "error": str(e)
            })

    return results


def add_docstrings(
    file_path: str,
    style: str = "google"
) -> Dict[str, any]:
    """
    Add placeholder docstrings to functions/classes missing them.

    Args:
        file_path: Path to Python file
        style: Docstring style ('google', 'numpy', or 'sphinx')

    Returns:
        Dict with status and functions modified
    """
    with open(file_path, 'r') as f:
        content = f.read()

    try:
        tree = ast.parse(content)
    except SyntaxError:
        return {"status": "error", "error": "Syntax error in file"}

    lines = content.splitlines()
    modifications = []

    # Find functions/classes without docstrings
    for node in ast.walk(tree):
        if isinstance(node, (ast.FunctionDef, ast.ClassDef)):
            if ast.get_docstring(node) is None:
                # Calculate indentation
                line_idx = node.lineno - 1
                indent = len(lines[line_idx]) - len(lines[line_idx].lstrip())

                # Create placeholder docstring
                if style == "google":
                    docstring = '"""TODO: Add description."""'
                elif style == "numpy":
                    docstring = '"""\n    TODO: Add description.\n    """'
                else:  # sphinx
                    docstring = '"""TODO: Add description."""'

                modifications.append({
                    "line": node.lineno,
                    "indent": indent,
                    "docstring": docstring,
                    "name": node.name
                })

    if modifications:
        # Insert docstrings (in reverse order to maintain line numbers)
        for mod in sorted(modifications, key=lambda x: x["line"], reverse=True):
            line_idx = mod["line"]
            indent_str = " " * (mod["indent"] + 4)
            docstring_line = f"{indent_str}{mod['docstring']}\n"
            lines.insert(line_idx, docstring_line)

        new_content = '\n'.join(lines)
        write_file(file_path, new_content, create_backup=True)

        return {
            "status": "success",
            "file": file_path,
            "docstrings_added": len(modifications),
            "functions": [m["name"] for m in modifications]
        }
    else:
        return {
            "status": "success",
            "file": file_path,
            "docstrings_added": 0,
            "message": "All functions/classes already have docstrings"
        }