import numpy as np
import hashlib
from typing import Dict, List, Tuple, Optional
from dataclasses import dataclass
from collections import defaultdict
import time

@dataclass
class Transaction:
    sender: str
    recipient: str
    amount: float
    token: str
    gas_price: float
    data: dict = None
    timestamp: float = 0
    
    def hash(self):
        tx_string = f"{self.sender}{self.recipient}{self.amount}{self.token}{self.timestamp}"
        return hashlib.sha256(tx_string.encode()).hexdigest()

class SimpleAMM:
    """Constant product AMM implementation (Uniswap v2 style)."""
    
    def __init__(self, token_a_reserve: float, token_b_reserve: float, fee: float = 0.003):
        self.token_a = token_a_reserve
        self.token_b = token_b_reserve
        self.fee = fee
        self.k = token_a_reserve * token_b_reserve
        
    def get_price(self) -> float:
        return self.token_b / self.token_a
    
    def swap(self, amount_in: float, token_in: str) -> float:
        if token_in == 'A':
            reserve_in, reserve_out = self.token_a, self.token_b
        else:
            reserve_in, reserve_out = self.token_b, self.token_a
        
        amount_in_with_fee = amount_in * (1 - self.fee)
        amount_out = (reserve_out * amount_in_with_fee) / (reserve_in + amount_in_with_fee)
        
        if token_in == 'A':
            self.token_a += amount_in
            self.token_b -= amount_out
        else:
            self.token_b += amount_in
            self.token_a -= amount_out
        
        self.k = self.token_a * self.token_b
        
        return amount_out
    
    def price_impact(self, amount_in: float, token_in: str) -> float:
        initial_price = self.get_price()
        
        if token_in == 'A':
            new_price = self.token_b / (self.token_a + amount_in)
        else:
            new_price = (self.token_b + amount_in) / self.token_a
        
        return abs(new_price - initial_price) / initial_price
    
    def add_liquidity(self, amount_a: float, amount_b: float) -> float:
        total_liquidity = np.sqrt(self.token_a * self.token_b)
        
        if amount_a / self.token_a <= amount_b / self.token_b:
            amount_b = amount_a * self.token_b / self.token_a
        else:
            amount_a = amount_b * self.token_a / self.token_b
        
        self.token_a += amount_a
        self.token_b += amount_b
        self.k = self.token_a * self.token_b
        
        new_liquidity = np.sqrt(self.token_a * self.token_b)
        return new_liquidity - total_liquidity

class ConcentratedLiquidityPool:
    """Uniswap v3 style concentrated liquidity."""
    
    def __init__(self, price_a: float, price_b: float, fee: float = 0.003):
        self.price_a = price_a
        self.price_b = price_b
        self.fee = fee
        self.liquidity = 0
        self.sqrt_price = np.sqrt(price_a)
        
    def get_amount_out(self, amount_in: float, token_in: str) -> float:
        sqrt_price_new = self.sqrt_price + amount_in / self.liquidity if token_in == 'A' else self.sqrt_price - amount_in / self.liquidity
        
        if token_in == 'A':
            amount_out = self.liquidity * (self.sqrt_price - sqrt_price_new)
        else:
            amount_out = self.liquidity * (1/sqrt_price_new - 1/self.sqrt_price)
        
        self.sqrt_price = sqrt_price_new
        return amount_out * (1 - self.fee)

class LendingProtocol:
    """Aave/Compound style lending protocol."""
    
    def __init__(self):
        self.deposits: Dict[str, float] = defaultdict(float)
        self.borrows: Dict[str, float] = defaultdict(float)
        self.reserves: Dict[str, float] = defaultdict(float)
        self.collateral_factor: Dict[str, float] = {
            'ETH': 0.75, 'WBTC': 0.70, 'USDC': 0.85, 'DAI': 0.85
        }
        self.liquidation_threshold: Dict[str, float] = {
            'ETH': 0.80, 'WBTC': 0.75, 'USDC': 0.90, 'DAI': 0.90
        }
        self.base_rate = 0.02
        self.slope = 0.10
        self.optimal_utilization = 0.80
        
    def deposit(self, user: str, token: str, amount: float):
        self.deposits[f"{user}_{token}"] += amount
        
    def borrow(self, user: str, token: str, amount: float, collateral_token: str, collateral_amount: float):
        collateral_value = collateral_amount * self.get_price(collateral_token)
        borrow_value = amount * self.get_price(token)
        
        if borrow_value > collateral_value * self.collateral_factor[collateral_token]:
            raise ValueError("Insufficient collateral")
        
        self.borrows[f"{user}_{token}"] += amount
        
    def get_utilization(self, token: str) -> float:
        total_deposits = sum(v for k, v in self.deposits.items() if k.endswith(f"_{token}"))
        total_borrows = sum(v for k, v in self.borrows.items() if k.endswith(f"_{token}"))
        
        if total_deposits == 0:
            return 0
        return total_borrows / total_deposits
    
    def get_borrow_rate(self, token: str) -> float:
        utilization = self.get_utilization(token)
        
        if utilization <= self.optimal_utilization:
            return self.base_rate + (self.slope * utilization / self.optimal_utilization)
        else:
            excess_utilization = utilization - self.optimal_utilization
            return self.base_rate + self.slope + (excess_utilization * 3.0)
    
    def get_supply_rate(self, token: str) -> float:
        borrow_rate = self.get_borrow_rate(token)
        utilization = self.get_utilization(token)
        return borrow_rate * utilization * 0.9
    
    def check_liquidation(self, user: str, collateral_token: str, borrow_token: str) -> bool:
        collateral_amount = self.deposits.get(f"{user}_{collateral_token}", 0)
        borrow_amount = self.borrows.get(f"{user}_{borrow_token}", 0)
        
        collateral_value = collateral_amount * self.get_price(collateral_token)
        borrow_value = borrow_amount * self.get_price(borrow_token)
        
        if collateral_value == 0:
            return False
        
        health_factor = (collateral_value * self.liquidation_threshold[collateral_token]) / borrow_value
        return health_factor < 1.0
    
    def get_price(self, token: str) -> float:
        prices = {'ETH': 2000, 'WBTC': 30000, 'USDC': 1, 'DAI': 1}
        return prices.get(token, 1)

class YieldAggregator:
    """Yearn-style yield aggregator."""
    
    def __init__(self):
        self.vaults: Dict[str, dict] = {}
        
    def create_vault(self, name: str, strategy: str, base_apy: float):
        self.vaults[name] = {
            'strategy': strategy,
            'base_apy': base_apy,
            'tvl': 0,
            'total_shares': 0,
            'share_price': 1.0,
            'performance_fee': 0.20,
            'management_fee': 0.02
        }
        
    def deposit(self, vault_name: str, amount: float) -> float:
        vault = self.vaults[vault_name]
        
        if vault['total_shares'] == 0:
            shares = amount
        else:
            shares = amount / vault['share_price']
        
        vault['total_shares'] += shares
        vault['tvl'] += amount
        
        return shares
    
    def harvest(self, vault_name: str):
        vault = self.vaults[vault_name]
        
        daily_yield = vault['tvl'] * vault['base_apy'] / 365
        performance_fee = daily_yield * vault['performance_fee']
        net_yield = daily_yield - performance_fee
        
        vault['tvl'] += net_yield
        vault['share_price'] = vault['tvl'] / vault['total_shares']
        
    def withdraw(self, vault_name: str, shares: float) -> float:
        vault = self.vaults[vault_name]
        
        amount = shares * vault['share_price']
        vault['total_shares'] -= shares
        vault['tvl'] -= amount
        
        return amount

class SimpleBlockchain:
    """Simplified blockchain for demonstration."""
    
    def __init__(self):
        self.chain = []
        self.pending_transactions = []
        self.balances: Dict[str, float] = defaultdict(float)
        self.gas_price = 20
        
    def add_transaction(self, tx: Transaction):
        self.pending_transactions.append(tx)
        
    def mine_block(self, miner: str) -> dict:
        block = {
            'index': len(self.chain),
            'timestamp': time.time(),
            'transactions': self.pending_transactions[:100],
            'miner': miner,
            'gas_used': len(self.pending_transactions[:100]) * 21000
        }
        
        for tx in block['transactions']:
            self.balances[tx.sender] -= tx.amount + tx.gas_price * 21000 / 1e9
            self.balances[tx.recipient] += tx.amount
        
        self.chain.append(block)
        self.pending_transactions = self.pending_transactions[100:]
        
        return block

def calculate_impermanent_loss(price_ratio: float) -> float:
    """Calculate impermanent loss for constant product AMM."""
    return 2 * np.sqrt(price_ratio) / (1 + price_ratio) - 1

def simulate_amm_trade(initial_a: float, initial_b: float, trade_amount: float, 
                       num_trades: int = 100) -> List[float]:
    """Simulate multiple trades through AMM and track price."""
    amm = SimpleAMM(initial_a, initial_b)
    prices = [amm.get_price()]
    
    for _ in range(num_trades):
        if np.random.random() > 0.5:
            amm.swap(trade_amount, 'A')
        else:
            amm.swap(trade_amount, 'B')
        prices.append(amm.get_price())
    
    return prices

# Example usage
if __name__ == "__main__":
    amm = SimpleAMM(1000, 2000000)
    print(f"Initial ETH/USDC Price: {amm.get_price():.2f}")
    
    trade_amount = 10
    tokens_out = amm.swap(trade_amount, 'A')
    print(f"Swapped {trade_amount} ETH for {tokens_out:.2f} USDC")
    print(f"New Price: {amm.get_price():.2f}")
    print(f"Price Impact: {amm.price_impact(trade_amount, 'A')*100:.4f}%")
    
    il = calculate_impermanent_loss(2.0)
    print(f"\nImpermanent Loss at 2x price change: {il*100:.2f}%")
    
    prices = simulate_amm_trade(1000, 2000000, 5, num_trades=50)
    print(f"\nPrice volatility over 50 trades: {np.std(prices):.4f}")
    
    lending = LendingProtocol()
    lending.deposit('alice', 'ETH', 10)
    lending.deposit('bob', 'USDC', 50000)
    lending.borrow('alice', 'USDC', 10000, 'ETH', 10)
    
    print(f"\nETH Utilization: {lending.get_utilization('ETH')*100:.1f}%")
    print(f"USDC Utilization: {lending.get_utilization('USDC')*100:.1f}%")
    print(f"ETH Borrow Rate: {lending.get_borrow_rate('ETH')*100:.2f}%")
    print(f"USDC Supply Rate: {lending.get_supply_rate('USDC')*100:.2f}%")
    
    print(f"\nAlice liquidatable? {lending.check_liquidation('alice', 'ETH', 'USDC')}")
    
    yield_agg = YieldAggregator()
    yield_agg.create_vault('ETH-USDC LP', 'uniswap_v3', 0.15)
    shares = yield_agg.deposit('ETH-USDC LP', 10000)
    print(f"\nDeposited $10,000, received {shares:.2f} shares")
    
    for _ in range(30):
        yield_agg.harvest('ETH-USDC LP')
    
    print(f"After 30 days: TVL = ${yield_agg.vaults['ETH-USDC LP']['tvl']:.2f}")
    print(f"Share price: ${yield_agg.vaults['ETH-USDC LP']['share_price']:.4f}")