from __future__ import annotations

from pathlib import Path
from typing import Any

from src.ctb_copy.reports.daily_copy_report import collect_report_stats
from src.ctb_copy.runtime_paths import CopyResearchPaths, day_string


def build_phase7_scorecard(paths: CopyResearchPaths | None = None, day: str | None = None) -> dict[str, Any]:
    """Build a read-only Phase-7 Copytrading Research v1 scorecard.

    This aggregates the existing ctb_copy watchlist, discovery registry, leader
    scorecard, shadow-position engine and follower fill model into a concise
    roadmap/status object. It never grants live-copy permission.
    """
    resolved_paths = paths or CopyResearchPaths()
    resolved_day = day or day_string()
    stats = collect_report_stats(resolved_paths, resolved_day)
    shadow = stats.shadow_summary if isinstance(stats.shadow_summary, dict) else {}
    registry = stats.discovery_registry_summary if isinstance(stats.discovery_registry_summary, dict) else {}

    capabilities = {
        "runtime_watchlist": True,
        "vault_snapshot_collector": True,
        "wallet_snapshot_collector": True,
        "leader_scorecard": True,
        "shadow_copy_position_engine": True,
        "follower_fill_model": True,
        "daily_copy_report": True,
    }
    evidence = {
        "enabled_wallets": stats.enabled_wallets_count,
        "enabled_vaults": stats.enabled_vaults_count,
        "vault_snapshots": stats.vault_snapshots,
        "wallet_snapshots": stats.wallet_snapshots,
        "market_context_snapshots": stats.market_context_snapshots,
        "registry_total": int(registry.get("total", 0)),
        "shadow_decisions": int(shadow.get("decisions_count", 0)),
        "shadow_allowed": int(shadow.get("allowed_count", 0)),
        "shadow_blocked": int(shadow.get("blocked_count", 0)),
        "copy_permission": bool(stats.observation_watchlist.get("copy_permission", False)),
    }
    blockers: list[str] = []
    if evidence["enabled_wallets"] == 0 and evidence["enabled_vaults"] == 0:
        blockers.append("no_enabled_copy_watchlist_entries")
    if evidence["shadow_decisions"] == 0:
        blockers.append("no_shadow_position_deltas_yet")
    if evidence["registry_total"] == 0:
        blockers.append("no_leaders_in_discovery_registry_yet")
    if evidence["copy_permission"]:
        blockers.append("unexpected_copy_permission_true")
    if not bool(stats.guard.get("read_only", True)) or bool(stats.guard.get("live_orders", False)):
        blockers.append("read_only_guard_not_green")

    return {
        "version": "copytrading_research.v1",
        "day": resolved_day,
        "runtime_dir": str(resolved_paths.root),
        "capabilities": capabilities,
        "evidence": evidence,
        "registry_by_status": registry.get("by_status", {}),
        "top_shadow_block_reasons": shadow.get("top_block_reasons", {}),
        "data_quality": list(stats.data_quality),
        "status": "closed_v1_collecting_evidence",
        "blockers": blockers,
        "research_only": True,
        "copy_permission": False,
        "live_copy_allowed": False,
        "vault_deposits_allowed": False,
        "wallet_execution_allowed": False,
        "mainnet_signed_action": False,
    }


def format_phase7_scorecard(scorecard: dict[str, Any]) -> str:
    raw_evidence = scorecard.get("evidence")
    evidence = raw_evidence if isinstance(raw_evidence, dict) else {}
    raw_blockers = scorecard.get("blockers")
    blockers = raw_blockers if isinstance(raw_blockers, list) else []
    blocker_text = ",".join(str(item) for item in blockers[:5]) if blockers else "keine"
    return (
        "Copytrading Research v1: "
        f"status={scorecard.get('status')}, "
        f"watchlist_wallets={evidence.get('enabled_wallets', 0)}, "
        f"watchlist_vaults={evidence.get('enabled_vaults', 0)}, "
        f"registry={evidence.get('registry_total', 0)}, "
        f"shadow_decisions={evidence.get('shadow_decisions', 0)}, "
        f"blocker={blocker_text}, "
        "mode=research_only, live_copy=nein"
    )