import logging
import threading
import time
from typing import Union

# 日志設置
logging.basicConfig(level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s")

class BankAccount:
    """ A secure bank account implementing defensive programming practices"""
    
    def __init__(self, account_number: str, initial_balance: Union[int, float] = 0):
        assert isinstance(account_number, str), "Account number must be a string"
        assert isinstance(initial_balance, (int, float)) and initial_balance >= 0, "Initial balance must be a positive number"
        
        self.account_number = account_number
        self.balance = initial_balance
        self.lock = threading.Lock()  # Prevents race conditions in multithreading
        logging.info(f"Account {self.account_number} created with balance ${self.balance}")

    def validate_amount(self, amount: Union[int, float]):
        """ Validates deposit/withdrawal amounts"""
        ifnot isinstance(amount, (int, float)) or amount <= 0:
            raise ValueError("Amount must be a positive number")
    
    def deposit(self, amount: Union[int, float]):
        """ Securely deposits money into the account"""
        self.validate_amount(amount)
        with self.lock:
            # 更新余額的原子操作
            self.balance += amount
            logging.info(f"Deposited ${amount} into account {self.account_number}. New balance: ${self.balance}")

    def withdraw(self, amount: Union[int, float]):
        """ Withdraws money securely, ensuring no overdraft"""
        self.validate_amount(amount)
        with self.lock:
            if amount > self.balance:
                raise ValueError("Insufficient funds")
            # 更新余額的原子操作
            self.balance -= amount
            logging.info(f"Withdrew ${amount} from account {self.account_number}. New balance: ${self.balance}")

    def get_balance(self) -> float:
        """ Retrieves the current balance safely"""
        with self.lock:
            return self.balance

# **依賴 & 資源管理**
def process_transactions(account: BankAccount):
    """ Simulates multiple transactions with concurrency management"""
    threads = []
    for _ in range(3):
        t1 = threading.Thread(target=account.deposit, args=(100,))
        t2 = threading.Thread(target=account.withdraw, args=(50,))
        threads.extend([t1, t2])

    for t in threads:
        t.start()
    for t in threads:
        t.join()

# **錯誤處理 & 安全**
def safe_transaction(account: BankAccount, transaction_type: str, amount: float):
    """ Handles transactions with exception handling"""
    try:
        if transaction_type == "deposit":
            account.deposit(amount)
        elif transaction_type == "withdraw":
            account.withdraw(amount)
        else:
            raise ValueError("Invalid transaction type")
    except ValueError as e:
        logging.error(f"Transaction error: {e}")

#**執行防御性編程**
if __name__ == "__main__":
    acc = BankAccount("1234567890", 500)
    
    # 執行安全事務
    safe_transaction(acc, "deposit", 200)
    safe_transaction(acc, "withdraw", 800)  # Should fail (handled gracefully)
    
    # 多線程并發
    process_transactions(acc)
    
    # 最終余額檢查
    logging.info(f"Final balance for account {acc.account_number}: ${acc.get_balance()}")