import numpy as np
import hashlib
import time
from typing import Dict, List, Optional
from dataclasses import dataclass, field
from collections import defaultdict
from enum import Enum
import uuid

class AccountType(Enum):
    CHECKING = "checking"
    SAVINGS = "savings"
    CREDIT = "credit"

@dataclass
class Transaction:
    transaction_id: str
    account_id: str
    amount: float
    transaction_type: str
    category: str
    merchant: str
    timestamp: float
    balance_after: float

class NeoBankLedger:
    """Double-entry ledger for neo banking."""
    
    def __init__(self):
        self.accounts: Dict[str, dict] = {}
        self.entries: List[dict] = []
        self.balances: Dict[str, float] = defaultdict(float)
        
    def create_account(self, account_id: str, account_type: AccountType,
                      currency: str = 'USD') -> dict:
        account = {
            'account_id': account_id,
            'type': account_type,
            'currency': currency,
            'created_at': time.time(),
            'status': 'active',
            'balance': 0.0
        }
        self.accounts[account_id] = account
        return account
    
    def debit(self, account_id: str, amount: float, description: str) -> bool:
        if account_id not in self.accounts:
            return False
        
        if self.balances[account_id] < amount:
            return False
        
        entry = {
            'entry_id': str(uuid.uuid4()),
            'account_id': account_id,
            'debit': amount,
            'credit': 0,
            'balance': self.balances[account_id] - amount,
            'description': description,
            'timestamp': time.time()
        }
        
        self.entries.append(entry)
        self.balances[account_id] -= amount
        self.accounts[account_id]['balance'] = self.balances[account_id]
        
        return True
    
    def credit(self, account_id: str, amount: float, description: str) -> bool:
        if account_id not in self.accounts:
            return False
        
        entry = {
            'entry_id': str(uuid.uuid4()),
            'account_id': account_id,
            'debit': 0,
            'credit': amount,
            'balance': self.balances[account_id] + amount,
            'description': description,
            'timestamp': time.time()
        }
        
        self.entries.append(entry)
        self.balances[account_id] += amount
        self.accounts[account_id]['balance'] = self.balances[account_id]
        
        return True
    
    def transfer(self, from_account: str, to_account: str, 
                amount: float, description: str) -> bool:
        if not self.debit(from_account, amount, f"Transfer out: {description}"):
            return False
        
        if not self.credit(to_account, amount, f"Transfer in: {description}"):
            self.credit(from_account, amount, "Reverse failed transfer")
            return False
        
        return True
    
    def get_balance(self, account_id: str) -> float:
        return self.balances.get(account_id, 0)
    
    def get_statement(self, account_id: str, limit: int = 100) -> List[dict]:
        return [e for e in self.entries if e['account_id'] == account_id][-limit:]

class CardService:
    """Virtual and physical card management."""
    
    def __init__(self):
        self.cards: Dict[str, dict] = {}
        
    def issue_virtual_card(self, account_id: str, spending_limit: float = 5000) -> dict:
        card_id = f"VC{uuid.uuid4().hex[:12].upper()}"
        
        card = {
            'card_id': card_id,
            'account_id': account_id,
            'type': 'virtual',
            'status': 'active',
            'spending_limit': spending_limit,
            'spent': 0,
            'created_at': time.time()
        }
        
        self.cards[card_id] = card
        return card
    
    def authorize_transaction(self, card_id: str, amount: float, 
                             merchant_category: str) -> dict:
        if card_id not in self.cards:
            return {'approved': False, 'reason': 'card_not_found'}
        
        card = self.cards[card_id]
        
        if card['status'] != 'active':
            return {'approved': False, 'reason': 'card_inactive'}
        
        if card['spent'] + amount > card['spending_limit']:
            return {'approved': False, 'reason': 'limit_exceeded'}
        
        card['spent'] += amount
        
        return {
            'approved': True,
            'authorization_code': uuid.uuid4().hex[:6].upper(),
            'remaining_limit': card['spending_limit'] - card['spent']
        }
    
    def block_card(self, card_id: str) -> bool:
        if card_id in self.cards:
            self.cards[card_id]['status'] = 'blocked'
            return True
        return False

class SavingsAccount:
    """High-yield savings account with interest accrual."""
    
    def __init__(self, account_id: str, apy: float = 0.04):
        self.account_id = account_id
        self.apy = apy
        self.balance = 0
        self.interest_earned = 0
        self.last_accrual = time.time()
        
    def deposit(self, amount: float):
        self.balance += amount
    
    def withdraw(self, amount: float) -> bool:
        if amount > self.balance:
            return False
        self.balance -= amount
        return True
    
    def accrue_interest(self):
        days_elapsed = (time.time() - self.last_accrual) / 86400
        
        daily_rate = self.apy / 365
        interest = self.balance * daily_rate * days_elapsed
        
        self.interest_earned += interest
        self.balance += interest
        self.last_accrual = time.time()
        
        return interest

class SpendingAnalytics:
    """AI-powered spending insights and budgeting."""
    
    def __init__(self):
        self.transactions: Dict[str, List[dict]] = defaultdict(list)
        self.budgets: Dict[str, Dict[str, float]] = {}
        
    def record_transaction(self, account_id: str, transaction: dict):
        self.transactions[account_id].append(transaction)
    
    def set_budget(self, account_id: str, category: str, monthly_limit: float):
        if account_id not in self.budgets:
            self.budgets[account_id] = {}
        self.budgets[account_id][category] = monthly_limit
    
    def get_spending_summary(self, account_id: str, days: int = 30) -> dict:
        cutoff = time.time() - days * 86400
        recent = [t for t in self.transactions[account_id] if t['timestamp'] > cutoff]
        
        by_category = defaultdict(float)
        for t in recent:
            by_category[t['category']] += abs(t['amount'])
        
        total_spent = sum(by_category.values())
        
        insights = []
        budget = self.budgets.get(account_id, {})
        for category, spent in by_category.items():
            if category in budget:
                pct = spent / budget[category] * 100
                if pct > 90:
                    insights.append(f"Warning: {category} at {pct:.0f}% of budget")
        
        return {
            'total_spent': total_spent,
            'by_category': dict(by_category),
            'insights': insights,
            'transaction_count': len(recent)
        }
    
    def detect_subscription(self, account_id: str) -> List[dict]:
        transactions = self.transactions[account_id]
        
        merchant_counts = defaultdict(int)
        for t in transactions:
            merchant_counts[t['merchant']] += 1
        
        subscriptions = []
        for merchant, count in merchant_counts.items():
            if count >= 3:
                amounts = [abs(t['amount']) for t in transactions if t['merchant'] == merchant]
                avg_amount = np.mean(amounts)
                
                subscriptions.append({
                    'merchant': merchant,
                    'frequency': f"~{count/3:.1f}x/month",
                    'avg_amount': avg_amount,
                    'annual_cost': avg_amount * 12
                })
        
        return sorted(subscriptions, key=lambda x: x['annual_cost'], reverse=True)

class NeoBankPlatform:
    """Complete neo banking platform."""
    
    def __init__(self):
        self.ledger = NeoBankLedger()
        self.card_service = CardService()
        self.analytics = SpendingAnalytics()
        self.savings_accounts: Dict[str, SavingsAccount] = {}
        
    def onboard_customer(self, customer_id: str) -> dict:
        checking_id = f"CHK_{customer_id}"
        savings_id = f"SAV_{customer_id}"
        
        self.ledger.create_account(checking_id, AccountType.CHECKING)
        self.ledger.create_account(savings_id, AccountType.SAVINGS)
        
        self.savings_accounts[savings_id] = SavingsAccount(savings_id)
        
        virtual_card = self.card_service.issue_virtual_card(checking_id)
        
        return {
            'checking_account': checking_id,
            'savings_account': savings_id,
            'virtual_card': virtual_card['card_id'],
            'status': 'active'
        }
    
    def process_card_payment(self, card_id: str, amount: float, 
                            merchant: str, category: str) -> dict:
        auth_result = self.card_service.authorize_transaction(card_id, amount, category)
        
        if not auth_result['approved']:
            return auth_result
        
        card = self.card_service.cards[card_id]
        account_id = card['account_id']
        
        self.ledger.debit(account_id, amount, f"Card payment at {merchant}")
        
        transaction = {
            'amount': -amount,
            'category': category,
            'merchant': merchant,
            'timestamp': time.time()
        }
        self.analytics.record_transaction(account_id, transaction)
        
        return auth_result
    
    def get_account_dashboard(self, account_id: str) -> dict:
        balance = self.ledger.get_balance(account_id)
        spending = self.analytics.get_spending_summary(account_id)
        subscriptions = self.analytics.detect_subscription(account_id)
        
        return {
            'balance': balance,
            'spending_summary': spending,
            'subscriptions': subscriptions,
            'statements': self.ledger.get_statement(account_id, limit=10)
        }

# Example usage
if __name__ == "__main__":
    platform = NeoBankPlatform()
    
    customer = platform.onboard_customer("CUST001")
    print(f"Customer onboarded: {customer['checking_account']}")
    print(f"Virtual Card: {customer['virtual_card']}")
    
    platform.ledger.credit(customer['checking_account'], 5000, "Initial deposit")
    print(f"Balance: ${platform.ledger.get_balance(customer['checking_account']):,.2f}")
    
    payments = [
        (customer['virtual_card'], 45.99, "Whole Foods", "grocery"),
        (customer['virtual_card'], 12.50, "Starbucks", "restaurant"),
        (customer['virtual_card'], 89.99, "Amazon", "shopping"),
        (customer['virtual_card'], 15.00, "Netflix", "entertainment"),
    ]
    
    print("\nProcessing Payments:")
    for card_id, amount, merchant, category in payments:
        result = platform.process_card_payment(card_id, amount, merchant, category)
        status = "APPROVED" if result.get('approved') else "DECLINED"
        print(f"  ${amount:.2f} at {merchant}: {status}")
    
    savings = platform.savings_accounts[customer['savings_account']]
    savings.deposit(1000)
    interest = savings.accrue_interest()
    print(f"\nSavings Balance: ${savings.balance:,.2f}")
    print(f"Interest Accrued: ${interest:.6f}")
    
    dashboard = platform.get_account_dashboard(customer['checking_account'])
    print(f"\nDashboard:")
    print(f"  Balance: ${dashboard['balance']:,.2f}")
    print(f"  Transactions: {dashboard['spending_summary']['transaction_count']}")
    
    subscriptions = dashboard['subscriptions']
    if subscriptions:
        print(f"  Detected Subscriptions:")
        for sub in subscriptions[:3]:
            print(f"    {sub['merchant']}: {sub['frequency']} @ ${sub['avg_amount']:.2f}")