┌─────────────────────────────────────────────────────────────────────────────┐
│                    BLOCKCHAIN TRADE FINANCE                               │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐                    │
│  │  Importer   │    │  Exporter   │    │  Bank       │                    │
│  │  (Buyer)    │    │  (Seller)   │    │  (Intermediary)                  │
│  └─────────────┘    └─────────────┘    └─────────────┘                    │
│        │                  │                  │                             │
│        └──────────────────┴──────────────────┘                             │
│                              │                                              │
│                    ┌─────────▼─────────┐                                  │
│                    │    BLOCKCHAIN     │                                  │
│                    │  (Shared Ledger)  │                                  │
│                    │                   │                                  │
│                    │  • Letter of      │                                  │
│                    │    Credit         │                                  │
│                    │  • Documentation  │                                  │
│                    │  • Tracking       │                                  │
│                    │  • Settlement     │                                  │
│                    └───────────────────┘                                  │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────────────────────┐
│                    SMART CONTRACT EXAMPLE                                 │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Conditions:                                                               │
│  • Payment amount: $10,000                                                │
│  • Seller delivers goods                                                  │
│  • Buyer confirms receipt                                                 │
│                                                                             │
│  IF Seller delivers goods AND Buyer confirms receipt:                     │
│     Execute: Transfer $10,000 from Buyer to Seller                        │
│     Execute: Update ledger                                                │
│     Execute: Notify both parties                                          │
│  ELSE:                                                                     │
│     Execute: Escrow funds until conditions met                            │
│     Execute: Notify both parties of status                                │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

# ===================================================================
# MODULE 3, LESSON 6: BLOCKCHAIN IN BANKING OPERATIONS
# ===================================================================

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

print("="*70)
print("BLOCKCHAIN IN BANKING OPERATIONS")
print("="*70)

# ----------------------------------------------------------------
# PART A: BLOCKCHAIN USE CASES IN BANKING
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART A: Blockchain Use Cases in Banking")
print("-"*60)

use_cases = pd.DataFrame({
    'Use Case': [
        'Trade Finance',
        'Cross-Border Payments',
        'Reconciliation',
        'Settlement',
        'Smart Contracts',
        'KYC/Identity',
        'Supply Chain Finance',
        'Asset Tokenisation'
    ],
    'Maturity (1-5)': [3, 4, 3, 4, 3, 3, 2, 2],
    'Impact (1-5)': [5, 5, 4, 5, 5, 4, 4, 5],
    'Complexity (1-5)': [4, 3, 3, 4, 4, 3, 4, 5],
    'ROI Potential': ['High', 'High', 'Medium', 'High', 'High', 'Medium', 'High', 'High']
})

print("Blockchain Use Cases in Banking:")
print(use_cases.to_string(index=False))

# Visualise
fig, ax = plt.subplots(figsize=(10, 6))
scatter = ax.scatter(use_cases['Maturity (1-5)'], use_cases['Impact (1-5)'], 
                     s=use_cases['Complexity (1-5)'] * 100, alpha=0.7)
for i, row in use_cases.iterrows():
    ax.annotate(row['Use Case'], (row['Maturity (1-5)'] + 0.1, row['Impact (1-5)'] + 0.1))
ax.set_xlabel('Maturity (1-5)')
ax.set_ylabel('Impact (1-5)')
ax.set_title('Blockchain Use Cases: Maturity vs Impact')
ax.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('blockchain_use_cases.png', dpi=300, bbox_inches='tight')
plt.show()
print("Blockchain use cases visualisation saved as 'blockchain_use_cases.png'")

# ----------------------------------------------------------------
# PART B: SIMPLIFIED BLOCKCHAIN IMPLEMENTATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART B: Simplified Blockchain Implementation")
print("-"*60)

class Block:
    """A simple block in a blockchain."""
    
    def __init__(self, index, transactions, timestamp, previous_hash):
        self.index = index
        self.transactions = transactions
        self.timestamp = timestamp
        self.previous_hash = previous_hash
        self.hash = self.calculate_hash()
    
    def calculate_hash(self):
        """Calculate the hash of the block."""
        block_string = json.dumps({
            'index': self.index,
            'transactions': self.transactions,
            'timestamp': self.timestamp,
            'previous_hash': self.previous_hash
        }, sort_keys=True)
        return hashlib.sha256(block_string.encode()).hexdigest()

class Blockchain:
    """A simple blockchain for banking operations."""
    
    def __init__(self):
        self.chain = [self.create_genesis_block()]
    
    def create_genesis_block(self):
        """Create the genesis block."""
        return Block(0, [], datetime.now().isoformat(), "0")
    
    def get_latest_block(self):
        """Get the latest block."""
        return self.chain[-1]
    
    def add_block(self, transactions):
        """Add a new block to the chain."""
        previous_block = self.get_latest_block()
        new_block = Block(
            index=previous_block.index + 1,
            transactions=transactions,
            timestamp=datetime.now().isoformat(),
            previous_hash=previous_block.hash
        )
        self.chain.append(new_block)
        return new_block
    
    def is_valid(self):
        """Validate the blockchain."""
        for i in range(1, len(self.chain)):
            current_block = self.chain[i]
            previous_block = self.chain[i-1]
            
            # Check if the hash is correct
            if current_block.hash != current_block.calculate_hash():
                return False
            
            # Check if the previous hash is correct
            if current_block.previous_hash != previous_block.hash:
                return False
        
        return True

# Create a blockchain and add transactions
print("Creating banking blockchain...")
bankchain = Blockchain()

# Simulate trade finance transactions
transactions = [
    {'type': 'Letter of Credit', 'from': 'Exporter A', 'to': 'Importer B', 'amount': 100000, 'status': 'Issued'},
    {'type': 'Payment', 'from': 'Importer B', 'to': 'Exporter A', 'amount': 100000, 'status': 'Completed'},
    {'type': 'Document', 'from': 'Exporter A', 'to': 'Bank X', 'amount': 0, 'status': 'Verified'},
    {'type': 'Settlement', 'from': 'Bank X', 'to': 'Exporter A', 'amount': 100000, 'status': 'Settled'},
    {'type': 'Reconciliation', 'from': 'Bank X', 'to': 'Bank Y', 'amount': 100000, 'status': 'Matched'}
]

for tx in transactions:
    block = bankchain.add_block(tx)
    print(f"Added block {block.index}: {tx['type']} - {tx['status']}")

print(f"\nBlockchain valid: {bankchain.is_valid()}")
print(f"Total blocks: {len(bankchain.chain)}")

# ----------------------------------------------------------------
# PART C: TRADE FINANCE SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART C: Trade Finance Simulation")
print("-"*60)

class TradeFinance:
    """Simulate trade finance on blockchain."""
    
    def __init__(self):
        self.blockchain = Blockchain()
        self.trades = []
        self.trade_counter = 0
    
    def create_trade(self, importer, exporter, amount, goods):
        """Create a new trade on blockchain."""
        self.trade_counter += 1
        trade = {
            'trade_id': self.trade_counter,
            'importer': importer,
            'exporter': exporter,
            'amount': amount,
            'goods': goods,
            'status': 'Created',
            'created': datetime.now().isoformat(),
            'steps': []
        }
        self.trades.append(trade)
        self._record_step(trade, 'Trade Created', 'Created')
        return trade
    
    def issue_letter_of_credit(self, trade):
        """Issue a letter of credit."""
        trade['status'] = 'L/C Issued'
        self._record_step(trade, 'Letter of Credit Issued', 'L/C Issued')
        self._add_block(f"L/C Issued for Trade {trade['trade_id']} - {trade['amount']}")
        return trade
    
    def ship_goods(self, trade):
        """Record goods shipment."""
        trade['status'] = 'Goods Shipped'
        self._record_step(trade, 'Goods Shipped', 'Goods Shipped')
        self._add_block(f"Goods Shipped for Trade {trade['trade_id']} - {trade['goods']}")
        return trade
    
    def confirm_receipt(self, trade):
        """Confirm receipt of goods."""
        trade['status'] = 'Goods Received'
        self._record_step(trade, 'Goods Received', 'Goods Received')
        self._add_block(f"Goods Received for Trade {trade['trade_id']} - Confirmed by {trade['importer']}")
        return trade
    
    def execute_payment(self, trade):
        """Execute payment."""
        trade['status'] = 'Payment Completed'
        self._record_step(trade, 'Payment Executed', 'Payment Completed')
        self._add_block(f"Payment Executed for Trade {trade['trade_id']} - {trade['amount']}")
        return trade
    
    def _record_step(self, trade, description, status):
        """Record a step in the trade process."""
        trade['steps'].append({
            'step': description,
            'timestamp': datetime.now().isoformat(),
            'status': status
        })
    
    def _add_block(self, data):
        """Add a block to the blockchain."""
        self.blockchain.add_block({'type': 'Trade Finance', 'data': data})
    
    def get_trade_status(self, trade_id):
        """Get the status of a trade."""
        for trade in self.trades:
            if trade['trade_id'] == trade_id:
                return trade['status']
        return None

# Simulate a trade finance transaction
tf = TradeFinance()

print("Simulating trade finance transaction on blockchain...")

# Create trade
trade = tf.create_trade("Importer B", "Exporter A", 100000, "Electronics")
print(f"Trade {trade['trade_id']} created: {trade['status']}")

# Process trade
tf.issue_letter_of_credit(trade)
print(f"Trade {trade['trade_id']}: {trade['status']}")

tf.ship_goods(trade)
print(f"Trade {trade['trade_id']}: {trade['status']}")

tf.confirm_receipt(trade)
print(f"Trade {trade['trade_id']}: {trade['status']}")

tf.execute_payment(trade)
print(f"Trade {trade['trade_id']}: {trade['status']}")

print(f"\nTrade Steps:")
for step in trade['steps']:
    print(f"  {step['step']} - {step['timestamp']}")

print(f"\nBlockchain valid: {tf.blockchain.is_valid()}")
print(f"Total blocks: {len(tf.blockchain.chain)}")

# ----------------------------------------------------------------
# PART D: RECONCILIATION USING BLOCKCHAIN
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART D: Reconciliation Using Blockchain")
print("-"*60)

class BlockchainReconciliation:
    """Simulate reconciliation on blockchain."""
    
    def __init__(self):
        self.ledger = Blockchain()
        self.transactions = []
    
    def record_transaction(self, tx_id, from_account, to_account, amount):
        """Record a transaction on the ledger."""
        tx = {
            'tx_id': tx_id,
            'from': from_account,
            'to': to_account,
            'amount': amount,
            'timestamp': datetime.now().isoformat(),
            'status': 'Recorded'
        }
        self.transactions.append(tx)
        self.ledger.add_block(tx)
        return tx
    
    def reconcile(self, external_records):
        """Reconcile internal records with external records."""
        # Convert internal transactions to a DataFrame
        internal_df = pd.DataFrame(self.transactions)
        
        # Convert external records to a DataFrame
        external_df = pd.DataFrame(external_records)
        
        # Match by transaction ID
        matched = internal_df[internal_df['tx_id'].isin(external_df['tx_id'])]
        unmatched_internal = internal_df[~internal_df['tx_id'].isin(external_df['tx_id'])]
        unmatched_external = external_df[~external_df['tx_id'].isin(internal_df['tx_id'])]
        
        # Record reconciliation on blockchain
        reconciliation_result = {
            'type': 'Reconciliation',
            'total_internal': len(internal_df),
            'total_external': len(external_df),
            'matched': len(matched),
            'unmatched_internal': len(unmatched_internal),
            'unmatched_external': len(unmatched_external),
            'timestamp': datetime.now().isoformat()
        }
        self.ledger.add_block(reconciliation_result)
        
        return reconciliation_result

# Simulate reconciliation
reconcile = BlockchainReconciliation()

# Record internal transactions
internal_tx = [
    {'tx_id': f'TX_{i}', 'from_account': 'Bank A', 'to_account': 'Bank B', 'amount': np.random.uniform(1000, 50000)}
    for i in range(1, 11)
]

print("Recording internal transactions...")
for tx in internal_tx:
    reconcile.record_transaction(tx['tx_id'], tx['from_account'], tx['to_account'], tx['amount'])

# Create external records (some missing, some extra)
external_tx = [
    {'tx_id': f'TX_{i}', 'from_account': 'Bank A', 'to_account': 'Bank B', 'amount': np.random.uniform(1000, 50000)}
    for i in range(1, 9)
]
# Add some extra transactions
external_tx.extend([
    {'tx_id': f'TX_EXT_{i}', 'from_account': 'Bank C', 'to_account': 'Bank D', 'amount': np.random.uniform(1000, 50000)}
    for i in range(1, 4)
])

# Reconcile
print("\nReconciling with external records...")
result = reconcile.reconcile(external_tx)

print(f"Reconciliation Results:")
print(f"  Internal Records: {result['total_internal']}")
print(f"  External Records: {result['total_external']}")
print(f"  Matched: {result['matched']}")
print(f"  Unmatched Internal: {result['unmatched_internal']}")
print(f"  Unmatched External: {result['unmatched_external']}")
print(f"  Match Rate: {result['matched'] / result['total_internal'] * 100:.2f}%")
print(f"\nBlockchain valid: {reconcile.ledger.is_valid()}")
print(f"Total blocks: {len(reconcile.ledger.chain)}")

# ----------------------------------------------------------------
# PART E: SMART CONTRACT SIMULATION
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART E: Smart Contract Simulation")
print("-"*60)

class SmartContract:
    """Simulate a smart contract for banking."""
    
    def __init__(self, contract_id, parties, conditions):
        self.contract_id = contract_id
        self.parties = parties
        self.conditions = conditions
        self.state = 'Deployed'
        self.execution_log = []
        self.blockchain = Blockchain()
    
    def check_conditions(self):
        """Check if all conditions are met."""
        all_met = True
        for condition in self.conditions:
            if not condition['met']:
                all_met = False
        return all_met
    
    def execute(self):
        """Execute the smart contract."""
        if self.state != 'Deployed':
            return {'status': 'Error', 'message': 'Contract already executed or terminated'}
        
        if self.check_conditions():
            self.state = 'Executing'
            self._log_step('Conditions met, executing contract')
            
            # Execute actions
            for action in self.conditions[0].get('actions', []):
                self._execute_action(action)
            
            self.state = 'Executed'
            self._log_step('Contract executed successfully')
            self._add_block('Contract executed')
            
            return {'status': 'Success', 'message': 'Contract executed successfully'}
        else:
            self.state = 'Pending'
            return {'status': 'Pending', 'message': 'Conditions not yet met'}
    
    def _execute_action(self, action):
        """Execute a contract action."""
        self._log_step(f"Executing: {action['description']}")
        # Simulate action execution
        time.sleep(0.01)
        self._log_step(f"Action completed: {action['description']}")
    
    def _log_step(self, step):
        """Log a step in the contract execution."""
        self.execution_log.append({
            'step': step,
            'timestamp': datetime.now().isoformat()
        })
    
    def _add_block(self, data):
        """Add a block to the blockchain."""
        self.blockchain.add_block({
            'type': 'Smart Contract',
            'contract_id': self.contract_id,
            'data': data
        })

# Create a smart contract for a loan
loan_contract = SmartContract(
    contract_id='LOAN_001',
    parties=['Bank A', 'Borrower B'],
    conditions=[
        {
            'description': 'Borrower completes KYC',
            'met': True
        },
        {
            'description': 'Borrower signs agreement',
            'met': True
        },
        {
            'description': 'Collateral verified',
            'met': True
        },
        {
            'description': 'Loan amount available',
            'met': True
        }
    ]
)

# Add actions
loan_contract.conditions[0]['actions'] = [
    {'description': 'Disburse $50,000 to Borrower B'},
    {'description': 'Record loan in system'},
    {'description': 'Send confirmation to parties'}
]

print(f"Smart Contract: {loan_contract.contract_id}")
print(f"Parties: {loan_contract.parties}")
print(f"Conditions: {len(loan_contract.conditions)}")

# Execute the contract
print("\nExecuting smart contract...")
result = loan_contract.execute()
print(f"Result: {result}")

print("\nExecution Log:")
for step in loan_contract.execution_log:
    print(f"  {step['step']} - {step['timestamp']}")

print(f"\nBlockchain valid: {loan_contract.blockchain.is_valid()}")
print(f"Total blocks: {len(loan_contract.blockchain.chain)}")

# ----------------------------------------------------------------
# PART F: BLOCKCHAIN ADOPTION CHALLENGES
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART F: Blockchain Adoption Challenges")
print("-"*60)

challenges = pd.DataFrame({
    'Challenge': [
        'Regulatory Uncertainty',
        'Scalability',
        'Interoperability',
        'Integration with Legacy Systems',
        'Talent and Skills',
        'Cost and ROI',
        'Data Privacy',
        'Security',
        'Standardisation'
    ],
    'Impact (1-5)': [5, 4, 4, 4, 4, 3, 4, 4, 4],
    'Likelihood (1-5)': [5, 4, 4, 5, 4, 3, 4, 3, 4],
    'Mitigation': [
        'Engage with regulators, participation in policy development',
        'Layer 2 solutions, alternative consensus mechanisms',
        'Cross-chain protocols, standardisation efforts',
        'API-first architecture, middleware solutions',
        'Training, hiring, partnerships',
        'Pilot projects, clear business cases',
        'Zero-knowledge proofs, private blockchains',
        'Security audits, best practices',
        'Industry collaboration, standards bodies'
    ]
})

print("Blockchain Adoption Challenges:")
print(challenges.to_string(index=False))

# ----------------------------------------------------------------
# PART G: BLOCKCHAIN STRATEGY FOR BANKING
# ----------------------------------------------------------------

print("\n" + "-"*60)
print("PART G: Blockchain Strategy for Banking")
print("-"*60)

strategy = {
    "1. Use Case Selection": {
        "Actions": [
            "Identify high-impact use cases (trade finance, payments, reconciliation).",
            "Prioritise based on feasibility and ROI.",
            "Start with pilot projects."
        ],
        "Priority": "High",
        "Timeline": "0-6 months"
    },
    "2. Platform Selection": {
        "Actions": [
            "Evaluate blockchain platforms (Hyperledger, Corda, Ethereum).",
            "Consider consortium vs private vs public.",
            "Assess scalability and interoperability."
        ],
        "Priority": "High",
        "Timeline": "0-6 months"
    },
    "3. Pilot Projects": {
        "Actions": [
            "Run trade finance pilot with 2-3 partners.",
            "Test reconciliation and settlement.",
            "Gather feedback and iterate."
        ],
        "Priority": "High",
        "Timeline": "6-12 months"
    },
    "4. Scale and Integration": {
        "Actions": [
            "Scale to production.",
            "Integrate with core banking systems.",
            "Establish governance and standards."
        ],
        "Priority": "Medium",
        "Timeline": "12-24 months"
    },
    "5. Innovation": {
        "Actions": [
            "Explore CBDC integration.",
            "Experiment with DeFi.",
            "Develop new blockchain-based products."
        ],
        "Priority": "Medium",
        "Timeline": "24+ months"
    }
}

for item, details in strategy.items():
    print(f"\n{item}:")
    for action in details['Actions']:
        print(f"  • {action}")
    print(f"  Priority: {details['Priority']}")
    print(f"  Timeline: {details['Timeline']}")

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

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

print("""
Blockchain in Banking Operations – Key Takeaways:

1. Blockchain addresses key challenges: manual processes, fragmented data, reconciliation, fraud.
2. Key use cases: trade finance, cross-border payments, reconciliation, settlement, smart contracts.
3. Smart contracts automate processes when conditions are met.
4. Trade finance benefits from digitised, transparent, and secure processes.
5. Reconciliation and settlement become faster and more accurate with blockchain.
6. Adoption challenges: regulation, scalability, integration, talent, cost.
7. Strategy: pilot → scale → integrate → innovate.

Recommendations:
  - Start with a pilot project for trade finance or reconciliation.
  - Choose the right blockchain platform (consortium vs private).
  - Engage with regulators early.
  - Invest in talent and training.
  - Ensure interoperability with existing systems.
  - Measure and demonstrate ROI.
""")

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