# ===================================================================
# MODULE 6, LESSON 7: BLOCKCHAIN AND DEFI ANALYTICS
# ===================================================================

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import requests
import json
from datetime import datetime, timedelta
import hashlib
import warnings
warnings.filterwarnings('ignore')

# Set style
sns.set_style("whitegrid")
np.random.seed(42)

print("="*70)
print("BLOCKCHAIN AND DECENTRALISED FINANCE (DEFI) ANALYTICS")
print("="*70)

# ----------------------------------------------------------------
# PART A: SIMULATED BLOCKCHAIN TRANSACTION DATA
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Simulated Blockchain Transaction Data")
print("-"*60)

# Simulate 10,000 transactions over 30 days
n_transactions = 10000
days = 30

# Generate timestamps (with realistic distribution)
timestamps = []
for d in range(days):
    # Transactions per day: weekday/weekend pattern
    daily_vol = np.random.poisson(333)  # avg 333/day
    if d % 7 in [5, 6]:  # weekend
        daily_vol = int(daily_vol * 0.6)
    # Random times within the day
    times = np.random.uniform(0, 86400, daily_vol)
    for t in times:
        ts = datetime(2024, 1, 1) + timedelta(days=d, seconds=int(t))
        timestamps.append(ts)

timestamps = pd.Series(timestamps)
# Simulate transaction amounts (log-normal)
amounts = np.random.lognormal(3, 2, len(timestamps))
# Round to 2 decimals
amounts = np.round(amounts, 2)

# Simulate addresses
addresses = [f"0x{hashlib.sha256(str(i).encode()).hexdigest()[:20]}" for i in range(500)]
sender = np.random.choice(addresses, len(timestamps))
receiver = np.random.choice(addresses, len(timestamps))

# Simulate gas fees (in Gwei)
gas_fees = np.random.gamma(20, 5, len(timestamps)).clip(1, 150)

# Create DataFrame
df_tx = pd.DataFrame({
    'timestamp': timestamps,
    'amount': amounts,
    'sender': sender,
    'receiver': receiver,
    'gas_fee': gas_fees
})

# Add some outliers (whale transactions)
whale_idx = np.random.choice(len(df_tx), 20, replace=False)
df_tx.loc[whale_idx, 'amount'] = np.random.uniform(10000, 500000, 20)
# Add a few zero-value spam transactions
spam_idx = np.random.choice(len(df_tx), 50, replace=False)
df_tx.loc[spam_idx, 'amount'] = 0

print(f"Generated {len(df_tx)} transactions over {days} days.")
print(f"Total value: ${df_tx['amount'].sum():,.2f}")
print(f"Average amount: ${df_tx['amount'].mean():.2f}")
print(f"Median amount: ${df_tx['amount'].median():.2f}")
print(f"Max amount: ${df_tx['amount'].max():,.2f}")

# ----------------------------------------------------------------
# PART B: TRANSACTION VOLUME AND NETWORK ACTIVITY
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Transaction Volume and Network Activity")
print("-"*60)

# Aggregate by day
df_tx['date'] = df_tx['timestamp'].dt.date
daily_volume = df_tx.groupby('date').agg({
    'amount': ['sum', 'count', 'mean'],
    'gas_fee': 'mean'
}).reset_index()
daily_volume.columns = ['date', 'total_volume', 'tx_count', 'avg_amount', 'avg_gas']

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

ax = axes[0, 0]
ax.plot(daily_volume['date'], daily_volume['total_volume'], 'b-', linewidth=2)
ax.set_xlabel('Date')
ax.set_ylabel('Total Volume ($)')
ax.set_title('Daily Transaction Volume')
ax.grid(True, alpha=0.3)

ax = axes[0, 1]
ax.plot(daily_volume['date'], daily_volume['tx_count'], 'g-', linewidth=2)
ax.set_xlabel('Date')
ax.set_ylabel('Transaction Count')
ax.set_title('Daily Transaction Count')
ax.grid(True, alpha=0.3)

ax = axes[1, 0]
ax.plot(daily_volume['date'], daily_volume['avg_amount'], 'r-', linewidth=2)
ax.set_xlabel('Date')
ax.set_ylabel('Average Transaction Amount ($)')
ax.set_title('Average Transaction Size')
ax.grid(True, alpha=0.3)

ax = axes[1, 1]
ax.plot(daily_volume['date'], daily_volume['avg_gas'], 'purple', linewidth=2)
ax.set_xlabel('Date')
ax.set_ylabel('Average Gas Fee (Gwei)')
ax.set_title('Average Gas Fee')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('blockchain_activity.png', dpi=300)
plt.show()

# ----------------------------------------------------------------
# PART C: WHALE WATCH – LARGE TRANSACTION ANALYSIS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Whale Watch – Large Transaction Analysis")
print("-"*60)

# Define whale threshold (top 1% of transactions)
threshold = df_tx['amount'].quantile(0.99)
whale_tx = df_tx[df_tx['amount'] > threshold]

print(f"Whale threshold (99th percentile): ${threshold:,.2f}")
print(f"Number of whale transactions: {len(whale_tx)}")
print(f"Whale volume: ${whale_tx['amount'].sum():,.2f}")
print(f"Whale % of total volume: {whale_tx['amount'].sum() / df_tx['amount'].sum() * 100:.2f}%")

# Top whales
top_whales = whale_tx.sort_values('amount', ascending=False).head(10)
print("\nTop 10 Whale Transactions:")
print(top_whales[['timestamp', 'amount', 'sender', 'receiver']].round(2).to_string(index=False))

# Whale concentration over time
whale_by_date = whale_tx.groupby(whale_tx['timestamp'].dt.date).agg({
    'amount': 'sum',
    'amount': 'count'
}).reset_index()
whale_by_date.columns = ['date', 'whale_volume', 'whale_count']

fig, ax = plt.subplots(figsize=(12, 5))
ax.bar(whale_by_date['date'], whale_by_date['whale_volume'], color='gold', alpha=0.7)
ax.set_xlabel('Date')
ax.set_ylabel('Whale Volume ($)')
ax.set_title('Daily Whale Transaction Volume')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('whale_activity.png', dpi=300)
plt.show()

# ----------------------------------------------------------------
# PART D: NETWORK HEALTH – ACTIVE ADDRESSES
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Network Health – Active Addresses")
print("-"*60)

# Count unique senders and receivers per day
active_senders = df_tx.groupby(df_tx['timestamp'].dt.date)['sender'].nunique()
active_receivers = df_tx.groupby(df_tx['timestamp'].dt.date)['receiver'].nunique()
active_addresses = active_senders + active_receivers

# Plot
fig, ax = plt.subplots(figsize=(12, 5))
ax.plot(active_addresses.index, active_addresses.values, 'b-', linewidth=2)
ax.set_xlabel('Date')
ax.set_ylabel('Active Addresses')
ax.set_title('Daily Active Addresses')
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('active_addresses.png', dpi=300)
plt.show()

print(f"Average daily active addresses: {active_addresses.mean():.0f}")
print(f"Peak daily active addresses: {active_addresses.max():.0f}")

# ----------------------------------------------------------------
# PART E: DEFI SIMULATION – LENDING AND BORROWING
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: DeFi Lending and Borrowing Simulation")
print("-"*60)

# Simulate a DeFi lending pool
# Users deposit assets, earn interest
# Borrowers take loans against collateral

n_users = 1000
n_days = 30

# Simulate user deposits and borrows
deposits = np.random.gamma(2, 500, n_users)  # User deposits
collateral_ratio = np.random.uniform(0.5, 0.9, n_users)  # LTV
borrow_amount = deposits * collateral_ratio * np.random.uniform(0.3, 0.8, n_users)

# Interest rates (annualised)
deposit_rate = 0.03  # 3% APR
borrow_rate = 0.08   # 8% APR
market_volatility = 0.2  # Asset volatility

# Simulate daily interest accrual over 30 days
def simulate_interest(deposits, borrows, deposit_rate, borrow_rate, n_days):
    """Simulate interest accrual on a DeFi lending pool."""
    # Daily rates (continuous compounding)
    daily_deposit = np.exp(deposit_rate / 365) - 1
    daily_borrow = np.exp(borrow_rate / 365) - 1
    
    # Simulate asset price fluctuations
    prices = 100 * np.exp(np.cumsum(np.random.normal(0, market_volatility / np.sqrt(365), n_days)))
    
    # Simulate positions over time
    daily_deposit_balance = []
    daily_borrow_balance = []
    
    for d in range(n_days):
        # Interest accrual
        deposits_accrued = deposits * (1 + daily_deposit) ** d
        borrows_accrued = borrows * (1 + daily_borrow) ** d
        # Check collateral health (if borrows > deposits * LTV)
        collateral_value = deposits_accrued * prices[d] / 100  # Simulate price impact
        health = collateral_value / borrows_accrued
        # If health < 1.1, liquidation event (simplified)
        if health < 1.1:
            # Liquidate: sell collateral to cover borrow
            deposits_accrued = borrows_accrued * 1.1 / prices[d] * 100
        
        daily_deposit_balance.append(np.mean(deposits_accrued))
        daily_borrow_balance.append(np.mean(borrows_accrued))
    
    return daily_deposit_balance, daily_borrow_balance

# Simulate
dep_balance, bor_balance = simulate_interest(deposits, borrow_amount, deposit_rate, borrow_rate, n_days)

# Visualise
fig, ax = plt.subplots(figsize=(12, 5))
ax.plot(range(n_days), dep_balance, label='Average Deposit Balance', color='green', linewidth=2)
ax.plot(range(n_days), bor_balance, label='Average Borrow Balance', color='red', linewidth=2)
ax.axhline(y=0, color='black', linestyle='-', alpha=0.3)
ax.set_xlabel('Day')
ax.set_ylabel('Balance ($)')
ax.set_title('DeFi Lending Pool – Average Balances Over Time')
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.savefig('defi_simulation.png', dpi=300)
plt.show()

print("DeFi Lending Simulation Complete.")

# ----------------------------------------------------------------
# PART F: REGULATORY AND COMPLIANCE ANALYTICS
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Regulatory and Compliance Analytics")
print("-"*60)

# Simulate AML checks: flag transactions to known high-risk addresses
# For demonstration, create a list of "sanctioned" addresses
sanctioned = np.random.choice(addresses, 10, replace=False)

# Flag transactions involving sanctioned addresses
df_tx['sanctioned_flag'] = (df_tx['sender'].isin(sanctioned) | df_tx['receiver'].isin(sanctioned))
sanctioned_tx = df_tx[df_tx['sanctioned_flag']]

print(f"Number of transactions involving sanctioned addresses: {len(sanctioned_tx)}")
print(f"Total value of flagged transactions: ${sanctioned_tx['amount'].sum():,.2f}")

# Identify potential suspicious patterns: frequent small transactions (structuring)
# Structuring: breaking large amounts into small transactions to avoid reporting
def detect_structuring(df, threshold=10000, count_threshold=5):
    """Detect potential structuring (smurfing) by address."""
    # Group by sender, count transactions, and total amount
    sender_summary = df.groupby('sender').agg(
        tx_count=('amount', 'count'),
        total_amount=('amount', 'sum'),
        avg_amount=('amount', 'mean')
    ).reset_index()
    
    # Flag addresses with high count and small avg amount but significant total
    structuring = sender_summary[
        (sender_summary['tx_count'] > count_threshold) &
        (sender_summary['avg_amount'] < threshold) &
        (sender_summary['total_amount'] > threshold * 5)
    ]
    return structuring

structuring_risk = detect_structuring(df_tx)
print(f"\nPotential structuring (smurfing) addresses detected: {len(structuring_risk)}")
if len(structuring_risk) > 0:
    print(structuring_risk.head(5).round(2).to_string(index=False))

# ----------------------------------------------------------------
# PART G: REGULATORY LANDSCAPE SUMMARY
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART G: Regulatory Landscape for Crypto and DeFi")
print("-"*60)

print("""
Regulatory Frameworks:

1. AML/KYC:
   - Financial Action Task Force (FATF) guidelines.
   - Travel Rule: VASPs must share sender/receiver info for transactions > $3,000 (EU) / $10,000 (US).
   - US: FinCEN, NYDFS BitLicense.

2. Securities Regulation:
   - SEC (US): Cryptocurrencies may be securities (Howey Test).
   - EU: MiCA (Markets in Crypto-Assets) regulation – comprehensive framework.

3. Taxation:
   - IRS treats cryptocurrency as property (capital gains).
   - EU: VAT exemption for crypto-to-fiat exchanges.

4. Stablecoins:
   - US: Proposed legislation for reserve backing and transparency.
   - UK: Stablecoins recognised as a form of payment.

5. CBDCs:
   - China: e-CNY (pilot).
   - Europe: Digital euro (development).
   - US: Digital dollar (research).

6. DeFi Regulation:
   - Focus on KYC/AML for DeFi protocols.
   - Potential classification of DeFi lending as securities or banking.

Banks are expected to:
  - Implement robust AML/KYC for crypto transactions.
  - Monitor customer exposure to crypto.
  - Prepare for CBDC integration.
  - Engage with regulators on DeFi risks.
""")

# ----------------------------------------------------------------
# PART H: SUMMARY AND RECOMMENDATIONS
# ----------------------------------------------------------------

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

print("""
Key Takeaways:

1. Blockchain enables decentralised, transparent, and immutable transactions.
2. Cryptocurrencies (Bitcoin, Ethereum) are the foundational layer.
3. DeFi replicates traditional financial services without intermediaries.
4. Blockchain data is rich for analytics: transaction flows, network health, fraud detection.
5. Regulatory landscape is evolving – AML/KYC, securities, taxation, CBDCs.
6. Banks are exploring blockchain for settlement, trade finance, and digital assets.

Recommendations for Practitioners:
  - Understand blockchain basics and use cases.
  - Familiarise yourself with on-chain analytics tools (Dune, Glassnode).
  - Apply Python for blockchain data analysis (APIs, SQL).
  - Stay updated on regulatory developments (FATF, MiCA, SEC).
  - Explore DeFi as an area of innovation (and risk).
  - Prepare for CBDC integration in banking systems.
""")

print("="*70)
print("END OF LESSON 7 – MODULE 6")
print("="*70)