"""
Audit logging hook example.

This hook logs all wallet transactions to an audit table for compliance and tracking.
POST hook - runs after successful transactions.
"""

import logging
from datetime import datetime
from typing import Optional

from wallet_utils.hooks import HookContext


logger = logging.getLogger(__name__)


class AuditLogger:
    """
    Audit logger for wallet transactions.
    
    In production, replace with database writes or external audit service.
    """
    
    def __init__(self):
        self.audit_records = []  # In-memory storage for demo
        self.logger = logging.getLogger("wallet.audit")
    
    def log_transaction(
        self,
        operation: str,
        user_id: int,
        point_type: str,
        amount: float,
        transaction_id: Optional[int],
        remarks: str,
        initiator_id: int,
        metadata: dict,
    ) -> None:
        """
        Log transaction to audit trail.
        
        Args:
            operation: Transaction type (add/deduct/transfer)
            user_id: User performing transaction
            point_type: Type of points
            amount: Transaction amount
            transaction_id: Transaction ID from database
            remarks: Transaction description
            initiator_id: Who initiated the transaction
            metadata: Additional context
        """
        audit_record = {
            "timestamp": datetime.now().isoformat(),
            "operation": operation,
            "user_id": user_id,
            "point_type": point_type,
            "amount": amount,
            "transaction_id": transaction_id,
            "remarks": remarks,
            "initiator_id": initiator_id,
            "metadata": metadata,
        }
        
        # Store in memory (in production, write to database)
        self.audit_records.append(audit_record)
        
        # Also log to logger
        self.logger.info(
            f"AUDIT: {operation.upper()} | User:{user_id} | Type:{point_type} | "
            f"Amount:{amount} | TX:{transaction_id} | Initiator:{initiator_id}"
        )
    
    def get_user_audit_trail(self, user_id: int, limit: int = 100):
        """Get audit records for a specific user."""
        return [
            record for record in self.audit_records
            if record["user_id"] == user_id
        ][-limit:]
    
    def get_recent_audits(self, limit: int = 100):
        """Get most recent audit records."""
        return self.audit_records[-limit:]


# Global audit logger instance
_audit_logger = AuditLogger()


def log_transaction_to_audit(context: HookContext) -> None:
    """
    POST hook to log transactions to audit trail.
    
    Logs all successful transactions for compliance and tracking purposes.
    This is a POST hook, so it runs after the transaction completes.
    
    Args:
        context: Hook context with transaction details
        
    Example:
        >>> from wallet_utils.hooks import register_hook, HookType
        >>> register_hook(
        ...     name="audit_logger",
        ...     hook_type=HookType.POST,
        ...     callback=log_transaction_to_audit,
        ...     operation="*",  # Log all operations
        ...     priority=900,  # Low priority, run after other hooks
        ... )
    """
    transaction_id = context.metadata.get("transaction_id")
    
    # Build metadata for audit log
    audit_metadata = {
        "current_balance": float(context.current_balance) if context.current_balance else None,
        "trans_type": context.trans_type,
    }
    
    # Add transfer-specific fields if present
    if context.operation == "transfer":
        audit_metadata["to_user_id"] = context.to_user_id
        audit_metadata["to_point_type"] = context.to_point_type
    
    # Add any custom metadata from other hooks
    for key, value in context.metadata.items():
        if key != "transaction_id":  # Don't duplicate
            audit_metadata[f"hook_{key}"] = value
    
    _audit_logger.log_transaction(
        operation=context.operation,
        user_id=context.user_id,
        point_type=context.point_type,
        amount=float(context.amount),
        transaction_id=transaction_id,
        remarks=context.remarks,
        initiator_id=context.iid,
        metadata=audit_metadata,
    )


def get_audit_logger() -> AuditLogger:
    """Get the global audit logger instance."""
    return _audit_logger


# Additional audit hooks for specific events

def log_failed_transaction_attempt(context: HookContext) -> bool:
    """
    PRE hook that logs transaction attempts (even if they fail later).
    
    This can be useful to track suspicious failed transaction patterns.
    """
    logger.info(
        f"Transaction attempt: {context.operation} | User:{context.user_id} | "
        f"Amount:{context.amount} | Type:{context.point_type}"
    )
    return True  # Always allow to continue


def log_large_transaction(context: HookContext) -> None:
    """
    POST hook to specifically flag large transactions.
    
    Example:
        >>> register_hook(
        ...     name="large_tx_logger",
        ...     hook_type=HookType.POST,
        ...     callback=log_large_transaction,
        ...     operation="*",
        ...     priority=850,
        ... )
    """
    from decimal import Decimal
    
    LARGE_AMOUNT_THRESHOLD = Decimal("5000.00")
    
    if context.amount >= LARGE_AMOUNT_THRESHOLD:
        logger.warning(
            f"LARGE TRANSACTION: {context.operation} | User:{context.user_id} | "
            f"Amount:{context.amount} | Type:{context.point_type} | "
            f"TX:{context.metadata.get('transaction_id')}"
        )
        
        # In production, send alert to compliance team
        # send_compliance_alert(context)