┌─────────────────────────────────────────────────────────────────────────────┐
│                    DAO CHARACTERISTICS                                      │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DECENTRALISED                                     │   │
│  │  No central authority or single point of failure.                   │   │
│  │  Power distributed among token holders.                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    AUTONOMOUS                                        │   │
│  │  Operates through smart contracts without human intervention.       │   │
│  │  Rules are encoded and self-executing.                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TRANSPARENT                                       │   │
│  │  All transactions, proposals, and votes are on-chain.              │   │
│  │  Full visibility into operations.                                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TOKEN-BASED GOVERNANCE                            │   │
│  │  Governance token holders vote on proposals.                        │   │
│  │  Voting power proportional to token holdings.                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    GLOBAL                                            │   │
│  │  Open to anyone with internet access and tokens.                    │   │
│  │  No geographic or jurisdictional borders.                           │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    DAO PROPOSAL LIFECYCLE                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  1. DISCUSSION                                                              │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Idea discussed in forums, Discord, or governance platforms       │   │
│  │ • Community feedback and refinement                                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  2. PROPOSAL SUBMISSION                                                    │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Proposal submitted on-chain (or via Snapshot)                   │   │
│  │ • Includes description, rationale, and execution details          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  3. VOTING PERIOD                                                          │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Token holders vote (typically 3-7 days)                         │   │
│  │ • Quorum requirements (minimum participation)                      │   │
│  │ • Threshold requirements (percentage approval)                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  4. EXECUTION                                                              │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • If passed, proposal is executed automatically                   │   │
│  │ • Smart contract enacts changes                                    │   │
│  │ • Timelock may delay execution                                     │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  5. IMPLEMENTATION                                                         │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Changes implemented                                                  │   │
│  │ • Monitoring and follow-up                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    DAO LEGAL STATUS BY JURISDICTION                         │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  UNITED STATES                                                              │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • No federal DAO legislation yet                                   │   │
│  │ • Wyoming: DAOs recognised as LLCs                                 │   │
│  │ • Vermont: Blockchain-based LLCs                                     │   │
│  │ • Some states considering legislation                              │   │
│  │ • Most DAOs operate as unincorporated associations               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  EUROPEAN UNION                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Estonia: e-residency and digital governance                      │   │
│  │ • Lithuania: innovation-friendly regulation                       │   │
│  │ • No specific DAO legislation yet                                 │   │
│  │ • General company law may apply                                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  SWITZERLAND                                                                │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Association structure available                                   │   │
│  │ • Foundation structure possible                                     │   │
│  │ • DAOs can register as associations                                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  SINGAPORE                                                                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Variable Capital Company (VCC)                                  │   │
│  │ • Limited Liability Partnerships (LLP)                              │   │
│  │ • No specific DAO legislation                                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  MARSHALL ISLANDS                                                           │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • DAO legislation passed (2022)                                      │   │
│  │ • DAOs can register as LLCs                                          │   │
│  │ • Legal recognition                                                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 5, LESSON 7: DAO GOVERNANCE AND LEGAL STATUS
# ===================================================================

import hashlib
import time
import random
from typing import Dict, List, Optional
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("DAO GOVERNANCE AND LEGAL STATUS")
print("="*70)

# ----------------------------------------------------------------
# PART A: DAO GOVERNANCE SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: DAO Governance Simulation")
print("-"*60)

class DAOGovernance:
    """
    Simulated DAO governance system.
    """
    def __init__(self, name: str):
        self.name = name
        self.tokens = {}  # address -> token balance
        self.proposals = []
        self.proposal_counter = 0
        self.delegations = {}  # address -> delegate address
        self.total_supply = 0
    
    def mint_tokens(self, address: str, amount: int):
        """Mint governance tokens."""
        self.tokens[address] = self.tokens.get(address, 0) + amount
        self.total_supply += amount
    
    def delegate(self, delegator: str, delegate: str) -> bool:
        """Delegate voting power."""
        if delegator not in self.tokens:
            return False
        self.delegations[delegator] = delegate
        return True
    
    def get_voting_power(self, address: str) -> int:
        """Get voting power (direct + delegated)."""
        power = self.tokens.get(address, 0)
        # Add delegated power from others
        for delegator, delegate in self.delegations.items():
            if delegate == address:
                power += self.tokens.get(delegator, 0)
        return power
    
    def create_proposal(self, proposer: str, description: str, actions: List[str]) -> Dict:
        """Create a new proposal."""
        if self.get_voting_power(proposer) == 0:
            return {'error': 'No voting power'}
        
        self.proposal_counter += 1
        proposal = {
            'id': self.proposal_counter,
            'proposer': proposer,
            'description': description,
            'actions': actions,
            'status': 'pending',
            'votes_for': 0,
            'votes_against': 0,
            'quorum': 100,  # minimum votes
            'voting_period': 7,  # days
            'created_at': time.time(),
            'end_at': time.time() + 7 * 24 * 60 * 60
        }
        self.proposals.append(proposal)
        print(f"Proposal #{proposal['id']} created: {description[:50]}...")
        return proposal
    
    def vote(self, proposal_id: int, voter: str, support: bool) -> bool:
        """Cast a vote on a proposal."""
        proposal = next((p for p in self.proposals if p['id'] == proposal_id), None)
        if not proposal:
            return False
        if time.time() > proposal['end_at']:
            return False
        
        voting_power = self.get_voting_power(voter)
        if voting_power <= 0:
            return False
        
        if support:
            proposal['votes_for'] += voting_power
        else:
            proposal['votes_against'] += voting_power
        
        print(f"{voter} voted {'FOR' if support else 'AGAINST'} with {voting_power} power")
        return True
    
    def execute_proposal(self, proposal_id: int) -> Dict:
        """Execute a passed proposal."""
        proposal = next((p for p in self.proposals if p['id'] == proposal_id), None)
        if not proposal:
            return {'error': 'Proposal not found'}
        
        if time.time() < proposal['end_at']:
            return {'error': 'Voting period not ended'}
        
        total_votes = proposal['votes_for'] + proposal['votes_against']
        quorum_met = total_votes >= proposal['quorum']
        passed = proposal['votes_for'] > proposal['votes_against'] and quorum_met
        
        if passed:
            proposal['status'] = 'executed'
            print(f"Proposal #{proposal_id} EXECUTED")
            return {'success': True, 'proposal': proposal}
        else:
            proposal['status'] = 'failed'
            print(f"Proposal #{proposal_id} FAILED")
            return {'success': False, 'reason': 'Not enough votes or quorum'}
    
    def get_governance_metrics(self) -> Dict:
        """Get governance metrics."""
        total_power = sum(self.tokens.values())
        proposals = len(self.proposals)
        executed = len([p for p in self.proposals if p['status'] == 'executed'])
        participation = 0
        for p in self.proposals:
            total_power = sum(self.tokens.values())
            votes = p['votes_for'] + p['votes_against']
            participation += votes / total_power if total_power > 0 else 0
        
        avg_participation = participation / proposals if proposals > 0 else 0
        
        return {
            'name': self.name,
            'total_supply': total_power,
            'token_holders': len(self.tokens),
            'proposals': proposals,
            'executed': executed,
            'avg_participation': avg_participation,
            'delegations': len(self.delegations)
        }

# Create DAO
dao = DAOGovernance("Digital Finance DAO")

print("Creating DAO...")

# Mint tokens to members
members = ['Alice', 'Bob', 'Charlie', 'David', 'Eve']
allocations = [1000, 800, 600, 400, 200]

for member, allocation in zip(members, allocations):
    dao.mint_tokens(member, allocation)

print(f"Total Supply: {dao.total_supply}")
print(f"Members: {', '.join(members)}")

# Delegate voting power
dao.delegate('David', 'Alice')
dao.delegate('Eve', 'Alice')

print("\nVoting Power:")
for member in members:
    print(f"  {member}: {dao.get_voting_power(member)}")

# Create proposal
proposal = dao.create_proposal(
    'Alice',
    'Deploy new lending protocol module',
    ['Deploy LendingV2 contract', 'Add liquidity', 'Update interest rates']
)

# Simulate voting
print("\nVoting...")
votes = [
    ('Alice', True),
    ('Bob', True),
    ('Charlie', False),
    ('David', True),  # delegated to Alice
    ('Eve', True)     # delegated to Alice
]

for voter, support in votes:
    dao.vote(proposal['id'], voter, support)

# Execute proposal
result = dao.execute_proposal(proposal['id'])
print(f"\nExecution Result: {result.get('success', False)}")

# Metrics
metrics = dao.get_governance_metrics()
print(f"\nDAO Metrics:")
print(f"  Total Supply: {metrics['total_supply']}")
print(f"  Token Holders: {metrics['token_holders']}")
print(f"  Proposals: {metrics['proposals']}")
print(f"  Executed: {metrics['executed']}")
print(f"  Avg Participation: {metrics['avg_participation']:.1%}")

# ----------------------------------------------------------------
# PART B: DAO LEGAL STRUCTURES
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: DAO Legal Structures")
print("-"*60)

legal_structures = {
    'Jurisdiction': ['Wyoming (US)', 'Vermont (US)', 'Switzerland', 'Singapore', 'Marshall Islands', 'UK'],
    'Entity Type': ['DAO LLC', 'BB-LLC', 'Foundation', 'VCC/LLP', 'DAO LLC', 'Unincorporated'],
    'Liability Protection': ['Limited', 'Limited', 'Limited', 'Limited', 'Limited', 'Unlimited'],
    'Recognition Level': ['High', 'Medium', 'High', 'Medium', 'High', 'Low'],
    'Tax Treatment': ['Complex', 'Complex', 'Favourable', 'Favourable', 'Complex', 'Unclear'],
    'Cost': ['Medium', 'Medium', 'High', 'Medium', 'Low', 'Very Low']
}

struct_df = pd.DataFrame(legal_structures)
print(struct_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: VOTING MECHANISMS COMPARISON
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Voting Mechanisms Comparison")
print("-"*60)

voting_data = {
    'Mechanism': ['Token-based', 'Delegated', 'Quadratic', 'Conviction', 'Liquid Democracy'],
    'Decentralisation Score': [8, 5, 7, 6, 6],
    'Efficiency Score': [9, 9, 5, 4, 6],
    'Security Score': [8, 7, 8, 8, 7],
    'Complexity': ['Low', 'Medium', 'High', 'Medium', 'Very High'],
    'Whale Resistance': ['Low', 'Medium', 'High', 'Medium', 'Medium']
}

voting_df = pd.DataFrame(voting_data)
print(voting_df.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(12, 6))
x = np.arange(len(voting_data['Mechanism']))
width = 0.25

ax.bar(x - width, voting_data['Decentralisation Score'], width, label='Decentralisation', color='blue', alpha=0.7)
ax.bar(x, voting_data['Efficiency Score'], width, label='Efficiency', color='green', alpha=0.7)
ax.bar(x + width, voting_data['Security Score'], width, label='Security', color='orange', alpha=0.7)

ax.set_xlabel('Voting Mechanism')
ax.set_ylabel('Score (1-10)')
ax.set_title('DAO Voting Mechanisms Comparison')
ax.set_xticks(x)
ax.set_xticklabels(voting_data['Mechanism'], rotation=45, ha='right')
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('dao_voting.png', dpi=300, bbox_inches='tight')
plt.show()
print("DAO voting chart saved as 'dao_voting.png'")

# ----------------------------------------------------------------
# PART D: DAO REGULATORY CHECKLIST
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: DAO Regulatory Checklist")
print("-"*60)

regulatory_checklist = {
    "Legal Structure": [
        "Determine legal entity type",
        "Register in appropriate jurisdiction",
        "Draft operating agreement",
        "Define governance rules"
    ],
    "Compliance": [
        "Assess securities law exposure",
        "Implement KYC/AML (if required)",
        "Comply with tax obligations",
        "Monitor regulatory developments"
    ],
    "Governance": [
        "Define proposal process",
        "Set voting parameters",
        "Establish quorum and thresholds",
        "Implement dispute resolution"
    ],
    "Risk Management": [
        "Obtain appropriate insurance",
        "Implement circuit breakers",
        "Establish incident response",
        "Regular security audits"
    ]
}

for category, items in regulatory_checklist.items():
    print(f"\n{category.upper()}:")
    for item in items:
        print(f"  □ {item}")

# ----------------------------------------------------------------
# PART E: SUMMARY AND RECOMMENDATIONS
# -----------------------------------------------------------------

print("\n" + "="*70)
print("PART E: Summary and Recommendations")
print("="*70)

print("""
DAO Governance and Legal Status – Key Takeaways:

1. DAOs are decentralised, autonomous, transparent, and global.
2. Governance models: token-based, delegated, quadratic, conviction, liquid democracy.
3. Proposal lifecycle: discussion → submission → voting → execution → implementation.
4. Legal status varies: Wyoming (DAO LLC), Switzerland (foundation), Singapore (VCC/LLP).
5. Liability: members may face personal liability without proper legal structure.
6. Regulatory issues: tax, securities, AML, legal personality, contractual capacity.
7. Compliance: legal structure, securities law, tax, KYC/AML, governance.

Recommendations:
  - Choose appropriate legal structure for your jurisdiction.
  - Register as a legal entity for liability protection.
  - Draft clear governance rules and operating agreement.
  - Consider tax implications early.
  - Implement security measures and insurance.
  - Stay updated on evolving legislation.
  - Engage legal counsel specialised in DAOs.
""")