#!/usr/bin/env python3
"""
VaultMesh Funding Roadmap — Genesis Receipt Generator
Rubedo Seal II: Treasury Nebula Activation

Generates cryptographic genesis receipt for complete funding roadmap:
- Computes SHA-256 hash of all roadmap files
- Builds Merkle tree from file hashes
- Creates genesis receipt with Rubedo seal
- Produces human-readable proof chain document
- Emits receipt to VaultMesh permanent ledger

Usage:
    python3 generate_genesis_receipt.py [--dry-run]
"""

import json
import hashlib
import datetime
from pathlib import Path
from typing import List, Dict, Tuple
import sys

class MerkleTree:
    """Simple Merkle tree implementation for funding roadmap files."""

    @staticmethod
    def hash_data(data: str) -> str:
        """SHA-256 hash of data."""
        return hashlib.sha256(data.encode('utf-8')).hexdigest()

    @staticmethod
    def hash_pair(left: str, right: str) -> str:
        """Hash two nodes together."""
        return hashlib.sha256((left + right).encode('utf-8')).hexdigest()

    @classmethod
    def build_tree(cls, leaf_hashes: List[str]) -> Tuple[str, List[List[str]]]:
        """
        Build Merkle tree from leaf hashes.
        Returns: (root_hash, tree_levels)
        """
        if not leaf_hashes:
            return cls.hash_data(""), [[]]

        # If odd number of leaves, duplicate last one
        if len(leaf_hashes) % 2 == 1:
            leaf_hashes = leaf_hashes + [leaf_hashes[-1]]

        tree_levels = [leaf_hashes]
        current_level = leaf_hashes

        while len(current_level) > 1:
            next_level = []
            for i in range(0, len(current_level), 2):
                left = current_level[i]
                right = current_level[i + 1] if i + 1 < len(current_level) else current_level[i]
                parent = cls.hash_pair(left, right)
                next_level.append(parent)
            tree_levels.append(next_level)
            current_level = next_level

        return current_level[0], tree_levels

class FundingRoadmapGenesis:
    """Genesis receipt generator for VaultMesh Funding Roadmap."""

    def __init__(self, roadmap_dir: Path):
        self.roadmap_dir = roadmap_dir
        self.timestamp = datetime.datetime.now(datetime.timezone.utc)
        self.files_data = []

    def scan_files(self) -> List[Dict]:
        """Scan all roadmap files and compute hashes."""
        print(f"📂 Scanning {self.roadmap_dir}")

        # Include all markdown, CSV, and Mermaid files
        patterns = ['**/*.md', '**/*.csv', '**/*.mmd']
        all_files = []

        for pattern in patterns:
            all_files.extend(self.roadmap_dir.glob(pattern))

        # Sort for deterministic ordering
        all_files = sorted(all_files)

        for file_path in all_files:
            try:
                content = file_path.read_text(encoding='utf-8')
                file_hash = hashlib.sha256(content.encode('utf-8')).hexdigest()

                self.files_data.append({
                    'path': str(file_path.relative_to(self.roadmap_dir)),
                    'hash': file_hash,
                    'size': len(content),
                    'lines': content.count('\n') + 1
                })

                print(f"  ✓ {file_path.name:50s} {file_hash[:16]}... ({len(content):6d} bytes)")

            except Exception as e:
                print(f"  ✗ {file_path.name}: {e}")

        return self.files_data

    def build_merkle_tree(self) -> Tuple[str, List[List[str]]]:
        """Build Merkle tree from file hashes."""
        print(f"\n🌳 Building Merkle tree from {len(self.files_data)} files")

        leaf_hashes = [f['hash'] for f in self.files_data]
        root_hash, tree_levels = MerkleTree.build_tree(leaf_hashes)

        print(f"  → Tree depth: {len(tree_levels)} levels")
        print(f"  → Root hash: {root_hash}")

        return root_hash, tree_levels

    def generate_genesis_receipt(self, merkle_root: str) -> Dict:
        """Generate genesis receipt for funding roadmap."""
        print(f"\n🜂 Generating Genesis Receipt (Rubedo Seal)")

        # Calculate aggregate statistics
        total_lines = sum(f['lines'] for f in self.files_data)
        total_bytes = sum(f['size'] for f in self.files_data)

        receipt = {
            "kind": "funding.roadmap.genesis",
            "milestone": "Treasury Nebula Activation",
            "phase": "Rubedo",
            "seal": "II",
            "ts": self.timestamp.isoformat(),
            "coordinator": "VaultMesh Technologies B.V.",
            "guardian": "guardian@vaultmesh.org",

            "manifest": {
                "files_count": len(self.files_data),
                "total_lines": total_lines,
                "total_bytes": total_bytes,
                "merkle_root": merkle_root
            },

            "funding_axis": {
                "proposals": 8,
                "total_budget_eur": "15.8M+",
                "partners": "20+",
                "countries": "10+",
                "work_packages": "25+",
                "pilots": "12+",
                "diagrams": 4,
                "timeline": "2025-2027"
            },

            "deliverables": {
                "loi_template": True,
                "onboarding_kit": True,
                "consortium_tracker": True,
                "architecture_diagrams": 4,
                "meta_visualization": "treasury-nebula-map.mmd"
            },

            "tier_1_proposals": [
                {
                    "name": "PQC Integration",
                    "budget_eur": "2.8M",
                    "call": "HORIZON-CL3-2025-CS-ECCC-06",
                    "deadline": "2025-12-15",
                    "partners": 4
                },
                {
                    "name": "Digital Twins",
                    "budget_eur": "10M",
                    "call": "HORIZON-CL4-2025-DIGITAL-03",
                    "deadline": "2026-01-20",
                    "partners": 6
                }
            ],

            "vaultmesh_organs": [
                "LAWCHAIN",
                "Ψ-Field",
                "Federation",
                "Receipts",
                "Treasury"
            ],

            "policy_alignment": [
                "AI Act (Reg 2024/1689)",
                "DORA",
                "NIS2",
                "Gaia-X",
                "EHDS"
            ],

            "files": self.files_data,

            "proof_chain": {
                "hash_algorithm": "SHA-256",
                "tree_type": "Merkle",
                "anchoring": {
                    "rfc3161_tsa": "pending",
                    "ethereum": "pending",
                    "bitcoin": "pending"
                }
            },

            "declaration": "All Funding Organs Activated. Treasury Nebula Breathing.",

            "next_horizon": {
                "milestone": "PQC Integration Submission",
                "deadline": "2025-12-15",
                "days_remaining": 39
            }
        }

        return receipt

    def save_receipt(self, receipt: Dict, dry_run: bool = False) -> Path:
        """Save receipt to VaultMesh ledger."""
        receipts_dir = Path.home() / '.vaultmesh' / 'receipts'

        if not receipts_dir.exists():
            print(f"\n⚠️  Receipt directory not found: {receipts_dir}")
            receipts_dir = self.roadmap_dir / 'proofs'
            receipts_dir.mkdir(exist_ok=True)
            print(f"  → Using fallback: {receipts_dir}")

        timestamp_str = self.timestamp.strftime("%Y%m%d%H%M%S")
        receipt_path = receipts_dir / f'genesis-roadmap-rubedo-{timestamp_str}.json'

        if dry_run:
            print(f"\n🏃 DRY RUN: Would save to {receipt_path}")
            print(json.dumps(receipt, indent=2)[:500] + "\n...")
        else:
            receipt_path.write_text(json.dumps(receipt, indent=2))
            print(f"\n✅ Genesis receipt saved: {receipt_path}")

        return receipt_path

    def generate_proof_chain_document(self, receipt: Dict, merkle_root: str,
                                     tree_levels: List[List[str]], dry_run: bool = False) -> Path:
        """Generate human-readable proof chain document."""
        doc_path = self.roadmap_dir / 'PROOF_CHAIN.md'

        doc_content = f"""# VaultMesh Funding Roadmap — Proof Chain

**Genesis Receipt:** Rubedo Seal II — Treasury Nebula Activation
**Timestamp:** {self.timestamp.isoformat()}
**Merkle Root:** `{merkle_root}`

---

## 🜂 Rubedo Genesis Block

This document provides cryptographic proof of the VaultMesh Funding Roadmap 2025-2027 at the moment of Rubedo attainment (Treasury Nebula Activation).

**What this proves:**
- All {len(self.files_data)} files in the funding roadmap existed at this timestamp
- The Merkle root cryptographically binds all files together
- Any modification to any file will change the Merkle root
- This genesis receipt can be anchored to RFC-3161 TSA and blockchain for tamper-evidence

---

## 📊 Manifest Summary

**Files:** {receipt['manifest']['files_count']}
**Total Lines:** {receipt['manifest']['total_lines']:,}
**Total Bytes:** {receipt['manifest']['total_bytes']:,}
**Merkle Root:** `{merkle_root}`

**Coverage:**
- **Proposals:** {receipt['funding_axis']['proposals']} (€{receipt['funding_axis']['total_budget_eur']})
- **Partners:** {receipt['funding_axis']['partners']} organizations across {receipt['funding_axis']['countries']} countries
- **Work Packages:** {receipt['funding_axis']['work_packages']}+
- **Validation Pilots:** {receipt['funding_axis']['pilots']}+
- **Architecture Diagrams:** {receipt['funding_axis']['diagrams']} (including meta-visualization)

---

## 📁 File Manifest (Merkle Leaves)

"""

        # Add file table
        doc_content += "| # | File | Hash (SHA-256) | Lines | Bytes |\n"
        doc_content += "|---|------|----------------|-------|-------|\n"

        for idx, file_data in enumerate(self.files_data, 1):
            doc_content += f"| {idx:2d} | `{file_data['path']}` | `{file_data['hash'][:16]}...` | {file_data['lines']:,} | {file_data['size']:,} |\n"

        # Add Merkle tree structure
        doc_content += f"""
---

## 🌳 Merkle Tree Structure

**Tree Depth:** {len(tree_levels)} levels
**Leaf Nodes:** {len(tree_levels[0])}
**Root Hash:** `{merkle_root}`

### Level-by-Level Breakdown

"""

        for level_idx, level in enumerate(tree_levels):
            if level_idx == 0:
                doc_content += f"**Level 0 (Leaves):** {len(level)} file hashes\n"
            elif level_idx == len(tree_levels) - 1:
                doc_content += f"**Level {level_idx} (Root):** `{level[0]}`\n"
            else:
                doc_content += f"**Level {level_idx}:** {len(level)} intermediate nodes\n"

        # Add verification instructions
        doc_content += f"""
---

## 🔍 Verification Instructions

### Verify File Hash
```bash
# Verify any file hasn't been modified
sha256sum funding-roadmap/diagrams/treasury-nebula-map.mmd
# Compare output to hash in manifest above
```

### Reconstruct Merkle Root
```bash
# Run genesis receipt generator
cd ~/vaultmesh-core/funding-roadmap
python3 scripts/generate_genesis_receipt.py --dry-run

# Compare output Merkle root to this document
# If roots match, all files are intact
```

### Anchor to External Timestamping
```bash
# Request RFC-3161 timestamp (when TSA integration available)
openssl ts -query -data PROOF_CHAIN.md -sha256 -out roadmap.tsq
curl -X POST https://freetsa.org/tsr -H "Content-Type: application/timestamp-query" --data-binary @roadmap.tsq -o roadmap.tsr

# Anchor Merkle root to Ethereum (when available)
# Anchor Merkle root to Bitcoin (when available)
```

---

## 📜 Genesis Receipt JSON

**Location:** `.vaultmesh/receipts/genesis-roadmap-rubedo-{self.timestamp.strftime("%Y%m%d%H%M%S")}.json`

**Kind:** `funding.roadmap.genesis`
**Milestone:** Treasury Nebula Activation
**Phase:** Rubedo (Perfection)
**Seal:** II

**Key Fields:**
```json
{{
  "manifest": {{
    "merkle_root": "{merkle_root}"
  }},
  "funding_axis": {{
    "proposals": {receipt['funding_axis']['proposals']},
    "total_budget_eur": "{receipt['funding_axis']['total_budget_eur']}",
    "partners": "{receipt['funding_axis']['partners']}",
    "timeline": "{receipt['funding_axis']['timeline']}"
  }},
  "declaration": "{receipt['declaration']}"
}}
```

Full receipt available at path above.

---

## 🎯 What This Proof Chain Guarantees

1. **Integrity:** Any modification to any file will break the Merkle root
2. **Timestamp:** This exact state existed at {self.timestamp.isoformat()}
3. **Completeness:** All {len(self.files_data)} files are accounted for in the tree
4. **Reproducibility:** Anyone can verify by recomputing file hashes
5. **Non-repudiation:** Once anchored to TSA/blockchain, this state is permanent

---

## 🌌 Treasury Nebula — Civilization Ledger Declaration

> *"All Funding Organs Activated. Treasury Nebula Breathing."*

This proof chain marks the **Rubedo attainment** of the VaultMesh Funding Roadmap 2025-2027:

- €15.8M+ orchestrated across 8 EU Horizon Europe proposals
- 20+ consortium partners mapped across 10+ countries
- 4 comprehensive architecture diagrams (including Treasury Nebula meta-visualization)
- Complete partner onboarding, LOI templates, and consortium tracking infrastructure
- Production-ready coordination protocol for civilization-scale funding federation

**Next Horizon:** PQC Integration submission (Dec 15, 2025) — 39 days

---

## 🜂 Alchemical Signature

**Phase:** Rubedo (Reddening) — Perfection Attained
**Coordinator:** VaultMesh Technologies B.V.
**Guardian:** Karol Stefanski (guardian@vaultmesh.org)
**Forged By:** Genesis Receipt Generator v1.0

**Merkle Root:** `{merkle_root}`
**Timestamp:** {self.timestamp.isoformat()}
**Receipt:** `genesis-roadmap-rubedo-{self.timestamp.strftime("%Y%m%d%H%M%S")}.json`

---

**Document Control:**
- Version: 1.0-GENESIS
- Classification: Cryptographic Proof (Public Chain)
- Owner: VaultMesh Technologies B.V.
- Purpose: Permanent ledger record of Rubedo Seal II
"""

        if dry_run:
            print(f"\n🏃 DRY RUN: Would save proof chain to {doc_path}")
            print(doc_content[:500] + "\n...")
        else:
            doc_path.write_text(doc_content)
            print(f"\n✅ Proof chain document saved: {doc_path}")

        return doc_path

def main():
    """Main execution."""
    print("=" * 70)
    print("🜂 VaultMesh Funding Roadmap — Genesis Receipt Generator")
    print("   Rubedo Seal II: Treasury Nebula Activation")
    print("=" * 70)

    # Check for dry-run flag
    dry_run = '--dry-run' in sys.argv
    if dry_run:
        print("\n🏃 DRY RUN MODE (no files will be written)\n")

    # Determine roadmap directory
    script_dir = Path(__file__).parent
    roadmap_dir = script_dir.parent

    print(f"\n📂 Roadmap directory: {roadmap_dir}")

    # Initialize generator
    genesis = FundingRoadmapGenesis(roadmap_dir)

    # Scan files
    files_data = genesis.scan_files()

    if not files_data:
        print("\n❌ No files found in roadmap directory")
        return 1

    # Build Merkle tree
    merkle_root, tree_levels = genesis.build_merkle_tree()

    # Generate genesis receipt
    receipt = genesis.generate_genesis_receipt(merkle_root)

    # Save receipt
    receipt_path = genesis.save_receipt(receipt, dry_run=dry_run)

    # Generate proof chain document
    proof_path = genesis.generate_proof_chain_document(
        receipt, merkle_root, tree_levels, dry_run=dry_run
    )

    # Summary
    print("\n" + "=" * 70)
    print("✨ GENESIS COMPLETE")
    print("=" * 70)
    print(f"📊 Files processed: {len(files_data)}")
    print(f"📏 Total lines: {receipt['manifest']['total_lines']:,}")
    print(f"💾 Total bytes: {receipt['manifest']['total_bytes']:,}")
    print(f"🌳 Merkle root: {merkle_root[:32]}...")
    print(f"🜂 Genesis receipt: {receipt_path.name}")
    print(f"📜 Proof chain: {proof_path.name}")
    print(f"⏰ Timestamp: {genesis.timestamp.isoformat()}")

    if not dry_run:
        print(f"\n🎯 Next steps:")
        print(f"   1. Review: cat {proof_path}")
        print(f"   2. Verify: sha256sum {roadmap_dir}/**/*.md")
        print(f"   3. Archive: cp {receipt_path} ~/backups/")
        print(f"   4. Anchor: [TSA/Ethereum/Bitcoin when available]")

    print("\n🌌 Treasury Nebula: BREATHING")
    print("=" * 70)

    return 0

if __name__ == '__main__':
    sys.exit(main())