┌─────────────────────────────────────────────────────────────────────────────┐
│                    BLOCKCHAIN IN REAL ESTATE                                │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TOKENISATION                                      │   │
│  │  Property divided into tradable digital tokens.                     │   │
│  │  • Fractional ownership                                             │   │
│  │  • Global investor access                                           │   │
│  │  • Secondary market liquidity                                       │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    TITLE MANAGEMENT                                  │   │
│  │  Property records on immutable blockchain.                          │   │
│  │  • Transparent ownership history                                    │   │
│  │  • Reduced fraud                                                    │   │
│  │  • Faster title searches                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                    SMART CONTRACTS                                   │   │
│  │  Automated property transactions.                                   │   │
│  │  • Rent collection                                                  │   │
│  │  • Escrow management                                                │   │
│  │  • Royalty distributions                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    PROPERTY TOKENISATION PROCESS                            │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  STEP 1: ASSET VALUATION                                                   │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Professional appraisal                                            │   │
│  │ • Market analysis                                                   │   │
│  │ • Legal due diligence                                               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  STEP 2: LEGAL STRUCTURE                                                   │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Create SPV (Special Purpose Vehicle)                             │   │
│  │ • Define token rights (dividends, voting)                          │   │
│  │ • Regulatory compliance                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  STEP 3: TOKEN CREATION                                                     │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Deploy smart contract                                             │   │
│  │ • Mint tokens representing ownership                               │   │
│  │ • Set token parameters (supply, price, restrictions)               │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                    │                                        │
│                                    v                                        │
│  STEP 4: DISTRIBUTION & TRADING                                            │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │ • Primary sale to investors                                         │   │
│  │ • Secondary market trading                                          │   │
│  │ • Dividend distributions                                            │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 3, LESSON 5: REAL ESTATE AND PROPERTY
# ===================================================================

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

print("="*70)
print("REAL ESTATE AND PROPERTY – BLOCKCHAIN APPLICATIONS")
print("="*70)

# ----------------------------------------------------------------
# PART A: PROPERTY TOKENISATION SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Property Tokenisation Simulation")
print("-"*60)

class PropertyToken:
    """
    Represents a tokenised property with fractional ownership.
    """
    def __init__(self, property_id: str, address: str, property_type: str, 
                 total_value: float, total_tokens: int):
        self.property_id = property_id
        self.address = address
        self.property_type = property_type
        self.total_value = total_value
        self.total_tokens = total_tokens
        self.token_price = total_value / total_tokens
        self.owner_balances: Dict[str, int] = {}
        self.rental_income = 0
        self.distributions = []
        self.transfers = []
        self.created_at = datetime.now()
        
        # Initial distribution to developer
        self.owner_balances['Developer'] = total_tokens
    
    def get_token_price(self) -> float:
        return self.token_price
    
    def get_balance(self, owner: str) -> int:
        return self.owner_balances.get(owner, 0)
    
    def transfer_tokens(self, from_owner: str, to_owner: str, amount: int) -> bool:
        if self.owner_balances.get(from_owner, 0) < amount:
            print(f"Insufficient balance for {from_owner}")
            return False
        if amount <= 0:
            return False
        
        self.owner_balances[from_owner] -= amount
        self.owner_balances[to_owner] = self.owner_balances.get(to_owner, 0) + amount
        
        self.transfers.append({
            'from': from_owner,
            'to': to_owner,
            'amount': amount,
            'timestamp': datetime.now(),
            'tx_hash': hashlib.sha256(f"{from_owner}{to_owner}{amount}{time.time()}".encode()).hexdigest()[:16]
        })
        return True
    
    def add_rental_income(self, amount: float) -> None:
        self.rental_income += amount
        print(f"Added rental income: ${amount:,.2f}")
    
    def distribute_income(self) -> Dict:
        """Distribute rental income to token holders."""
        if self.rental_income == 0 or len(self.owner_balances) == 0:
            return {'message': 'No income to distribute'}
        
        distribution = {}
        for owner, tokens in self.owner_balances.items():
            if tokens > 0:
                share = (tokens / self.total_tokens) * self.rental_income
                distribution[owner] = share
        
        self.distributions.append({
            'amount': self.rental_income,
            'date': datetime.now(),
            'distribution': distribution
        })
        
        self.rental_income = 0
        print(f"Distributed ${sum(distribution.values()):,.2f} to {len(distribution)} token holders")
        return distribution
    
    def get_metrics(self) -> Dict:
        num_holders = len([b for b in self.owner_balances.values() if b > 0])
        tokens_in_circulation = sum(self.owner_balances.values())
        
        return {
            'property_id': self.property_id,
            'address': self.address,
            'total_value': self.total_value,
            'token_price': self.token_price,
            'total_tokens': self.total_tokens,
            'holders': num_holders,
            'circulation_rate': tokens_in_circulation / self.total_tokens,
            'total_transfers': len(self.transfers),
            'total_distributions': len(self.distributions),
            'rental_income_pending': self.rental_income
        }
    
    def get_holder_summary(self) -> pd.DataFrame:
        """Get summary of all token holders."""
        holders = []
        for owner, tokens in self.owner_balances.items():
            if tokens > 0:
                holders.append({
                    'owner': owner,
                    'tokens': tokens,
                    'percentage': (tokens / self.total_tokens) * 100,
                    'value': tokens * self.token_price
                })
        return pd.DataFrame(holders).sort_values('tokens', ascending=False)

# Create tokenised property
property_token = PropertyToken(
    property_id='PR-001',
    address='123 Main Street, New York, NY 10001',
    property_type='Commercial',
    total_value=5000000,  # $5M property
    total_tokens=50000     # 50,000 tokens at $100 each
)

print(f"Property Tokenised: {property_token.address}")
print(f"Property Type: {property_token.property_type}")
print(f"Total Value: ${property_token.total_value:,.2f}")
print(f"Token Price: ${property_token.token_price:.2f}")
print(f"Total Tokens: {property_token.total_tokens}")

# Initial token distribution
print("\n--- Token Distribution ---")
investors = ['Alice', 'Bob', 'Charlie', 'David', 'Eve']
allocations = [5000, 3000, 2000, 1500, 1000]

for investor, allocation in zip(investors, allocations):
    property_token.transfer_tokens('Developer', investor, allocation)

# Remaining tokens stay with developer
print(f"Developer retains: {property_token.get_balance('Developer')} tokens")

# Show holder summary
print("\nHolder Summary:")
print(property_token.get_holder_summary().to_string(index=False))

# ----------------------------------------------------------------
# PART B: RENTAL INCOME DISTRIBUTION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Rental Income Distribution")
print("-"*60)

# Simulate rental income
print("Simulating rental income over 3 months...")
monthly_rent = 25000  # $25,000 per month

for month in range(1, 4):
    print(f"\nMonth {month}: Collecting ${monthly_rent:,.2f} rent")
    property_token.add_rental_income(monthly_rent)
    
    # Distribute income
    distribution = property_token.distribute_income()
    if isinstance(distribution, dict) and 'message' not in distribution:
        print("Income distributed to:")
        for owner, amount in list(distribution.items())[:3]:
            print(f"  {owner}: ${amount:,.2f}")

# ----------------------------------------------------------------
# PART C: PROPERTY ANALYTICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Property Analytics")
print("-"*60)

class PropertyAnalytics:
    """
    Analytics for tokenised properties.
    """
    def __init__(self, property_token: PropertyToken):
        self.token = property_token
    
    def calculate_yield(self, annual_rent: float) -> float:
        """Calculate gross rental yield."""
        return annual_rent / self.token.total_value
    
    def calculate_token_metrics(self, token_price_change: float) -> Dict:
        """Calculate performance metrics."""
        current_price = self.token.token_price * (1 + token_price_change)
        initial_investment = self.token.token_price
        
        return {
            'current_token_price': current_price,
            'price_change': token_price_change,
            'price_change_pct': token_price_change * 100,
            'annual_yield': self.calculate_yield(25000 * 12),
            'total_holders': len([h for h in self.token.owner_balances.values() if h > 0]),
            'liquidity_score': self.token.circulation_rate * 100
        }
    
    def generate_investment_report(self) -> pd.DataFrame:
        """Generate a comprehensive investment report."""
        holder_data = self.token.get_holder_summary()
        
        report = {
            'Metric': [
                'Property Value',
                'Token Price',
                'Total Tokens',
                'Active Holders',
                'Circulation Rate',
                'Annual Rental Income',
                'Gross Yield',
                'Total Distributions'
            ],
            'Value': [
                f"${self.token.total_value:,.2f}",
                f"${self.token.token_price:.2f}",
                f"{self.token.total_tokens:,}",
                len([h for h in self.token.owner_balances.values() if h > 0]),
                f"{self.token.circulation_rate:.1%}",
                f"${25000 * 12:,.2f}",
                f"{self.calculate_yield(25000 * 12):.2%}",
                len(self.token.distributions)
            ]
        }
        return pd.DataFrame(report)

# Generate property analytics
analytics = PropertyAnalytics(property_token)

print("Property Analytics Report:")
report = analytics.generate_investment_report()
print(report.to_string(index=False))

# Simulate token price change and calculate metrics
print("\nToken Performance Metrics (10% price increase):")
metrics = analytics.calculate_token_metrics(0.10)
for key, value in metrics.items():
    if isinstance(value, float):
        print(f"  {key}: {value:.2%}" if 'pct' in key or 'yield' in key else f"  {key}: {value:.2f}")
    else:
        print(f"  {key}: {value}")

# ----------------------------------------------------------------
# PART D: REAL ESTATE MARKET VISUALISATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Real Estate Market Visualisation")
print("-"*60)

# Simulate real estate market data
property_types = ['Residential', 'Commercial', 'Industrial', 'Retail', 'Mixed Use']
regions = ['New York', 'London', 'Singapore', 'Dubai', 'Hong Kong']

market_data = []
for _ in range(50):
    property_type = random.choice(property_types)
    region = random.choice(regions)
    size = random.uniform(1000, 50000)
    price_per_sqft = random.uniform(200, 2000)
    total_value = size * price_per_sqft
    
    tokenised = random.choice([True, False])
    token_price = total_value / random.randint(1000, 50000) if tokenised else None
    
    market_data.append({
        'property_type': property_type,
        'region': region,
        'size_sqft': size,
        'price_per_sqft': price_per_sqft,
        'total_value': total_value,
        'tokenised': tokenised,
        'est_token_price': token_price
    })

market_df = pd.DataFrame(market_data)

# Create visualisations
fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# 1. Property value by type
ax1 = axes[0, 0]
value_by_type = market_df.groupby('property_type')['total_value'].mean().sort_values()
ax1.barh(value_by_type.index, value_by_type.values, color='teal', alpha=0.7)
ax1.set_xlabel('Average Property Value ($)')
ax1.set_title('Average Property Value by Type')
ax1.grid(True, alpha=0.3)

# 2. Price per sq ft by region
ax2 = axes[0, 1]
price_by_region = market_df.groupby('region')['price_per_sqft'].mean().sort_values()
ax2.bar(price_by_region.index, price_by_region.values, color='orange', alpha=0.7)
ax2.set_ylabel('Price per Sq Ft ($)')
ax2.set_title('Average Price per Sq Ft by Region')
ax2.grid(True, alpha=0.3)
plt.setp(ax2.get_xticklabels(), rotation=45, ha='right')

# 3. Tokenisation penetration
ax3 = axes[1, 0]
tokenisation_by_type = market_df.groupby('property_type')['tokenised'].mean()
ax3.bar(tokenisation_by_type.index, tokenisation_by_type.values, color='green', alpha=0.7)
ax3.set_ylabel('Tokenisation Rate (%)')
ax3.set_title('Tokenisation Penetration by Property Type')
ax3.grid(True, alpha=0.3)
plt.setp(ax3.get_xticklabels(), rotation=45, ha='right')

# 4. Property size distribution
ax4 = axes[1, 1]
ax4.hist(market_df['size_sqft'] / 1000, bins=20, color='purple', alpha=0.7, edgecolor='black')
ax4.set_xlabel('Size (sq ft x 1000)')
ax4.set_ylabel('Frequency')
ax4.set_title('Property Size Distribution')
ax4.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('real_estate_market.png', dpi=300, bbox_inches='tight')
plt.show()
print("Real estate market chart saved as 'real_estate_market.png'")

# ----------------------------------------------------------------
# PART E: BLOCKCHAIN BENEFITS IN REAL ESTATE
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Blockchain Benefits in Real Estate")
print("-"*60)

benefits_data = pd.DataFrame({
    'Benefit': [
        'Transaction Speed',
        'Cost Reduction',
        'Transparency',
        'Liquidity',
        'Accessibility',
        'Fraud Prevention',
        'Fractional Ownership'
    ],
    'Traditional': [
        '30-90 days',
        '5-10% fees',
        'Limited',
        'Low',
        'High barriers',
        'Vulnerable',
        'Not available'
    ],
    'Blockchain-Enabled': [
        'Hours-days',
        '1-3% fees',
        'Full',
        'High',
        'Low barriers',
        'Immutable',
        'Available'
    ],
    'Improvement': [
        '95% reduction',
        '70% reduction',
        'Significant',
        '10x+',
        'Dramatic',
        'High',
        'New capability'
    ]
})

print(benefits_data.to_string(index=False))

# Visualise benefit improvement
fig, ax = plt.subplots(figsize=(10, 6))

# Create a comparative bar chart for quantitative metrics
metrics = ['Transaction Speed (days)', 'Cost Reduction (%)', 'Liquidity Score']
traditional_values = [60, 7, 20]  # Lower is better for speed and cost, higher for liquidity
blockchain_values = [2, 2.5, 85]   # Speed in days, cost as %, liquidity as score

x = np.arange(len(metrics))
width = 0.35

ax.bar(x - width/2, traditional_values, width, label='Traditional', color='red', alpha=0.7)
ax.bar(x + width/2, blockchain_values, width, label='Blockchain-Enabled', color='green', alpha=0.7)

ax.set_xlabel('Metric')
ax.set_ylabel('Value')
ax.set_title('Real Estate: Traditional vs Blockchain-Enabled')
ax.set_xticks(x)
ax.set_xticklabels(metrics)
ax.legend()
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('real_estate_benefits.png', dpi=300, bbox_inches='tight')
plt.show()
print("Real estate benefits chart saved as 'real_estate_benefits.png'")

# ----------------------------------------------------------------
# PART F: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

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

print("""
Real Estate and Property with Blockchain – Key Takeaways:

1. Real estate tokenisation enables fractional ownership and liquidity.
2. Blockchain provides immutable title records and transparent transactions.
3. Smart contracts automate rent collection, escrow, and distributions.
4. Token economics: total supply, token price, dividends, transfer restrictions.
5. Key platforms: Propy, RealT, SolidBlock, RedSwan.
6. Benefits: faster transactions, lower costs, global access, fraud reduction.
7. Tokenisation democratises real estate investment.

Recommendations:
  - Start with tokenising a single property to test the model.
  - Ensure legal and regulatory compliance (securities laws).
  - Build transparent governance for token holders.
  - Integrate with property management systems.
  - Educate investors on token economics and risks.
  - Consider stablecoins for dividend distributions.
  - Plan for secondary market liquidity.
""")