# ===================================================================
# MODULE 10, LESSON 2: THE SELF-DRIVING BANK – AI AGENTS
# ===================================================================

import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import json
import warnings
warnings.filterwarnings('ignore')

print("="*70)
print("PROTOTYPING A FINANCIAL AI AGENT")
print("="*70)

# ----------------------------------------------------------------
# PART A: MOCK BANKING CORE (SIMULATED APIS)
# ----------------------------------------------------------------
print("\n" + "-"*60)
print("PART A: Simulated Banking Core APIs")
print("-"*60)

class BankingCore:
    """Mimics a legacy banking system with REST APIs."""
    def __init__(self):
        self.accounts = {
            '12345': {'balance': 1500.00, 'type': 'Checking', 'overdraft_limit': 200},
            '67890': {'balance': 5000.00, 'type': 'Savings', 'overdraft_limit': 0}
        }
        self.transactions = []
        self.loan_rates = 0.049  # 4.9% interest

    def get_balance(self, account_id):
        return self.accounts.get(account_id, {}).get('balance', 0.0)

    def transfer(self, from_acc, to_acc, amount):
        if self.get_balance(from_acc) >= amount:
            self.accounts[from_acc]['balance'] -= amount
            self.accounts[to_acc]['balance'] += amount
            log = f"TRANSFER: ${amount} from {from_acc} to {to_acc}"
            self.transactions.append(log)
            return {"status": "success", "message": log}
        else:
            return {"status": "failed", "message": "Insufficient funds"}

    def check_loan_eligibility(self, account_id, credit_score):
        if credit_score > 700:
            return {"eligible": True, "max_amount": 25000, "rate": self.loan_rates}
        else:
            return {"eligible": False, "max_amount": 0, "rate": 0}

    def get_transaction_summary(self, account_id, days=30):
        # Mock summary
        return {
            'account': account_id,
            'debits': np.random.randint(100, 500, 5).tolist(),
            'credits': np.random.randint(300, 800, 3).tolist()
        }

# Initialize core
core = BankingCore()
print("Banking Core Initialized.")
print(f"Checking Balance: ${core.get_balance('12345')}")
print(f"Savings Balance: ${core.get_balance('67890')}")

# ----------------------------------------------------------------
# PART B: THE AI AGENT "BRAIN" (LOGIC LAYER)
# ----------------------------------------------------------------
print("\n" + "-"*60)
print("PART B: AI Agent Orchestration Logic")
print("-"*60)

class FinancialAgent:
    """
    This agent simulates an LLM orchestrator.
    It uses a simple rule-based "thinking" layer to decide which tools (APIs) to call.
    """
    def __init__(self, user_id, core_banking):
        self.user_id = user_id
        self.core = core_banking
        self.memory = []  # Short term memory for this session
        print(f"Agent initialized for User: {user_id}")

    def think_and_act(self, user_prompt):
        """
        The main loop: Simulates the LLM processing prompt -> Plan -> Act -> Observe.
        """
        print(f"\n>>> User Input: {user_prompt}")
        self.memory.append({"role": "user", "content": user_prompt})
        
        response = "I understand you want help with your finances. "
        
        # 1. PERCEIVE & PLAN (Intent Recognition)
        prompt_lower = user_prompt.lower()
        
        # 2. TOOL EXECUTION (The "Actions")
        if "balance" in prompt_lower:
            # Act: Call Get Balance Tool
            balance = self.core.get_balance('12345')
            response += f"Your current checking balance is ${balance:.2f}. "
            
            # Proactive check: Savings balance
            if "savings" in prompt_lower:
                sav_balance = self.core.get_balance('67890')
                response += f"Your savings balance is ${sav_balance:.2f}. "
                
        elif "transfer" in prompt_lower:
            # Parse amount (simplified)
            try:
                # Simulating extracting amount via LLM
                amount = float(prompt_lower.split('$')[1].split()[0])
                # Act: Call Transfer Tool
                result = self.core.transfer('12345', '67890', amount)
                response += f"Transfer result: {result['message']}. "
            except:
                response += "I could not parse the transfer amount. Please specify like 'transfer $200'."

        elif "loan" in prompt_lower:
            # Simulating risk assessment
            response += "Checking eligibility based on your profile... "
            # Act: Call Loan Tool (Simulating credit check from memory)
            result = self.core.check_loan_eligibility('12345', 720)
            if result['eligible']:
                response += f"Congratulations! You are eligible for up to ${result['max_amount']} at {result['rate']*100}% APR. "
            else:
                response += "Unfortunately, you are not eligible at this time."

        elif "optimize" in prompt_lower or "cash" in prompt_lower:
            # 3. ADVANCED REASONING: Self-driving feature
            checking_bal = self.core.get_balance('12345')
            savings_bal = self.core.get_balance('67890')
            
            if checking_bal < 300 and savings_bal > 1000:
                # Act: Auto-transfer to avoid overdraft
                transfer_amt = min(400, savings_bal - 500)  # Keep $500 buffer
                self.core.transfer('67890', '12345', transfer_amt)
                response += f"Proactive action taken: Transferred ${transfer_amt:.2f} from Savings to Checking to optimize your cash position. "
            else:
                response += f"Your cash position looks healthy. Checking: ${checking_bal:.2f}, Savings: ${savings_bal:.2f}. "
        
        else:
            response += "I can check balances, transfer funds, or run loan eligibility. How can I assist?"

        # 4. OBSERVE & RECORD
        self.memory.append({"role": "agent", "content": response})
        print(f">>> Agent: {response}")
        return response

# ----------------------------------------------------------------
# PART C: SIMULATING USER INTERACTIONS
# ----------------------------------------------------------------
print("\n" + "-"*60)
print("PART C: Simulating Agentic Interactions")
print("-"*60)

# Instantiate the agent
agent = FinancialAgent(user_id="user_001", core_banking=core)

# Simulate a conversation
agent.think_and_act("What is my current balance?")
agent.think_and_act("Can I get a loan?")
agent.think_and_act("transfer $100 to savings")
agent.think_and_act("optimize my cash")  # Triggers the self-driving "auto-transfer" logic