#!/usr/bin/env python3
"""
CIF フォルダ整理エージェント v1.0
────────────────────────────────────
パソコン上で実行するフォルダスキャン・整理実行スクリプト

【必要なもの】
  Python 3.8以上
  pip install requests

【使い方】
  1. フォルダをスキャンして提案を作成:
     python folder_agent.py scan --path ~/Desktop --server https://あなたのCIFのURL

  2. 提案の一覧を確認:
     python folder_agent.py list --server https://あなたのCIFのURL

  3. 承認済み提案を実行（ファイルを実際に移動）:
     python folder_agent.py execute --id <proposal_id> --server https://あなたのCIFのURL

  4. 実行前に確認したい場合（dry-run）:
     python folder_agent.py execute --id <proposal_id> --server https://... --dry-run
"""

import os
import sys
import json
import argparse
import hashlib
from pathlib import Path
from datetime import datetime

try:
    import requests
except ImportError:
    print("❌ requests がインストールされていません。")
    print("   pip install requests  を実行してください。")
    sys.exit(1)


# ========================================
# 設定
# ========================================

MAX_DEPTH = 4          # スキャンする階層の深さ
MAX_FILES = 2000       # スキャンする最大ファイル数
SKIP_DIRS = {          # スキップするフォルダ名
    ".git", "__pycache__", "node_modules", ".DS_Store",
    "Library", "System", "private", "proc", "dev",
    ".Trash", "$RECYCLE.BIN", "Windows", "Program Files",
}
SKIP_EXTENSIONS = {    # スキャンしない拡張子（バイナリ等）
    ".exe", ".dll", ".so", ".dylib", ".bin",
}


# ========================================
# スキャン処理
# ========================================

def scan_directory(root_path: str) -> dict:
    """ディレクトリ構造をスキャン"""
    root = Path(root_path).expanduser().resolve()

    if not root.exists():
        print(f"❌ パスが存在しません: {root}")
        sys.exit(1)

    print(f"\n📂 スキャン開始: {root}")
    print("   (スキャン中...)\n")

    tree = []
    ext_stats = {}
    total_files = 0
    total_dirs = 0
    total_size = 0
    file_count = 0

    def walk(path: Path, depth: int):
        nonlocal total_files, total_dirs, total_size, file_count

        if depth > MAX_DEPTH:
            return
        if file_count > MAX_FILES:
            return

        try:
            entries = sorted(path.iterdir(), key=lambda x: (x.is_file(), x.name.lower()))
        except PermissionError:
            return

        for entry in entries:
            if entry.name.startswith(".") and depth > 0:
                continue
            if entry.name in SKIP_DIRS:
                continue

            if entry.is_dir():
                total_dirs += 1
                child_count = 0
                try:
                    child_count = sum(1 for _ in entry.iterdir())
                except PermissionError:
                    pass

                tree.append({
                    "type": "dir",
                    "name": entry.name,
                    "path": str(entry.relative_to(root)),
                    "depth": depth,
                    "child_count": child_count,
                })
                walk(entry, depth + 1)

            elif entry.is_file():
                if file_count >= MAX_FILES:
                    continue
                ext = entry.suffix.lower()
                if ext in SKIP_EXTENSIONS:
                    continue

                try:
                    size = entry.stat().st_size
                except OSError:
                    size = 0

                total_files += 1
                total_size += size
                file_count += 1
                ext_stats[ext] = ext_stats.get(ext, 0) + 1

                tree.append({
                    "type": "file",
                    "name": entry.name,
                    "path": str(entry.relative_to(root)),
                    "depth": depth,
                    "ext": ext,
                    "size_kb": round(size / 1024, 1),
                })

    walk(root, 0)

    result = {
        "root_path": str(root),
        "total_files": total_files,
        "total_dirs": total_dirs,
        "total_size_mb": round(total_size / (1024 * 1024), 2),
        "ext_stats": ext_stats,
        "tree": tree,
        "scanned_at": datetime.now().isoformat(),
        "truncated": file_count >= MAX_FILES,
    }

    print(f"  ✅ フォルダ数: {total_dirs}")
    print(f"  ✅ ファイル数: {total_files}{' (上限で打ち切り)' if result['truncated'] else ''}")
    print(f"  ✅ 合計サイズ: {result['total_size_mb']:.1f} MB")

    return result


# ========================================
# CIF API 通信
# ========================================

def send_scan(server: str, scan_data: dict, label: str = "") -> dict:
    """スキャン結果をCIFに送信"""
    url = f"{server.rstrip('/')}/api/folder/scan"
    print(f"\n📤 CIFに送信中...")

    try:
        resp = requests.post(url, json={"scan_data": scan_data, "label": label}, timeout=60)
        resp.raise_for_status()
        return resp.json()
    except requests.exceptions.ConnectionError:
        print(f"❌ CIFに接続できません: {server}")
        print("   サーバーURLが正しいか確認してください。")
        sys.exit(1)
    except Exception as e:
        print(f"❌ 送信エラー: {e}")
        sys.exit(1)


def get_proposals(server: str) -> list:
    """提案一覧を取得"""
    url = f"{server.rstrip('/')}/api/folder/proposals"
    try:
        resp = requests.get(url, timeout=15)
        resp.raise_for_status()
        return resp.json().get("proposals", [])
    except Exception as e:
        print(f"❌ 取得エラー: {e}")
        sys.exit(1)


def get_execution_plan(server: str, proposal_id: str) -> dict:
    """実行プランを取得"""
    url = f"{server.rstrip('/')}/api/folder/proposals/{proposal_id}"
    try:
        resp = requests.get(url, timeout=15)
        resp.raise_for_status()
        return resp.json()
    except Exception as e:
        print(f"❌ プラン取得エラー: {e}")
        sys.exit(1)


# ========================================
# ファイル整理実行
# ========================================

def execute_plan(root_path: str, moves: list, dry_run: bool = False) -> dict:
    """整理プランを実行"""
    root = Path(root_path).expanduser().resolve()
    results = {"success": [], "skipped": [], "errors": []}

    print(f"\n{'🔍 ドライラン（実際には移動しません）' if dry_run else '🚀 整理を実行します'}")
    print(f"   対象: {root}\n")

    for move in moves:
        action = move.get("action", "move")
        src_rel = move.get("from", "")
        dst_rel = move.get("to", "")

        if action == "create_folder":
            folder = root / dst_rel
            if not folder.exists():
                if not dry_run:
                    folder.mkdir(parents=True, exist_ok=True)
                print(f"  📁 フォルダ作成: {dst_rel}")
                results["success"].append(f"mkdir: {dst_rel}")
            else:
                print(f"  ✅ 既存: {dst_rel}")
                results["skipped"].append(f"exists: {dst_rel}")
            continue

        if not src_rel:
            continue

        src = root / src_rel
        if not src.exists():
            print(f"  ⚠️  スキップ（存在しない）: {src_rel}")
            results["skipped"].append(f"not_found: {src_rel}")
            continue

        dst = root / dst_rel

        print(f"  {'→' if not dry_run else '~'} {src_rel}")
        print(f"    {'→' if not dry_run else '~'} {dst_rel}  ({move.get('reason', '')})")

        if not dry_run:
            try:
                dst.parent.mkdir(parents=True, exist_ok=True)
                if action == "rename":
                    src.rename(dst)
                else:
                    import shutil
                    shutil.move(str(src), str(dst))
                results["success"].append(f"{action}: {src_rel} -> {dst_rel}")
            except Exception as e:
                print(f"    ❌ エラー: {e}")
                results["errors"].append(f"error: {src_rel}: {e}")
        else:
            results["success"].append(f"dry_{action}: {src_rel} -> {dst_rel}")

    return results


def notify_executed(server: str, proposal_id: str):
    """実行完了をCIFに通知"""
    url = f"{server.rstrip('/')}/api/folder/proposals/{proposal_id}/execute"
    try:
        requests.post(url, timeout=10)
    except Exception:
        pass


# ========================================
# コマンド処理
# ========================================

def cmd_scan(args):
    scan_data = scan_directory(args.path)
    label = args.label or Path(args.path).expanduser().name
    result = send_scan(args.server, scan_data, label)

    if not result.get("success"):
        print(f"❌ エラー: {result.get('error')}")
        sys.exit(1)

    proposal_id = result["proposal_id"]
    ui_url = result.get("ui_url", f"{args.server}/viewer/folder-organizer.html")

    print(f"\n{'='*55}")
    print(f"✅ 分析が完了しました！")
    print(f"{'='*55}")
    print(f"\n📋 提案ID: {proposal_id}")
    print(f"\n🌐 以下のURLをブラウザで開いて提案を確認・承認してください:")
    print(f"\n   {ui_url}?id={proposal_id}")
    print(f"\n承認後は以下のコマンドで実行できます:")
    print(f"   python folder_agent.py execute --id {proposal_id} --server {args.server}")
    print()


def cmd_list(args):
    proposals = get_proposals(args.server)
    if not proposals:
        print("\n📋 提案はまだありません。")
        return

    print(f"\n{'='*55}")
    print(f"  提案一覧 ({len(proposals)}件)")
    print(f"{'='*55}")

    status_icons = {
        "pending": "⏳", "analyzed": "🔍",
        "approved": "✅", "executed": "🎉"
    }
    for p in proposals:
        icon = status_icons.get(p["status"], "❓")
        print(f"\n{icon} [{p['id']}] {p.get('user_label', '名称なし')}")
        print(f"   状態: {p['status']}  作成: {p['created_at'][:16]}")

    print()


def cmd_execute(args):
    # プランを取得
    result = get_execution_plan(args.server, args.id)
    if not result.get("success"):
        print(f"❌ エラー: {result.get('error', '提案が見つかりません')}")
        sys.exit(1)

    proposal = result["proposal"]
    status = proposal.get("status")

    if status == "executed":
        print("⚠️  この提案はすでに実行済みです。")
        return

    if status not in ("approved", "analyzed"):
        print(f"⚠️  この提案はまだ承認されていません（現状: {status}）")
        print(f"   先にブラウザで承認してください:")
        print(f"   {args.server}/viewer/folder-organizer.html?id={args.id}")
        sys.exit(1)

    root_path = proposal["scan_data"]["root_path"]
    moves = proposal.get("execution_plan", [])

    print(f"\n📋 提案ID: {args.id}")
    print(f"📂 対象: {root_path}")
    print(f"📝 操作数: {len(moves)}件")

    if not moves:
        print("⚠️  実行する操作がありません。")
        return

    if not args.dry_run:
        print(f"\n⚠️  以下のフォルダを整理します: {root_path}")
        confirm = input("実行しますか？ (yes/no): ").strip().lower()
        if confirm not in ("yes", "y"):
            print("キャンセルしました。")
            return

    exec_results = execute_plan(root_path, moves, dry_run=args.dry_run)

    print(f"\n{'='*55}")
    if args.dry_run:
        print(f"🔍 ドライラン完了")
    else:
        print(f"🎉 整理完了！")
        notify_executed(args.server, args.id)

    print(f"  成功: {len(exec_results['success'])}件")
    print(f"  スキップ: {len(exec_results['skipped'])}件")
    print(f"  エラー: {len(exec_results['errors'])}件")
    if exec_results["errors"]:
        for e in exec_results["errors"]:
            print(f"  ❌ {e}")
    print()


# ========================================
# エントリポイント
# ========================================

def _fix_argv():
    """--server と --path がサブコマンドの後にある場合でも動くよう argv を整形"""
    argv = sys.argv[1:]
    subcommands = {"scan", "list", "execute"}

    sub_idx = next((i for i, a in enumerate(argv) if a in subcommands), None)
    if sub_idx is None:
        return

    def _extract(flag, args):
        for i, a in enumerate(args):
            if a == flag and i + 1 < len(args):
                val = args[i + 1]
                rest = args[:i] + args[i+2:]
                return val, rest
        return None, args

    server, argv = _extract("--server", argv)

    if server:
        sub_idx2 = next((i for i, a in enumerate(argv) if a in subcommands), None)
        if sub_idx2 is not None:
            argv = argv[:sub_idx2] + ["--server", server] + argv[sub_idx2:]
        else:
            argv = ["--server", server] + argv

    sys.argv[1:] = argv


def main():
    _fix_argv()

    parser = argparse.ArgumentParser(
        description="CIF フォルダ整理エージェント",
        formatter_class=argparse.RawDescriptionHelpFormatter,
    )
    parser.add_argument("--server", required=True,
                        help="CIFサーバーのURL（例: https://xxx.replit.app）")
    sub = parser.add_subparsers(dest="command")

    # scan
    p_scan = sub.add_parser("scan", help="フォルダをスキャンして提案を作成")
    p_scan.add_argument("--path", required=True, help="スキャンするフォルダのパス")
    p_scan.add_argument("--label", default="", help="ラベル（任意）")

    # list
    sub.add_parser("list", help="提案一覧を表示")

    # execute
    p_exec = sub.add_parser("execute", help="承認済み提案を実行")
    p_exec.add_argument("--id", required=True, help="提案ID")
    p_exec.add_argument("--dry-run", action="store_true",
                        help="実際に移動せずシミュレーションのみ実行")

    args = parser.parse_args()
    if not args.command:
        parser.print_help()
        sys.exit(0)

    if args.command == "scan":
        cmd_scan(args)
    elif args.command == "list":
        cmd_list(args)
    elif args.command == "execute":
        cmd_execute(args)


if __name__ == "__main__":
    main()
