import os
import re
import shutil
import difflib
import argparse
import pydoc
from pathlib import Path

def find_custom_footnotes(text):
    """
    Find all footnotes in the format ^[{content}].
    Uses a cursor-based approach to support nested brackets (e.g., Markdown links).
    """
    results = []
    i = 0
    while i < len(text):
        idx = text.find('^[', i)
        if idx == -1:
            break
        
        depth = 0
        start = idx + 2
        end = -1
        
        for j in range(start, len(text)):
            if text[j] == '[':
                depth += 1
            elif text[j] == ']':
                if depth == 0:
                    end = j
                    break
                else:
                    depth -= 1
                    
        if end != -1:
            content = text[start:end]
            if not content.isdigit():
                results.append((idx, end + 1, content))
            i = end + 1
        else:
            i = start
    return results

def process_markdown_file(file_path):
    """
    Process a single markdown file and return original and modified text.
    """
    with open(file_path, 'r', encoding='utf-8') as f:
        original_text = f.read()

    target_footnotes = find_custom_footnotes(original_text)
    if not target_footnotes:
        return None

    existing_indices = [int(m.group(1)) for m in re.finditer(r'\[\^(\d+)\]', original_text)]
    current_max = max(existing_indices) if existing_indices else 0

    replacements = []
    new_footnote_definitions = []

    for start, end, content in target_footnotes:
        current_max += 1
        replacements.append((start, end, current_max))
        new_footnote_definitions.append((current_max, content))

    modified_text = original_text
    # Replace from back to front to maintain index integrity
    for start, end, footnote_idx in reversed(replacements):
        prefix_space = " " if start > 0 and modified_text[start-1] == ']' else ""
        modified_text = modified_text[:start] + f"{prefix_space}[^{footnote_idx}]" + modified_text[end:]

    if new_footnote_definitions:
        modified_text = modified_text.rstrip() + '\n\n'
        for idx, content in new_footnote_definitions:
            modified_text += f'[^{idx}]: {content}\n'

    return original_text, modified_text

def main():
    parser = argparse.ArgumentParser(description="Markdown Footnote Formatter")
    parser.add_argument('--auto', action='store_true', help="Auto-confirm without prompt (useful for build pipelines)")
    args = parser.parse_args()

    directory = "."
    # Find all .md files recursively
    all_files = list(Path(directory).rglob("*.md"))
    
    # Filter out node_modules to avoid unnecessary scanning in Vite projects
    md_files = [f for f in all_files if "node_modules" not in str(f)]
    
    if not md_files:
        print("No .md files found.")
        return

    changes_dict = {}
    for md_file in md_files:
        try:
            result = process_markdown_file(md_file)
            if result:
                changes_dict[md_file] = result
        except Exception as e:
            print(f"Error processing {md_file}: {e}")

    if not changes_dict:
        print("🎉 Scan complete. No footnotes need to be replaced.")
        return

    print(f"Found {len(changes_dict)} file(s) with changes.")

    if args.auto:
        print("Detected --auto flag. Executing replacements directly...")
        confirm_status = True
    else:
        # Build a single string for all diffs to be displayed via pager
        full_diff_output = []
        full_diff_output.append("=== PREVIEW OF CHANGES (Press 'q' to exit pager) ===\n")
        
        for file_path, (orig_text, mod_text) in changes_dict.items():
            full_diff_output.append(f"\nFILE: {file_path}")
            full_diff_output.append("-" * len(str(file_path)))
            
            diff = difflib.unified_diff(
                orig_text.splitlines(keepends=True), 
                mod_text.splitlines(keepends=True),
                fromfile='Before', tofile='After', n=2
            )
            full_diff_output.extend(list(diff))
        
        # Use pydoc.pager to allow scrolling through long outputs
        pydoc.pager("".join(full_diff_output))
        
        # Prevent accidental cancellation due to rapid Enter key presses
        print("\n" + "="*50)
        print(">>> PREVIEW FINISHED.")
        print(f">>> {len(changes_dict)} file(s) pending modification.")
        print("="*50)
        
        while True:
            user_input = input("Confirm replacement and generate .bak files? (y/n): ").strip().lower()
            if user_input == 'y':
                confirm_status = True
                break
            elif user_input == 'n':
                confirm_status = False
                break
            else:
                # If the user just pressed Enter or typed something else, ask again
                print("Invalid input. Please enter 'y' to confirm or 'n' to cancel.")

    if confirm_status:
        for file_path, (orig_text, mod_text) in changes_dict.items():
            bak_file_path = str(file_path) + ".bak"
            shutil.copy2(file_path, bak_file_path)
            with open(file_path, 'w', encoding='utf-8') as f:
                f.write(mod_text)
        print("✅ Replacement complete!")
    else:
        print("❌ Operation cancelled.")

if __name__ == "__main__":
    main()

import os
import re
import shutil
import datetime
from pathlib import Path

def get_file_mtime(file_path):
    """获取文件的最后修改时间，返回格式为 yyyy-mm-dd"""
    stat = os.stat(file_path)
    # 使用本地时间
    mtime = datetime.datetime.fromtimestamp(stat.st_mtime)
    return mtime.strftime('%Y-%m-%d')

def update_yaml_frontmatter(file_path, updated_date):
    """更新或创建 Markdown 文件的 YAML Frontmatter 中的 updated 字段"""
    with open(file_path, 'r', encoding='utf-8') as f:
        content = f.read()

    # 正则表达式匹配 YAML Frontmatter (--- ... ---)
    yaml_pattern = re.compile(r'^---\s*\n(.*?)\n---\s*\n', re.DOTALL)
    match = yaml_pattern.match(content)

    new_content = ""
    updated_field = f"updated: {updated_date}"

    if match:
        # 存在 Frontmatter
        frontmatter = match.group(1)
        body = content[match.end():]
        
        # 检查是否已有 updated 字段
        if re.search(r'^updated:', frontmatter, re.MULTILINE):
            # 替换旧的 updated 字段
            new_frontmatter = re.sub(r'^updated:.*$', updated_field, frontmatter, flags=re.MULTILINE)
        else:
            # 在 Frontmatter 末尾追加 updated 字段
            new_frontmatter = frontmatter.rstrip() + f"\n{updated_field}"
        
        new_content = f"---\n{new_frontmatter}\n---\n{body}"
    else:
        # 不存在 Frontmatter，在开头新建
        new_content = f"---\n{updated_field}\n---\n\n{content}"

    # 修改前备份
    shutil.copy2(file_path, str(file_path) + ".bak")
    
    with open(file_path, 'w', encoding='utf-8') as f:
        f.write(new_content)

def main():
    print("=== Markdown 修改日期同步工具 ===")
    src_dir_input = input("请输入源文件目录 (获取修改时间): ").strip()
    dst_dir_input = input("请输入目标文件目录 (填写 YAML): ").strip()

    src_root = Path(src_dir_input)
    dst_root = Path(dst_dir_input)

    if not src_root.exists() or not dst_root.exists():
        print("错误：源目录或目标目录不存在，请检查路径。")
        return

    # 递归查找源目录下的所有 .md 文件
    src_files = list(src_root.rglob("*.md"))
    
    if not src_files:
        print("源目录下未找到 .md 文件。")
        return

    print(f"开始处理，共发现 {len(src_files)} 个源文件...")
    success_count = 0
    skip_count = 0

    for src_file in src_files:
        # 获取相对路径，以便在目标目录中寻找对应文件
        rel_path = src_file.relative_to(src_root)
        dst_file = dst_root / rel_path

        if dst_file.exists():
            try:
                mdate = get_file_mtime(src_file)
                update_yaml_frontmatter(dst_file, mdate)
                print(f" [OK] 已同步: {rel_path} -> {mdate}")
                success_count += 1
            except Exception as e:
                print(f" [ERR] 处理 {rel_path} 时出错: {e}")
        else:
            # print(f" [SKIP] 目标目录不存在对应文件: {rel_path}")
            skip_count += 1

    print("-" * 30)
    print(f"同步完成！")
    print(f"成功更新: {success_count}")
    print(f"未找到对应目标文件: {skip_count}")
    print(f"备份文件已生成 (.bak)")

if __name__ == "__main__":
    main()

import sys
from pathlib import Path
import re
from ruamel.yaml import YAML
from ruamel.yaml.scalarstring import DoubleQuotedScalarString
from io import StringIO

def process_frontmatter(content: str) -> tuple[bool, str, str]:
    """同时处理 category 和 tags/tag"""
    
    fm_match = re.search(r'^(---\s*[\r\n]+)(.*?)([\r\n]+---\s*[\r\n]?)', content, re.DOTALL)
    if not fm_match:
        return False, content, "未检测到 Frontmatter"

    front_start, fm_body, front_end = fm_match.groups()
    remaining = content[fm_match.end():]

    yaml = YAML()
    yaml.preserve_quotes = True
    yaml.allow_unicode = True
    yaml.width = 2000
    yaml.default_flow_style = True

    try:
        metadata = yaml.load(fm_body)
    except Exception as e:
        return False, content, f"YAML 解析失败: {e}"

    changed = False
    preview_lines = []

    # ==================== 处理 category / categories ====================
    cat_key = None
    if 'category' in metadata:
        cat_key = 'category'
    elif 'categories' in metadata:
        cat_key = 'categories'

    if cat_key:
        cat = metadata.get(cat_key)
        if isinstance(cat, list) and len(cat) > 0:
            first_item = str(cat[0]).strip()
            metadata[cat_key] = first_item
            changed = True
            preview_lines.append(f"原 {cat_key}: {cat}\n→ 新 {cat_key}: {first_item}")
        elif isinstance(cat, (str, int, float)):
            preview_lines.append(f"{cat_key} 已经是字符串，跳过")
        else:
            preview_lines.append(f"{cat_key} 类型不支持，跳过")

    # ==================== 处理 tags / tag ====================
    tag_key = None
    if 'tags' in metadata:
        tag_key = 'tags'
    elif 'tag' in metadata:
        tag_key = 'tag'

    if tag_key:
        tags = metadata.get(tag_key)
        if isinstance(tags, (str, int, float)):
            tags = [str(tags)]
        elif not isinstance(tags, list):
            preview_lines.append(f"{tag_key} 不是列表，跳过")
            tags = None

        if tags and len(tags) > 0:
            metadata[tag_key] = [DoubleQuotedScalarString(str(t).strip()) for t in tags]
            changed = True
            preview_lines.append(f"原 {tag_key}: {tags}\n→ 新 {tag_key}: {metadata[tag_key]}")

    if not changed:
        return False, content, "没有需要修改的字段"

    # 生成新的 frontmatter
    stream = StringIO()
    yaml.dump(metadata, stream)
    new_fm_body = stream.getvalue().strip()

    new_content = front_start + new_fm_body + "\n" + front_end.strip() + "\n" + remaining

    preview = "\n".join(preview_lines)
    return True, new_content, preview


def main(directory="."):
    md_files = list(Path(directory).rglob("*.md"))
    print(f"共扫描到 {len(md_files)} 个 .md 文件\n")

    to_modify = []

    for file_path in sorted(md_files):
        try:
            with open(file_path, 'r', encoding='utf-8') as f:
                content = f.read()

            changed, new_content, preview = process_frontmatter(content)

            if changed:
                rel_path = file_path.relative_to(Path(directory))
                print(f"【将转换】 {rel_path}")
                print(f"{preview}\n")
                to_modify.append((file_path, new_content))

        except Exception as e:
            print(f"处理失败 {file_path.name}: {e}")

    if not to_modify:
        print("没有找到需要转换的文件。")
        return

    print(f"\n总计发现 {len(to_modify)} 个文件需要转换。")
    confirm = input("\n是否执行替换？(输入 y 或 yes 确认，其他取消): ").strip().lower()

    if confirm not in ('y', 'yes'):
        print("操作已取消。")
        return

    success = 0
    for file_path, new_content in to_modify:
        try:
            backup = file_path.with_suffix('.md.bak')
            with open(backup, 'w', encoding='utf-8') as f:
                f.write(open(file_path, 'r', encoding='utf-8').read())

            with open(file_path, 'w', encoding='utf-8') as f:
                f.write(new_content)
            print(f"✓ 替换成功: {file_path.name}")
            success += 1
        except Exception as e:
            print(f"✗ 写入失败 {file_path.name}: {e}")

    print(f"\n完成！成功处理 {success}/{len(to_modify)} 个文件（已自动生成 .bak 备份）")


if __name__ == "__main__":
    print("=== Markdown Frontmatter 清理工具 ===\n")
    print("功能：")
    print("  - category/categories → 只保留第一项并转为字符串")
    print("  - tags/tag → 转为紧凑行内数组 [\"标签1\", \"标签2\"]\n")

    target_dir = sys.argv[1] if len(sys.argv) > 1 else "."
    main(target_dir)