#!/usr/bin/env python3
"""
Python字符串引號(hào)規(guī)范檢查與修復(fù)工具
自動(dòng)檢查單引號(hào)字符串并建議替換為雙引號(hào)
"""

import ast
import tokenize
import argparse
import os
import sys
import json
from pathlib import Path
from typing import List, Dict, Tuple, Set, Any
import fnmatch

class StringQuoteChecker:
    """字符串引號(hào)檢查器"""
    
    def __init__(self):
        self.stats = {
            'files_processed': 0,
            'total_strings': 0,
            'single_quote_strings': 0,
            'replaced_strings': 0,
            'skipped_strings': 0,
            'error_files': 0,
            'issues_found': 0
        }
        self.issues = []
        
    def is_excluded_directory(self, filepath: str, exclude_dirs: List[str]) -> bool:
        """檢查是否在排除目錄中"""
        path = Path(filepath)
        for exclude_dir in exclude_dirs:
            if fnmatch.fnmatch(str(path), exclude_dir) or exclude_dir in path.parts:
                return True
        return False
    
    def is_whitelisted(self, filepath: str, whitelist: List[str]) -> bool:
        """檢查是否在白名單中"""
        if not whitelist:
            return False
        path = Path(filepath)
        for pattern in whitelist:
            if fnmatch.fnmatch(str(path), pattern):
                return True
        return False
    
    def is_docstring(self, filepath: str, line_no: int) -> bool:
        """檢查是否為模塊、類或函數(shù)的docstring"""
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                content = f.read()
            
            tree = ast.parse(content)
            
            # 檢查模塊級(jí)docstring
            if (isinstance(tree.body[0], ast.Expr) and 
                isinstance(tree.body[0].value, ast.Str) and 
                tree.body[0].lineno == line_no):
                return True
            
            # 檢查類和函數(shù)的docstring
            for node in ast.walk(tree):
                if (isinstance(node, (ast.FunctionDef, ast.ClassDef, ast.AsyncFunctionDef)) and
                    node.body and 
                    isinstance(node.body[0], ast.Expr) and 
                    isinstance(node.body[0].value, ast.Str) and 
                    node.body[0].lineno == line_no):
                    return True
                    
        except Exception:
            pass
            
        return False
    
    def analyze_file(self, filepath: str) -> List[Dict[str, Any]]:
        """分析單個(gè)文件中的字符串引號(hào)使用"""
        issues = []
        
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                content = f.read()
            
            # 使用tokenize進(jìn)行分詞分析
            f.seek(0)
            tokens = list(tokenize.generate_tokens(f.readline))
            
            for token in tokens:
                if token.type == tokenize.STRING:
                    self.stats['total_strings'] += 1
                    string_value = token.string
                    
                    # 跳過空字符串
                    if len(string_value) <= 2:
                        continue
                    
                    # 檢查是否為單引號(hào)字符串（排除雙引號(hào)包含單引號(hào)的情況）
                    if (string_value.startswith("'") and string_value.endswith("'") and
                        not ('"' in string_value and string_value.count('"') >= 2)):
                        
                        # 檢查前綴
                        prefix = ''
                        if string_value[0] in 'rubf' or string_value.startswith(('fr', 'rf', 'br', 'rb')):
                            # 提取前綴
                            quote_start = string_value.find("'")
                            if quote_start > 0:
                                prefix = string_value[:quote_start]
                        
                        # 跳過docstring
                        if self.is_docstring(filepath, token.start[0]):
                            self.stats['skipped_strings'] += 1
                            continue
                        
                        self.stats['single_quote_strings'] += 1
                        
                        issues.append({
                            'file': filepath,
                            'line': token.start[0],
                            'column': token.start[1],
                            'original_string': string_value,
                            'suggested_string': prefix + '"' + string_value[len(prefix)+1:-1] + '"',
                            'prefix': prefix,
                            'content': string_value[len(prefix)+1:-1]
                        })
                        
        except Exception as e:
            self.stats['error_files'] += 1
            print(f"錯(cuò)誤分析文件 {filepath}: {e}")
            
        return issues
    
    def replace_string_in_file(self, filepath: str, replacements: List[Dict[str, Any]]) -> int:
        """在文件中替換字符串"""
        replaced_count = 0
        
        try:
            with open(filepath, 'r', encoding='utf-8') as f:
                lines = f.readlines()
            
            # 按行號(hào)降序排序，避免替換時(shí)影響行號(hào)
            replacements.sort(key=lambda x: x['line'], reverse=True)
            
            for replacement in replacements:
                line_no = replacement['line'] - 1  # 轉(zhuǎn)換為0-based索引
                original = replacement['original_string']
                suggested = replacement['suggested_string']
                
                # 獲取當(dāng)前行內(nèi)容
                line_content = lines[line_no]
                
                # 替換字符串
                new_line = line_content.replace(original, suggested, 1)
                
                if new_line != line_content:
                    lines[line_no] = new_line
                    replaced_count += 1
                    print(f"替換: {original} -> {suggested}")
                else:
                    print(f"警告: 無法替換 {original}")
            
            # 寫回文件
            if replaced_count > 0:
                with open(filepath, 'w', encoding='utf-8') as f:
                    f.writelines(lines)
                    
        except Exception as e:
            print(f"錯(cuò)誤替換文件 {filepath}: {e}")
            
        return replaced_count
    
    def process_directory(self, root_dir: str, exclude_dirs: List[str], 
                         whitelist: List[str], auto_fix: bool = False) -> None:
        """處理目錄中的所有Python文件"""
        root_path = Path(root_dir)
        
        for py_file in root_path.rglob("*.py"):
            if self.is_excluded_directory(str(py_file), exclude_dirs):
                continue
                
            if whitelist and not self.is_whitelisted(str(py_file), whitelist):
                continue
                
            self.stats['files_processed'] += 1
            print(f"\n分析文件: {py_file}")
            
            issues = self.analyze_file(str(py_file))
            
            if issues:
                self.issues.extend(issues)
                self.stats['issues_found'] += len(issues)
                
                print(f"發(fā)現(xiàn) {len(issues)} 個(gè)單引號(hào)字符串:")
                
                replacements = []
                for issue in issues:
                    print(f"  行 {issue['line']}: {issue['original_string']}")
                    
                    if auto_fix:
                        replacements.append(issue)
                    else:
                        # 交互式確認(rèn)
                        response = input(f"替換為 {issue['suggested_string']}? (y/n/a): ").lower()
                        if response == 'y':
                            replacements.append(issue)
                        elif response == 'a':
                            auto_fix = True
                            replacements.append(issue)
                
                # 執(zhí)行替換
                if replacements:
                    replaced = self.replace_string_in_file(str(py_file), replacements)
                    self.stats['replaced_strings'] += replaced
                    print(f"成功替換 {replaced} 個(gè)字符串")
    
    def save_stats(self, output_file: str) -> None:
        """保存統(tǒng)計(jì)信息到JSON文件"""
        stats_data = {
            'summary': self.stats,
            'issues': self.issues
        }
        
        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump(stats_data, f, indent=2, ensure_ascii=False)
        
        print(f"\n統(tǒng)計(jì)信息已保存到: {output_file}")

def main():
    parser = argparse.ArgumentParser(description='Python字符串引號(hào)規(guī)范檢查與修復(fù)工具')
    parser.add_argument('path', help='要檢查的文件或目錄路徑')
    parser.add_argument('--exclude', nargs='*', default=[], help='排除的目錄模式')
    parser.add_argument('--whitelist', nargs='*', default=[], help='白名單文件模式')
    parser.add_argument('--auto-fix', action='store_true', help='自動(dòng)修復(fù)模式')
    parser.add_argument('--output', default='string_quote_stats.json', help='統(tǒng)計(jì)輸出文件')
    
    args = parser.parse_args()
    
    checker = StringQuoteChecker()
    
    if os.path.isfile(args.path):
        # 處理單個(gè)文件
        if args.whitelist and not checker.is_whitelisted(args.path, args.whitelist):
            print("文件不在白名單中")
            return
        
        issues = checker.analyze_file(args.path)
        if issues:
            replacements = []
            for issue in issues:
                print(f"行 {issue['line']}: {issue['original_string']}")
                
                if args.auto_fix:
                    replacements.append(issue)
                else:
                    response = input(f"替換為 {issue['suggested_string']}? (y/n): ").lower()
                    if response == 'y':
                        replacements.append(issue)
            
            if replacements:
                replaced = checker.replace_string_in_file(args.path, replacements)
                checker.stats['replaced_strings'] += replaced
                print(f"成功替換 {replaced} 個(gè)字符串")
    
    elif os.path.isdir(args.path):
        # 處理目錄
        checker.process_directory(args.path, args.exclude, args.whitelist, args.auto_fix)
    
    else:
        print(f"路徑不存在: {args.path}")
        return
    
    # 輸出統(tǒng)計(jì)信息
    print("\n" + "="*50)
    print("統(tǒng)計(jì)摘要:")
    for key, value in checker.stats.items():
        print(f"  {key}: {value}")
    
    # 保存詳細(xì)統(tǒng)計(jì)
    checker.save_stats(args.output)

if __name__ == "__main__":
    main()

def analyze_file(self, filepath: str) -> List[Dict[str, Any]]:
    # 使用tokenize精確識(shí)別字符串
    tokens = list(tokenize.generate_tokens(f.readline))
    
    for token in tokens:
        if token.type == tokenize.STRING:
            # 處理帶前綴的字符串：r、u、f、b等
            prefix = ''
            if string_value[0] in 'rubf' or string_value.startswith(('fr', 'rf', 'br', 'rb')):
                quote_start = string_value.find("'")
                if quote_start > 0:
                    prefix = string_value[:quote_start]

def is_docstring(self, filepath: str, line_no: int) -> bool:
    # 使用AST分析識(shí)別模塊、類、函數(shù)的docstring
    tree = ast.parse(content)
    
    # 檢查模塊級(jí)docstring
    if (isinstance(tree.body[0], ast.Expr) and 
        isinstance(tree.body[0].value, ast.Str) and 
        tree.body[0].lineno == line_no):
        return True

def replace_string_in_file(self, filepath: str, replacements: List[Dict[str, Any]]) -> int:
    # 按行號(hào)降序排序，避免替換時(shí)影響行號(hào)
    replacements.sort(key=lambda x: x['line'], reverse=True)
    
    for replacement in replacements:
        # 精確替換，避免誤操作
        new_line = line_content.replace(original, suggested, 1)

'''模塊docstring - 應(yīng)該被忽略'''
# 單行單引號(hào)字符串 - 應(yīng)該被替換
single_quote = 'hello world'

# 雙引號(hào)字符串 - 應(yīng)該保持不變
double_quote = "hello world"

# 包含單引號(hào)的雙引號(hào)字符串 - 應(yīng)該保持不變
contains_single = "it's a test"

# 包含雙引號(hào)的單引號(hào)字符串 - 應(yīng)該被替換
contains_double = 'he said "hello"'

# 帶前綴的字符串
raw_string = r'raw string'
unicode_string = u'unicode string'
bytes_string = b'bytes string'
formatted_string = f'formatted {single_quote}'

class MyClass:
    '''類docstring - 應(yīng)該被忽略'''
    
    def __init__(self):
        '''方法docstring - 應(yīng)該被忽略'''
        self.message = 'instance attribute'

def my_function():
    '''函數(shù)docstring - 應(yīng)該被忽略'''
    local_var = 'local variable'
    return 'return value'

# 交互式模式
python string_quote_checker.py test_example.py

# 自動(dòng)修復(fù)模式
python string_quote_checker.py test_example.py --auto-fix

# 目錄處理模式
python string_quote_checker.py ./src --exclude "*/migrations/*" --whitelist "*.py" --output stats.json

'''模塊docstring - 應(yīng)該被忽略'''
# 單行單引號(hào)字符串 - 應(yīng)該被替換
single_quote = "hello world"

# 雙引號(hào)字符串 - 應(yīng)該保持不變
double_quote = "hello world"

# 包含單引號(hào)的雙引號(hào)字符串 - 應(yīng)該保持不變
contains_single = "it's a test"

# 包含雙引號(hào)的單引號(hào)字符串 - 應(yīng)該被替換
contains_double = "he said \"hello\""

# 帶前綴的字符串
raw_string = r"raw string"
unicode_string = u"unicode string"
bytes_string = b"bytes string"
formatted_string = f"formatted {single_quote}"

class MyClass:
    '''類docstring - 應(yīng)該被忽略'''
    
    def __init__(self):
        '''方法docstring - 應(yīng)該被忽略'''
        self.message = "instance attribute"

def my_function():
    '''函數(shù)docstring - 應(yīng)該被忽略'''
    local_var = "local variable"
    return "return value"

{
  "summary": {
    "files_processed": 1,
    "total_strings": 15,
    "single_quote_strings": 8,
    "replaced_strings": 6,
    "skipped_strings": 3,
    "error_files": 0,
    "issues_found": 6
  },
  "issues": [
    {
      "file": "test_example.py",
      "line": 3,
      "column": 16,
      "original_string": "'hello world'",
      "suggested_string": "\"hello world\"",
      "prefix": "",
      "content": "hello world"
    }
  ]
}