┌─────────────────────────────────────────────────────────────────────────────┐
│                    WHY GOVERNANCE MATTERS                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    DECENTRALISED DECISION-MAKING                    │   │
│  │  Enables community-driven protocol evolution.                      │   │
│  │  Reduces reliance on centralised teams.                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ALIGNMENT OF INCENTIVES                           │   │
│  │  Aligns interests of token holders with protocol success.          │   │
│  │  Encourages long-term participation.                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    RESOURCE ALLOCATION                               │   │
│  │  Efficient allocation of protocol resources.                       │   │
│  │  Treasury management and funding of initiatives.                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    ADAPTABILITY                                     │   │
│  │  Enables protocol upgrades and improvements.                       │   │
│  │  Adaptation to changing market conditions.                         │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    LEGITIMACY                                        │   │
│  │  Community buy-in for major decisions.                              │   │
│  │  Transparency and accountability.                                  │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    GOVERNANCE MODEL COMPARISON                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Model         │ Decentralisation │ Efficiency │ Whale Resistance          │
│  ─────────────┼─────────────────┼────────────┼───────────────────────────│
│  Token-Based   │ High            │ High      │ Low                        │
│  Delegated     │ Medium          │ Very High │ Medium                     │
│  Quadratic     │ High            │ Medium    │ High                       │
│  Conviction    │ High            │ Low       │ High                       │
│  Liquid        │ High            │ High      │ Medium                     │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    INCENTIVE TYPES                                          │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    FINANCIAL INCENTIVES                              │   │
│  │  Direct economic rewards for participation.                          │   │
│  │  • Staking rewards                                                   │   │
│  │  • Yield farming                                                     │   │
│  │  • Liquidity provision fees                                          │   │
│  │  • Protocol revenue sharing                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    GOVERNANCE INCENTIVES                             │   │
│  │  Influence over protocol decisions.                                 │   │
│  │  • Voting rights                                                     │   │
│  │  • Proposal submission                                                │   │
│  │  • Treasury allocation                                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    REPUTATIONAL INCENTIVES                          │   │
│  │  Social and professional recognition.                              │   │
│  │  • Community recognition                                            │   │
│  │  • Governance participation credit                                  │   │
│  │  • Professional reputation                                          │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    PENALTIES                                         │   │
│  │  Disincentives for malicious behaviour.                             │   │
│  │  • Slashing                                                          │   │
│  │  • Reputation damage                                                 │   │
│  │  • Loss of voting rights                                             │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 6, LESSON 6: TOKEN GOVERNANCE AND INCENTIVES
# ===================================================================

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

print("="*70)
print("TOKEN GOVERNANCE AND INCENTIVES")
print("="*70)

# ----------------------------------------------------------------
# PART A: GOVERNANCE VOTING SIMULATION
# ----------------------------------------------------------------

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

class GovernanceSystem:
    """
    Simulated token governance system.
    """
    def __init__(self, name: str):
        self.name = name
        self.tokens: Dict[str, float] = {}
        self.delegations: Dict[str, str] = {}
        self.proposals: List[Dict] = []
        self.proposal_counter = 0
        self.total_supply = 0
    
    def mint_tokens(self, address: str, amount: float):
        """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 to another address."""
        if delegator not in self.tokens:
            return False
        self.delegations[delegator] = delegate
        return True
    
    def get_voting_power(self, address: str) -> float:
        """Get total voting power (direct + delegated)."""
        power = self.tokens.get(address, 0)
        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 governance proposal."""
        if self.get_voting_power(proposer) < self.total_supply * 0.01:  # 1% threshold
            return {'error': 'Insufficient voting power'}
        
        self.proposal_counter += 1
        proposal = {
            'id': self.proposal_counter,
            'proposer': proposer,
            'description': description,
            'actions': actions,
            'for_votes': 0,
            'against_votes': 0,
            'abstain_votes': 0,
            'quorum': self.total_supply * 0.04,  # 4% quorum
            'status': 'active',
            'created_at': len(self.proposals)
        }
        self.proposals.append(proposal)
        print(f"Proposal #{proposal['id']}: {description[:50]}...")
        return proposal
    
    def vote(self, proposal_id: int, voter: str, option: str) -> 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 proposal['status'] != 'active':
            return False
        
        voting_power = self.get_voting_power(voter)
        if voting_power <= 0:
            return False
        
        if option == 'for':
            proposal['for_votes'] += voting_power
        elif option == 'against':
            proposal['against_votes'] += voting_power
        elif option == 'abstain':
            proposal['abstain_votes'] += voting_power
        else:
            return False
        
        print(f"{voter} voted {option} with {voting_power:.0f} power")
        return True
    
    def execute_proposal(self, proposal_id: int) -> Dict:
        """Execute a proposal if passed."""
        proposal = next((p for p in self.proposals if p['id'] == proposal_id), None)
        if not proposal:
            return {'error': 'Proposal not found'}
        
        total_votes = proposal['for_votes'] + proposal['against_votes']
        quorum_met = total_votes >= proposal['quorum']
        passed = proposal['for_votes'] > proposal['against_votes'] and quorum_met
        
        if passed:
            proposal['status'] = 'executed'
            return {'success': True, 'proposal': proposal}
        else:
            proposal['status'] = 'failed'
            return {'success': False, 'reason': 'Failed to pass'}
    
    def get_metrics(self) -> Dict:
        return {
            'name': self.name,
            'total_supply': self.total_supply,
            'token_holders': len(self.tokens),
            'proposals': len(self.proposals),
            'executed': len([p for p in self.proposals if p['status'] == 'executed']),
            'active_proposals': len([p for p in self.proposals if p['status'] == 'active'])
        }

# Create governance system
gov = GovernanceSystem("TokenDAO")

print("Governance Simulation:")
print("Distributing governance tokens...")

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

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

print(f"Total Supply: {gov.total_supply}")
print(f"Token Holders: {len(gov.tokens)}")

# Delegations
gov.delegate('David', 'Alice')
gov.delegate('Eve', 'Alice')

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

# Create proposals
print("\nProposals:")
gov.create_proposal('Alice', 'Increase staking rewards from 5% to 8%', 
                    ['Update staking contract', 'Adjust reward rate'])
gov.create_proposal('Charlie', 'Allocate 100,000 tokens for developer grants',
                    ['Create grants program', 'Distribute funds'])
gov.create_proposal('Alice', 'Add new lending pool feature',
                    ['Deploy lending contract', 'Add liquidity'])

# Voting simulation
print("\nVoting...")
votes = [
    (1, 'Alice', 'for'),
    (1, 'Bob', 'for'),
    (1, 'Charlie', 'against'),
    (1, 'David', 'for'),
    (2, 'Alice', 'for'),
    (2, 'Charlie', 'for'),
    (2, 'Eve', 'against'),
    (3, 'Alice', 'for'),
    (3, 'Bob', 'against')
]

for proposal_id, voter, option in votes:
    gov.vote(proposal_id, voter, option)

# Execute proposals
print("\nExecution:")
for i in range(1, 4):
    result = gov.execute_proposal(i)
    if result['success']:
        print(f"  Proposal #{i}: EXECUTED")
    else:
        print(f"  Proposal #{i}: FAILED")

# Metrics
metrics = gov.get_metrics()
print(f"\nGovernance 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']}")

# ----------------------------------------------------------------
# PART B: INCENTIVE STRUCTURE COMPARISON
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Incentive Structure Comparison")
print("-"*60)

incentive_data = {
    'Incentive Type': ['Staking Rewards', 'Liquidity Mining', 'Yield Farming', 'Governance', 'Referral Rewards'],
    'Target': ['Validators', 'LPs', 'Users', 'All Holders', 'New Users'],
    'Alignment': ['High', 'High', 'Medium', 'High', 'Medium'],
    'Sustainability': ['High', 'Medium', 'Low', 'High', 'Low'],
    'Cost': ['Low', 'High', 'High', 'Low', 'Medium']
}

incentive_df = pd.DataFrame(incentive_data)
print(incentive_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: TREASURY MANAGEMENT MODELS
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Treasury Management Models")
print("-"*60)

treasury_data = {
    'Model': ['Community Controlled', 'Multi-sig', 'Foundation', 'Automated'],
    'Control': ['Token holders', 'Signers', 'Foundation team', 'Smart contract'],
    'Transparency': ['High', 'Medium', 'Medium', 'High'],
    'Flexibility': ['Medium', 'High', 'High', 'Low'],
    'Decentralisation': ['High', 'Medium', 'Low', 'High'],
    'Examples': ['MakerDAO', 'Uniswap', 'Ethereum Foundation', 'Protocol-owned liquidity']
}

treasury_df = pd.DataFrame(treasury_data)
print(treasury_df.to_string(index=False))

# ----------------------------------------------------------------
# PART D: GOVERNANCE TOKEN FEATURES
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Governance Token Features")
print("-"*60)

governance_features = {
    'Feature': ['Voting Power', 'Proposal Threshold', 'Quorum', 'Voting Period', 'Timelock'],
    'Description': [
        'Weighted by token holdings',
        'Minimum tokens to propose',
        'Minimum participation required',
        'Duration of voting window',
        'Delay before execution'
    ],
    'Typical Value': [
        '1 token = 1 vote',
        '0.5-2% of supply',
        '4-10% of supply',
        '3-7 days',
        '12-48 hours'
    ]
}

features_df = pd.DataFrame(governance_features)
print(features_df.to_string(index=False))

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

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

print("""
Token Governance and Incentives – Key Takeaways:

1. Token governance enables community-driven protocol evolution and resource allocation.
2. Governance models: token-based, delegated, quadratic, conviction, liquid democracy.
3. On-chain governance: automatic execution; off-chain: manual execution.
4. Incentives: financial (rewards), governance (influence), reputation, penalties.
5. Treasury management: funding, staking, investments, burns, reserves.
6. Key governance parameters: proposal threshold, quorum, voting period, timelock.

Recommendations:
  - Design governance with appropriate thresholds and quorum.
  - Align incentives across all stakeholder groups.
  - Implement transparent treasury management.
  - Monitor governance participation and delegate effectively.
  - Use time-locks for critical functions.
  - Balance decentralisation with efficiency.
  - Provide clear documentation for governance processes.
""")