#!/usr/bin/env python3
"""
Python Import Position Checker
檢查Python代碼文件中import語句是否出現(xiàn)在函數(shù)體內(nèi)部或之后
"""

import ast
import argparse
import sys
import os
from typing import List, Tuple, Dict, Any

class ImportPositionChecker:
    """檢查import語句位置的類"""
    
    def __init__(self):
        self.issues = []
    
    def check_file(self, filepath: str) -> List[Dict[str, Any]]:
        """
        檢查單個文件的import語句位置
        
        Args:
            filepath: 文件路徑
            
        Returns:
            問題列表
        """
        self.issues = []
        
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                content = f.read()
            
            tree = ast.parse(content, filename=filepath)
            self._analyze_ast(tree, filepath, content)
            
        except SyntaxError as e:
            self.issues.append({
                'file': filepath,
                'line': e.lineno,
                'col': e.offset,
                'type': 'syntax_error',
                'message': f'Syntax error: {e.msg}'
            })
        except Exception as e:
            self.issues.append({
                'file': filepath,
                'line': 0,
                'col': 0,
                'type': 'parse_error',
                'message': f'Failed to parse file: {str(e)}'
            })
        
        return self.issues
    
    def _analyze_ast(self, tree: ast.AST, filepath: str, content: str):
        """分析AST樹，檢測import位置問題"""
        
        # 獲取所有函數(shù)定義
        functions = []
        for node in ast.walk(tree):
            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                functions.append(node)
        
        # 獲取所有import語句
        imports = []
        for node in ast.walk(tree):
            if isinstance(node, (ast.Import, ast.ImportFrom)):
                imports.append(node)
        
        # 檢查每個import語句是否在函數(shù)內(nèi)部
        for import_node in imports:
            self._check_import_position(import_node, functions, filepath, content)
    
    def _check_import_position(self, import_node: ast.AST, functions: List[ast.AST], 
                              filepath: str, content: str):
        """檢查單個import語句的位置"""
        
        import_line = import_node.lineno
        
        # 查找這個import語句所在的函數(shù)
        containing_function = None
        for func in functions:
            if (hasattr(func, 'lineno') and hasattr(func, 'end_lineno') and
                func.lineno <= import_line <= func.end_lineno):
                containing_function = func
                break
        
        if containing_function:
            # import語句在函數(shù)內(nèi)部
            func_name = containing_function.name
            self.issues.append({
                'file': filepath,
                'line': import_line,
                'col': import_node.col_offset,
                'type': 'import_in_function',
                'message': f'Import statement found inside function "{func_name}" at line {import_line}',
                'suggestion': 'Move import to module level (top of file)'
            })
        
        # 檢查是否在第一個函數(shù)定義之后
        if functions:
            first_function_line = min(func.lineno for func in functions)
            if import_line > first_function_line:
                # 找出這個import語句之前最近的一個函數(shù)
                previous_functions = [f for f in functions if f.lineno < import_line]
                if previous_functions:
                    last_previous_func = max(previous_functions, key=lambda f: f.lineno)
                    self.issues.append({
                        'file': filepath,
                        'line': import_line,
                        'col': import_node.col_offset,
                        'type': 'import_after_function',
                        'message': f'Import statement at line {import_line} appears after function "{last_previous_func.name}" definition',
                        'suggestion': 'Move all imports to the top of the file, before any function definitions'
                    })

def main():
    """主函數(shù)"""
    parser = argparse.ArgumentParser(
        description='檢查Python代碼文件中import語句位置問題',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog='''
示例:
  %(prog)s example.py                    # 檢查單個文件
  %(prog)s src/ --exclude test_*        # 檢查目錄，排除測試文件
  %(prog)s . --fix                      # 檢查并自動修復
        '''
    )
    
    parser.add_argument('path', help='要檢查的文件或目錄路徑')
    parser.add_argument('--exclude', nargs='+', default=[], 
                       help='要排除的文件模式')
    parser.add_argument('--fix', action='store_true', 
                       help='嘗試自動修復問題')
    parser.add_argument('--verbose', action='store_true', 
                       help='顯示詳細信息')
    
    args = parser.parse_args()
    
    checker = ImportPositionChecker()
    
    # 收集要檢查的文件
    files_to_check = []
    if os.path.isfile(args.path):
        files_to_check = [args.path]
    elif os.path.isdir(args.path):
        for root, dirs, files in os.walk(args.path):
            for file in files:
                if file.endswith('.py'):
                    filepath = os.path.join(root, file)
                    
                    # 檢查是否在排除列表中
                    exclude = False
                    for pattern in args.exclude:
                        if pattern in file or pattern in filepath:
                            exclude = True
                            break
                    
                    if not exclude:
                        files_to_check.append(filepath)
    
    # 檢查文件
    all_issues = []
    for filepath in files_to_check:
        if args.verbose:
            print(f"檢查文件: {filepath}")
        
        issues = checker.check_file(filepath)
        all_issues.extend(issues)
    
    # 輸出結(jié)果
    if all_issues:
        print(f"\n發(fā)現(xiàn) {len(all_issues)} 個import位置問題:")
        
        issues_by_type = {}
        for issue in all_issues:
            issue_type = issue['type']
            if issue_type not in issues_by_type:
                issues_by_type[issue_type] = []
            issues_by_type[issue_type].append(issue)
        
        for issue_type, issues in issues_by_type.items():
            print(f"\n{issue_type}: {len(issues)} 個問題")
            for issue in issues:
                print(f"  {issue['file']}:{issue['line']}:{issue['col']} - {issue['message']}")
                if 'suggestion' in issue:
                    print(f"    建議: {issue['suggestion']}")
        
        # 如果啟用修復功能
        if args.fix:
            print("\n開始自動修復...")
            fixed_count = fix_issues(all_issues)
            print(f"已修復 {fixed_count} 個文件")
        
        sys.exit(1)
    else:
        print("未發(fā)現(xiàn)import位置問題！")
        sys.exit(0)

def fix_issues(issues: List[Dict[str, Any]]) -> int:
    """自動修復問題（簡化版本）"""
    fixed_files = set()
    
    # 按文件分組問題
    issues_by_file = {}
    for issue in issues:
        filepath = issue['file']
        if filepath not in issues_by_file:
            issues_by_file[filepath] = []
        issues_by_file[filepath].append(issue)
    
    # 對每個有問題的文件進行修復
    for filepath, file_issues in issues_by_file.items():
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                lines = f.readlines()
            
            # 這里可以實現(xiàn)具體的修復邏輯
            # 由于修復邏輯較復雜，這里只是示例
            print(f"  需要修復: {filepath} (包含 {len(file_issues)} 個問題)")
            fixed_files.add(filepath)
            
        except Exception as e:
            print(f"  修復 {filepath} 時出錯: {str(e)}")
    
    return len(fixed_files)

if __name__ == '__main__':
    main()

#!/usr/bin/env python3
"""
測試文件 - 包含各種import位置問題的示例
"""

# 正確的import - 在模塊級別
import os
import sys
from typing import List, Dict

def function_with_import_inside():
    """函數(shù)內(nèi)部有import - 這是不推薦的"""
    import json  # 問題：在函數(shù)內(nèi)部import
    return json.dumps({"test": "value"})

class MyClass:
    """測試類"""
    
    def method_with_import(self):
        """方法內(nèi)部有import"""
        import datetime  # 問題：在方法內(nèi)部import
        return datetime.datetime.now()

# 在函數(shù)定義之后的import - 這也是不推薦的
def another_function():
    return "Hello World"

import re  # 問題：在函數(shù)定義之后

def yet_another_function():
    """另一個函數(shù)"""
    from collections import defaultdict  # 問題：在函數(shù)內(nèi)部import
    return defaultdict(list)

# 模塊級別的import - 這是正確的
import math

def bad_function():
    import json  # 檢測到的問題
    return json.dumps({})

def some_function():
    pass

???????import os  # 檢測到的問題

# 基本用法
python import_checker.py example.py

# 檢查目錄
python import_checker.py src/

# 排除測試文件
python import_checker.py . --exclude test_* *_test.py

# 詳細輸出
python import_checker.py . --verbose

# 自動修復
python import_checker.py . --fix

import correct_import

def function():
    import bad_import  # 應該被檢測到
    pass

class TestClass:
    def method(self):
        from collections import defaultdict  # 應該被檢測到
        return defaultdict()

import good_import

def first_function():
    pass

import bad_import_after_function  # 應該被檢測到

def second_function():
    import bad_import_inside  # 應該被檢測到
    pass

# 文檔字符串
"""模塊文檔"""

# 正確的import
import sys
import os

# 類型注解import
from typing import List, Optional

def correct_function():
    """這個函數(shù)沒有import問題"""
    return "OK"

# 更多正確的import
import math

python import_checker.py test_example.py --verbose

# GitHub Actions示例
- name: Check Import Positions
  run: python import_checker.py src/ --exclude test_*