Smart Contracts: Revolutionizing Business Agreements Through Automated, Transparent, and Secure Blockchain Technology

import hashlib
import json
import numpy as np
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Any, Callable
from dataclasses import dataclass, field
from enum import Enum
import uuid

class ContractStatus(Enum):
    DRAFT = "draft"
    ACTIVE = "active"
    EXECUTED = "executed"
    BREACHED = "breached"
    TERMINATED = "terminated"

class EventType(Enum):
    CONTRACT_CREATED = "contract_created"
    CONDITION_MET = "condition_met"
    PAYMENT_EXECUTED = "payment_executed"
    MILESTONE_REACHED = "milestone_reached"
    DISPUTE_RAISED = "dispute_raised"
    CONTRACT_COMPLETED = "contract_completed"

@dataclass
class ContractCondition:
    """Represents a condition in a smart contract"""
    id: str
    description: str
    condition_type: str  # payment, delivery, time, performance
    parameters: Dict[str, Any]
    evaluation_function: Optional[Callable] = None
    is_met: bool = False
    verification_data: Dict[str, Any] = field(default_factory=dict)
    
@dataclass
class ContractAction:
    """Represents an action to be executed when conditions are met"""
    id: str
    action_type: str  # transfer, notify, update, trigger
    parameters: Dict[str, Any]
    execution_function: Optional[Callable] = None
    dependencies: List[str] = field(default_factory=list)
    executed: bool = False
    execution_result: Dict[str, Any] = field(default_factory=dict)
    
@dataclass
class ContractParty:
    """Represents a party in the smart contract"""
    id: str
    name: str
    role: str
    wallet_address: str
    reputation_score: float = 0.5
    verification_status: str = "unverified"
    contact_info: Dict[str, str] = field(default_factory=dict)
    
@dataclass
class ContractEvent:
    """Represents an event in the contract lifecycle"""
    id: str
    event_type: EventType
    timestamp: datetime
    data: Dict[str, Any]
    triggered_by: str
    block_hash: str = ""
    
class SmartContractFramework:
    """Comprehensive smart contract implementation with advanced features"""
    
    def __init__(self, contract_id: str, contract_type: str):
        self.contract_id = contract_id
        self.contract_type = contract_type
        self.status = ContractStatus.DRAFT
        self.created_at = datetime.now()
        self.parties: Dict[str, ContractParty] = {}
        self.conditions: Dict[str, ContractCondition] = {}
        self.actions: Dict[str, ContractAction] = {}
        self.events: List[ContractEvent] = []
        
        # Contract metadata
        self.metadata = {
            "version": "1.0",
            "blockchain": "ethereum",
            "legal_jurisdiction": "default",
            "dispute_resolution": "arbitration"
        }
        
        # Execution tracking
        self.execution_log: List[Dict[str, Any]] = []
        self.gas_usage = 0
        self.total_value_locked = 0.0
        
        # AI and analytics components
        self.performance_metrics = {}
        self.risk_assessment = {}
        self.optimization_suggestions = []
        
        # Initialize with contract creation event
        self._add_event(EventType.CONTRACT_CREATED, {
            "contract_id": contract_id,
            "contract_type": contract_type,
            "created_by": "system"
        })
        
    def add_party(self, party: ContractParty) -> bool:
        """Add a party to the smart contract"""
        if party.id not in self.parties:
            self.parties[party.id] = party
            print(f"Party {party.name} added to contract {self.contract_id}")
            return True
        return False
        
    def add_condition(self, condition: ContractCondition) -> bool:
        """Add a condition to the smart contract"""
        if condition.id not in self.conditions:
            self.conditions[condition.id] = condition
            print(f"Condition {condition.description} added to contract")
            return True
        return False
        
    def add_action(self, action: ContractAction) -> bool:
        """Add an action to the smart contract"""
        if action.id not in self.actions:
            self.actions[action.id] = action
            print(f"Action {action.action_type} added to contract")
            return True
        return False
        
    def activate_contract(self) -> bool:
        """Activate the smart contract for execution"""
        if self.status != ContractStatus.DRAFT:
            print("Contract can only be activated from draft status")
            return False
            
        # Validate contract completeness
        if not self._validate_contract():
            print("Contract validation failed")
            return False
            
        self.status = ContractStatus.ACTIVE
        self._add_event(EventType.CONTRACT_CREATED, {
            "status_change": "activated",
            "validation_passed": True
        })
        
        print(f"Contract {self.contract_id} activated successfully")
        return True
        
    def evaluate_conditions(self, external_data: Dict[str, Any] = None) -> Dict[str, bool]:
        """Evaluate all contract conditions"""
        if external_data is None:
            external_data = {}
            
        condition_results = {}
        newly_met_conditions = []
        
        for condition_id, condition in self.conditions.items():
            if not condition.is_met:
                # Evaluate condition
                result = self._evaluate_single_condition(condition, external_data)
                condition_results[condition_id] = result
                
                if result:
                    condition.is_met = True
                    newly_met_conditions.append(condition_id)
                    
                    # Log condition met event
                    self._add_event(EventType.CONDITION_MET, {
                        "condition_id": condition_id,
                        "condition_type": condition.condition_type,
                        "evaluation_data": external_data
                    })
            else:
                condition_results[condition_id] = True
                
        # Execute actions for newly met conditions
        if newly_met_conditions:
            self._execute_triggered_actions(newly_met_conditions)
            
        return condition_results
        
    def _evaluate_single_condition(self, condition: ContractCondition, 
                                 external_data: Dict[str, Any]) -> bool:
        """Evaluate a single condition"""
        if condition.evaluation_function:
            # Custom evaluation function
            return condition.evaluation_function(condition.parameters, external_data)
        
        # Default evaluation logic based on condition type
        if condition.condition_type == "payment":
            required_amount = condition.parameters.get("amount", 0)
            received_amount = external_data.get("payment_amount", 0)
            return received_amount >= required_amount
            
        elif condition.condition_type == "time":
            target_time = condition.parameters.get("target_datetime")
            if isinstance(target_time, str):
                target_time = datetime.fromisoformat(target_time)
            return datetime.now() >= target_time
            
        elif condition.condition_type == "delivery":
            delivery_confirmed = external_data.get("delivery_confirmed", False)
            location_verified = external_data.get("location_verified", False)
            return delivery_confirmed and location_verified
            
        elif condition.condition_type == "performance":
            required_metric = condition.parameters.get("metric_threshold", 0)
            actual_metric = external_data.get("performance_metric", 0)
            return actual_metric >= required_metric
            
        return False
        
    def _execute_triggered_actions(self, triggered_conditions: List[str]):
        """Execute actions triggered by met conditions"""
        for action_id, action in self.actions.items():
            if not action.executed and self._should_execute_action(action, triggered_conditions):
                self._execute_action(action)
                
    def _should_execute_action(self, action: ContractAction, 
                             triggered_conditions: List[str]) -> bool:
        """Determine if an action should be executed based on dependencies"""
        if not action.dependencies:
            return True  # No dependencies, always execute when triggered
            
        # Check if all dependencies are met
        for dependency in action.dependencies:
            if dependency not in triggered_conditions:
                # Check if dependency condition was already met
                if dependency not in self.conditions or not self.conditions[dependency].is_met:
                    return False
                    
        return True
        
    def _execute_action(self, action: ContractAction):
        """Execute a specific action"""
        try:
            if action.execution_function:
                # Custom execution function
                result = action.execution_function(action.parameters)
                action.execution_result = result
            else:
                # Default execution logic
                result = self._default_action_execution(action)
                action.execution_result = result
                
            action.executed = True
            
            # Log execution
            self.execution_log.append({
                "timestamp": datetime.now(),
                "action_id": action.id,
                "action_type": action.action_type,
                "result": result,
                "success": True
            })
            
            print(f"Action {action.action_type} executed successfully")
            
        except Exception as e:
            error_result = {"error": str(e), "success": False}
            action.execution_result = error_result
            
            self.execution_log.append({
                "timestamp": datetime.now(),
                "action_id": action.id,
                "action_type": action.action_type,
                "result": error_result,
                "success": False
            })
            
            print(f"Action {action.action_type} execution failed: {e}")
            
    def _default_action_execution(self, action: ContractAction) -> Dict[str, Any]:
        """Default execution logic for different action types"""
        if action.action_type == "transfer":
            from_party = action.parameters.get("from")
            to_party = action.parameters.get("to")
            amount = action.parameters.get("amount", 0)
            
            # Simulate transfer (in real implementation, this would interact with blockchain)
            return {
                "transaction_id": f"tx_{uuid.uuid4()}",
                "from": from_party,
                "to": to_party,
                "amount": amount,
                "status": "completed"
            }
            
        elif action.action_type == "notify":
            recipients = action.parameters.get("recipients", [])
            message = action.parameters.get("message", "")
            
            # Simulate notification
            return {
                "notification_id": f"notif_{uuid.uuid4()}",
                "recipients": recipients,
                "message": message,
                "sent_at": datetime.now().isoformat()
            }
            
        elif action.action_type == "update":
            field = action.parameters.get("field")
            value = action.parameters.get("value")
            
            # Update contract metadata or party information
            return {
                "update_id": f"upd_{uuid.uuid4()}",
                "field_updated": field,
                "new_value": value,
                "updated_at": datetime.now().isoformat()
            }
            
        return {"action_type": action.action_type, "executed": True}
        
    def check_contract_completion(self) -> bool:
        """Check if contract is fully completed"""
        if self.status != ContractStatus.ACTIVE:
            return False
            
        # Check if all conditions are met
        all_conditions_met = all(condition.is_met for condition in self.conditions.values())
        
        # Check if all actions are executed
        all_actions_executed = all(action.executed for action in self.actions.values())
        
        if all_conditions_met and all_actions_executed:
            self.status = ContractStatus.EXECUTED
            self._add_event(EventType.CONTRACT_COMPLETED, {
                "completion_time": datetime.now().isoformat(),
                "all_conditions_met": True,
                "all_actions_executed": True
            })
            print(f"Contract {self.contract_id} completed successfully")
            return True
            
        return False
        
    def generate_performance_report(self) -> Dict[str, Any]:
        """Generate comprehensive performance report"""
        total_conditions = len(self.conditions)
        met_conditions = len([c for c in self.conditions.values() if c.is_met])
        
        total_actions = len(self.actions)
        executed_actions = len([a for a in self.actions.values() if a.executed])
        
        successful_executions = len([log for log in self.execution_log if log["success"]])
        failed_executions = len(self.execution_log) - successful_executions
        
        report = {
            "contract_id": self.contract_id,
            "contract_type": self.contract_type,
            "status": self.status.value,
            "created_at": self.created_at.isoformat(),
            "performance_metrics": {
                "conditions_completion_rate": (met_conditions / total_conditions * 100) if total_conditions > 0 else 0,
                "actions_execution_rate": (executed_actions / total_actions * 100) if total_actions > 0 else 0,
                "execution_success_rate": (successful_executions / len(self.execution_log) * 100) if self.execution_log else 0
            },
            "statistics": {
                "total_conditions": total_conditions,
                "met_conditions": met_conditions,
                "total_actions": total_actions,
                "executed_actions": executed_actions,
                "total_events": len(self.events),
                "execution_attempts": len(self.execution_log),
                "successful_executions": successful_executions,
                "failed_executions": failed_executions
            },
            "parties_involved": len(self.parties),
            "contract_duration": str(datetime.now() - self.created_at),
            "gas_usage_estimated": self.gas_usage,
            "total_value_locked": self.total_value_locked
        }
        
        return report
        
    def _validate_contract(self) -> bool:
        """Validate contract before activation"""
        # Check basic requirements
        if len(self.parties) < 2:
            print("Contract requires at least 2 parties")
            return False
            
        if len(self.conditions) == 0:
            print("Contract requires at least 1 condition")
            return False
            
        if len(self.actions) == 0:
            print("Contract requires at least 1 action")
            return False
            
        # Validate action dependencies
        for action in self.actions.values():
            for dependency in action.dependencies:
                if dependency not in self.conditions:
                    print(f"Action {action.id} has invalid dependency {dependency}")
                    return False
                    
        return True
        
    def _add_event(self, event_type: EventType, data: Dict[str, Any]):
        """Add event to contract history"""
        event = ContractEvent(
            id=f"evt_{uuid.uuid4()}",
            event_type=event_type,
            timestamp=datetime.now(),
            data=data,
            triggered_by=data.get("triggered_by", "system")
        )
        self.events.append(event)
        
    def get_contract_state(self) -> Dict[str, Any]:
        """Get current contract state"""
        return {
            "contract_id": self.contract_id,
            "status": self.status.value,
            "parties": {pid: {"name": p.name, "role": p.role} for pid, p in self.parties.items()},
            "conditions": {cid: {"description": c.description, "met": c.is_met} for cid, c in self.conditions.items()},
            "actions": {aid: {"type": a.action_type, "executed": a.executed} for aid, a in self.actions.items()},
            "recent_events": [{
                "type": e.event_type.value,
                "timestamp": e.timestamp.isoformat(),
                "data": e.data
            } for e in self.events[-5:]],  # Last 5 events
            "performance_summary": self.generate_performance_report()["performance_metrics"]
        }

# Example usage and demonstration
def create_supply_chain_contract():
    """Create a comprehensive supply chain smart contract"""
    contract = SmartContractFramework("SC_SUPPLY_001", "supply_chain")
    
    # Add parties
    supplier = ContractParty(
        id="supplier_001",
        name="Global Supplier Inc.",
        role="supplier",
        wallet_address="0x1234...supplier",
        reputation_score=0.85
    )
    
    buyer = ContractParty(
        id="buyer_001", 
        name="Retail Chain Corp.",
        role="buyer",
        wallet_address="0x5678...buyer",
        reputation_score=0.90
    )
    
    logistics = ContractParty(
        id="logistics_001",
        name="Fast Delivery LLC",
        role="logistics",
        wallet_address="0x9abc...logistics",
        reputation_score=0.75
    )
    
    contract.add_party(supplier)
    contract.add_party(buyer)
    contract.add_party(logistics)
    
    # Add conditions
    payment_condition = ContractCondition(
        id="payment_received",
        description="Initial payment received from buyer",
        condition_type="payment",
        parameters={"amount": 50000, "currency": "USD"}
    )
    
    production_condition = ContractCondition(
        id="production_complete",
        description="Goods production completed by supplier",
        condition_type="performance",
        parameters={"metric_threshold": 100, "metric_type": "completion_percentage"}
    )
    
    shipping_condition = ContractCondition(
        id="goods_shipped",
        description="Goods shipped by logistics provider",
        condition_type="delivery",
        parameters={"shipping_confirmed": True, "tracking_number": "required"}
    )
    
    delivery_condition = ContractCondition(
        id="goods_delivered",
        description="Goods delivered to buyer location",
        condition_type="delivery",
        parameters={"delivery_confirmed": True, "location_verified": True}
    )
    
    contract.add_condition(payment_condition)
    contract.add_condition(production_condition)
    contract.add_condition(shipping_condition)
    contract.add_condition(delivery_condition)
    
    # Add actions
    start_production_action = ContractAction(
        id="start_production",
        action_type="notify",
        parameters={
            "recipients": ["supplier_001"],
            "message": "Payment received. Begin production immediately."
        },
        dependencies=["payment_received"]
    )
    
    ship_goods_action = ContractAction(
        id="ship_goods",
        action_type="notify",
        parameters={
            "recipients": ["logistics_001"],
            "message": "Goods ready for pickup. Initiate shipping."
        },
        dependencies=["production_complete"]
    )
    
    release_payment_action = ContractAction(
        id="release_final_payment",
        action_type="transfer",
        parameters={
            "from": "buyer_001",
            "to": "supplier_001",
            "amount": 45000,
            "currency": "USD"
        },
        dependencies=["goods_delivered"]
    )
    
    pay_logistics_action = ContractAction(
        id="pay_logistics",
        action_type="transfer",
        parameters={
            "from": "buyer_001",
            "to": "logistics_001",
            "amount": 5000,
            "currency": "USD"
        },
        dependencies=["goods_delivered"]
    )
    
    contract.add_action(start_production_action)
    contract.add_action(ship_goods_action)
    contract.add_action(release_payment_action)
    contract.add_action(pay_logistics_action)
    
    return contract

def run_smart_contract_demo():
    print("=== Smart Contract Framework Demo ===")
    
    # Create supply chain contract
    contract = create_supply_chain_contract()
    print(f"Created contract: {contract.contract_id}")
    
    # Activate contract
    if contract.activate_contract():
        print("Contract activated successfully")
    
    # Simulate contract execution over time
    execution_scenarios = [
        {
            "description": "Initial payment received",
            "data": {"payment_amount": 50000, "currency": "USD"}
        },
        {
            "description": "Production completed", 
            "data": {"performance_metric": 100, "quality_check": "passed"}
        },
        {
            "description": "Goods shipped",
            "data": {"delivery_confirmed": True, "tracking_number": "TRK123456"}
        },
        {
            "description": "Goods delivered",
            "data": {"delivery_confirmed": True, "location_verified": True, "signature": "received"}
        }
    ]
    
    print("\nExecuting contract scenarios:")
    for i, scenario in enumerate(execution_scenarios, 1):
        print(f"\n--- Scenario {i}: {scenario['description']} ---")
        
        # Evaluate conditions with new data
        results = contract.evaluate_conditions(scenario['data'])
        
        print(f"Conditions evaluation results: {results}")
        print(f"Contract status: {contract.status.value}")
        
        # Check if contract is complete
        if contract.check_contract_completion():
            print("🎉 Contract completed successfully!")
            break
    
    # Generate final report
    print("\n=== Final Performance Report ===")
    report = contract.generate_performance_report()
    
    print(f"Contract Status: {report['status']}")
    print(f"Conditions Completion: {report['performance_metrics']['conditions_completion_rate']:.1f}%")
    print(f"Actions Execution: {report['performance_metrics']['actions_execution_rate']:.1f}%")
    print(f"Execution Success Rate: {report['performance_metrics']['execution_success_rate']:.1f}%")
    print(f"Total Events: {report['statistics']['total_events']}")
    print(f"Contract Duration: {report['contract_duration']}")
    
    # Display contract state
    print("\n=== Final Contract State ===")
    state = contract.get_contract_state()
    print(f"Parties: {len(state['parties'])}")
    print(f"Conditions Met: {sum(1 for c in state['conditions'].values() if c['met'])}/{len(state['conditions'])}")
    print(f"Actions Executed: {sum(1 for a in state['actions'].values() if a['executed'])}/{len(state['actions'])}")
    
    return contract

# Run demonstration
if __name__ == "__main__":
    demo_contract = run_smart_contract_demo()