┌─────────────────────────────────────────────────────────────────────────────┐
│                    SMART CONTRACT LEGAL FRAMEWORK                           │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  TRADITIONAL CONTRACT                                                      │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Written in natural language                                       │   │
│  │ • Interpreted by courts                                             │   │
│  │ • Enforced through legal system                                     │   │
│  │ • Flexible and adaptable                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  SMART CONTRACT                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Written in code (Solidity, Rust, etc.)                           │   │
│  │ • Interpreted by computers (EVM, etc.)                             │   │
│  │ • Enforced through blockchain consensus                            │   │
│  │ • Rigid and immutable                                              │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  HYBRID APPROACH                                                           │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Natural language contract + code execution                       │   │
│  │ • Legal terms referenced in code                                   │   │
│  │ • Code executes as agreed                                           │   │
│  │ • Courts interpret disputes                                         │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    CODE AS LAW VS LAW AS CODE                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  CODE AS LAW                                                               │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • "Code is law" - blockchain code is the ultimate authority         │   │
│  │ • Code executes without external interference                       │   │
│  │ • Pros: Predictable, efficient, immutable                           │   │
│  │ • Cons: Bugs become law, no human discretion                        │   │
│  │ • Examples: DAO governance, autonomous protocols                   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  LAW AS CODE                                                               │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Laws encoded into smart contracts                                 │   │
│  │ • Code reflects legal rules                                          │   │
│  │ • Pros: Compliance by design, automation                            │   │
│  │ • Cons: Rigid, requires legal expertise in coding                  │   │
│  │ • Examples: Regulated tokens, compliance contracts                 │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  HYBRID (HUMAN OVERSIGHT)                                                  │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Code executes automatically                                       │   │
│  │ • Human intervention for exceptions                                │   │
│  │ • Arbitration mechanisms                                            │   │
│  │ • Best of both worlds                                               │   │
│  │ • Examples: Most real-world applications                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 5, LESSON 6: SMART CONTRACT LEGAL FRAMEWORKS
# ===================================================================

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

print("="*70)
print("SMART CONTRACT LEGAL FRAMEWORKS")
print("="*70)

# ----------------------------------------------------------------
# PART A: SMART CONTRACT LEGAL ANALYSIS FRAMEWORK
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Smart Contract Legal Analysis Framework")
print("-"*60)

class SmartContractLegalAnalyzer:
    """
    Simulated legal analysis framework for smart contracts.
    """
    def __init__(self, contract_name: str):
        self.contract_name = contract_name
        self.assessments = {}
        self.findings = []
    
    def assess_element(self, element: str, status: str, notes: str = "") -> None:
        """Assess a legal element of the contract."""
        self.assessments[element] = {
            'status': status,  # 'compliant', 'risk', 'non-compliant'
            'notes': notes
        }
    
    def assess_enforceability(self) -> Dict:
        """Assess overall enforceability."""
        criteria = {
            'offer': {'status': 'Present', 'weight': 0.15},
            'acceptance': {'status': 'Present', 'weight': 0.15},
            'consideration': {'status': 'Present', 'weight': 0.15},
            'intention': {'status': 'Unclear', 'weight': 0.15},
            'certainty': {'status': 'High', 'weight': 0.20},
            'capacity': {'status': 'N/A', 'weight': 0.10},
            'legality': {'status': 'Compliant', 'weight': 0.10}
        }
        
        score = 0
        for criterion, details in criteria.items():
            status_weight = {'Present': 1.0, 'High': 1.0, 'Medium': 0.5, 
                            'Unclear': 0.5, 'Low': 0.0, 'N/A': 0.0, 'Compliant': 1.0}
            score += details['weight'] * status_weight.get(details['status'], 0.5)
        
        enforceability = {
            'Excellent' if score > 0.8 else 'Good' if score > 0.6 else 'Risky' if score > 0.4 else 'Poor'
        }
        
        return {
            'score': score,
            'enforceability': enforceability,
            'criteria': criteria
        }
    
    def identify_risks(self) -> List[Dict]:
        """Identify legal risks."""
        risks = []
        
        if 'intention' in self.assessments and self.assessments['intention']['status'] == 'Unclear':
            risks.append({
                'risk': 'Intention to create legal relations is unclear',
                'severity': 'Medium',
                'mitigation': 'Include clear legal language and signatures'
            })
        
        if 'capacity' in self.assessments and self.assessments['capacity']['status'] == 'N/A':
            risks.append({
                'risk': 'Smart contract lacks legal capacity',
                'severity': 'High',
                'mitigation': 'Legal entity (SPV) as contracting party'
            })
        
        return risks
    
    def generate_report(self) -> Dict:
        """Generate legal assessment report."""
        return {
            'contract_name': self.contract_name,
            'assessments': self.assessments,
            'enforceability': self.assess_enforceability(),
            'risks': self.identify_risks(),
            'recommendations': self._generate_recommendations()
        }
    
    def _generate_recommendations(self) -> List[str]:
        """Generate recommendations for legal compliance."""
        recommendations = []
        
        for element, assessment in self.assessments.items():
            if assessment['status'] == 'risk':
                recommendations.append(f"Address risk in {element}: {assessment['notes']}")
            elif assessment['status'] == 'non-compliant':
                recommendations.append(f"Fix non-compliance in {element}: {assessment['notes']}")
        
        if not recommendations:
            recommendations.append("Contract appears legally sound.")
        
        recommendations.append("Consider legal review by qualified attorney.")
        recommendations.append("Document all legal assumptions.")
        
        return recommendations

# Analyse sample contract
analyzer = SmartContractLegalAnalyzer("TokenVestingContract")

print("Smart Contract Legal Analysis:")

# Assess legal elements
analyzer.assess_element('offer', 'Present', 'Code deployment with specific terms')
analyzer.assess_element('acceptance', 'Present', 'User interaction constitutes acceptance')
analyzer.assess_element('consideration', 'Present', 'Tokens exchanged')
analyzer.assess_element('intention', 'Unclear', 'Code has no explicit legal intent')
analyzer.assess_element('certainty', 'High', 'Code is precise and deterministic')
analyzer.assess_element('capacity', 'N/A', 'Code cannot have legal capacity')
analyzer.assess_element('legality', 'Compliant', 'Token structure appears compliant')

# Generate report
report = analyzer.generate_report()

print(f"\nContract: {report['contract_name']}")
print("\nAssessments:")
for element, details in report['assessments'].items():
    print(f"  {element}: {details['status']} - {details['notes']}")

print(f"\nEnforceability Score: {report['enforceability']['score']:.1%}")
print(f"  Rating: {list(report['enforceability']['enforceability'].keys())[0]}")

print("\nRisks:")
for risk in report['risks']:
    print(f"  [{risk['severity']}] {risk['risk']}")
    print(f"    Mitigation: {risk['mitigation']}")

print("\nRecommendations:")
for rec in report['recommendations']:
    print(f"  • {rec}")

# ----------------------------------------------------------------
# PART B: JURISDICTIONAL COMPARISON
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Smart Contract Legal Recognition by Jurisdiction")
print("-"*60)

legal_recognition = {
    'Jurisdiction': ['US (Arizona)', 'US (Tennessee)', 'UK', 'EU', 'Singapore', 'Switzerland', 'Estonia'],
    'Recognition Level': ['High', 'High', 'Medium', 'Medium', 'High', 'High', 'High'],
    'Specific Legislation': ['Yes (HB 2417)', 'Yes (SB 1662)', 'No (common law)', 'Partial (eIDAS)', 
                            'Yes (ETA)', 'Yes (general)', 'Yes (X-Road)'],
    'Enforceability': ['High', 'High', 'Medium', 'Medium', 'High', 'High', 'High'],
    'Court Cases': ['Few', 'Few', 'None', 'None', 'None', 'Few', 'None']
}

legal_df = pd.DataFrame(legal_recognition)
print(legal_df.to_string(index=False))

# ----------------------------------------------------------------
# PART C: DISPUTE RESOLUTION MECHANISMS
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Smart Contract Dispute Resolution")
print("-"*60)

dispute_mechanisms = {
    "On-Chain Arbitration": {
        "Description": "Decentralised arbitration using token holders or selected arbitrators.",
        "Examples": ["Kleros", "Aragon Court"],
        "Advantages": ["Decentralised", "Fast", "Transparent"],
        "Disadvantages": ["Novel", "Uncertain legal status"]
    },
    "Off-Chain Arbitration": {
        "Description": "Traditional arbitration with legal enforceability.",
        "Examples": ["ICC Arbitration", "AAA"],
        "Advantages": ["Legally binding", "Predictable", "Expert arbitrators"],
        "Disadvantages": ["Costly", "Slow", "Centralised"]
    },
    "Smart Contract Escrow": {
        "Description": "Funds held in escrow, released based on conditions.",
        "Examples": ["Multi-sig", "Conditional payments"],
        "Advantages": ["Automated", "Trustless"],
        "Disadvantages": ["Rigid", "No discretion"]
    },
    "DAO Governance": {
        "Description": "Community voting on dispute resolution.",
        "Examples": ["DAO proposals", "Governance votes"],
        "Advantages": ["Democratic", "Transparent"],
        "Disadvantages": ["Slow", "Subject to manipulation"]
    }
}

for mechanism, details in dispute_mechanisms.items():
    print(f"\n{mechanism.upper()}:")
    print(f"  Description: {details['Description']}")
    print(f"  Examples: {', '.join(details['Examples'])}")
    print(f"  Advantages: {', '.join(details['Advantages'])}")
    print(f"  Disadvantages: {', '.join(details['Disadvantages'])}")

# ----------------------------------------------------------------
# PART D: BEST PRACTICES FOR LEGALLY COMPLIANT SMART CONTRACTS
# -----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Best Practices for Legally Compliant Smart Contracts")
print("-"*60)

best_practices = {
    "Contract Design": [
        "Include explicit terms in natural language",
        "Reference governing law and jurisdiction",
        "Define dispute resolution mechanism",
        "Include termination and amendment clauses"
    ],
    "Code Quality": [
        "Use battle-tested libraries",
        "Conduct multiple audits",
        "Maintain comprehensive documentation",
        "Implement upgradeability (with safeguards)"
    ],
    "Risk Management": [
        "Include circuit breakers",
        "Implement multi-signature controls",
        "Use time-locks for critical functions",
        "Maintain insurance where possible"
    ],
    "Compliance": [
        "Ensure AML/CFT compliance",
        "Consider KYC requirements",
        "Comply with securities laws",
        "Monitor regulatory developments"
    ],
    "User Protection": [
        "Clear disclosures of risks",
        "Transparent terms and conditions",
        "User education materials",
        "Support and complaint channels"
    ]
}

for category, items in best_practices.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("""
Smart Contract Legal Frameworks – Key Takeaways:

1. Smart contracts are legally recognised in several jurisdictions (US states, EU, Singapore, Switzerland).
2. Hybrid contracts combine natural language terms with code execution.
3. Enforceability depends on contract law elements (offer, acceptance, consideration, intention, certainty, capacity).
4. Challenges: interpretation, mistakes, illegality, capacity, jurisdiction, immutability.
5. Legal safeguards: circuit breakers, upgradeability, multi-signature, time-locks, escrow.
6. "Code as law" vs "Law as code" debate: pure code vs encoded legal rules.
7. Liability: developers, deployers, protocols, users, oracles, auditors.

Recommendations:
  - Include clear legal language alongside code.
  - Specify governing law and jurisdiction.
  - Implement dispute resolution mechanisms.
  - Conduct legal review alongside technical audits.
  - Consider hybrid approaches for complex contracts.
  - Document all assumptions and intended outcomes.
  - Stay updated on evolving case law and legislation.
""")