leggen/leggend/services/notification_service.py

from typing import List, Dict, Any

from loguru import logger

from leggend.config import config


class NotificationService:
    def __init__(self):
        self.notifications_config = config.notifications_config
        self.filters_config = config.filters_config

    async def send_transaction_notifications(self, transactions: List[Dict[str, Any]]) -> None:
        """Send notifications for new transactions that match filters"""
        if not self.filters_config:
            logger.info("No notification filters configured, skipping notifications")
            return

        # Filter transactions that match notification criteria
        matching_transactions = self._filter_transactions(transactions)
        
        if not matching_transactions:
            logger.info("No transactions matched notification filters")
            return

        # Send to enabled notification services
        if self._is_discord_enabled():
            await self._send_discord_notifications(matching_transactions)
            
        if self._is_telegram_enabled():
            await self._send_telegram_notifications(matching_transactions)

    async def send_test_notification(self, service: str, message: str) -> bool:
        """Send a test notification"""
        try:
            if service == "discord" and self._is_discord_enabled():
                await self._send_discord_test(message)
                return True
            elif service == "telegram" and self._is_telegram_enabled():
                await self._send_telegram_test(message)
                return True
            else:
                logger.error(f"Notification service '{service}' not enabled or not found")
                return False
        except Exception as e:
            logger.error(f"Failed to send test notification to {service}: {e}")
            return False

    async def send_expiry_notification(self, notification_data: Dict[str, Any]) -> None:
        """Send notification about account expiry"""
        if self._is_discord_enabled():
            await self._send_discord_expiry(notification_data)
            
        if self._is_telegram_enabled():
            await self._send_telegram_expiry(notification_data)

    def _filter_transactions(self, transactions: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
        """Filter transactions based on notification criteria"""
        matching = []
        filters_case_insensitive = self.filters_config.get("case-insensitive", {})
        
        for transaction in transactions:
            description = transaction.get("description", "").lower()
            
            # Check case-insensitive filters
            for filter_name, filter_value in filters_case_insensitive.items():
                if filter_value.lower() in description:
                    matching.append({
                        "name": transaction["description"],
                        "value": transaction["transactionValue"], 
                        "currency": transaction["transactionCurrency"],
                        "date": transaction["transactionDate"],
                    })
                    break
        
        return matching

    def _is_discord_enabled(self) -> bool:
        """Check if Discord notifications are enabled"""
        discord_config = self.notifications_config.get("discord", {})
        return bool(discord_config.get("webhook") and discord_config.get("enabled", True))

    def _is_telegram_enabled(self) -> bool:
        """Check if Telegram notifications are enabled"""
        telegram_config = self.notifications_config.get("telegram", {})
        return bool(
            telegram_config.get("token") and 
            telegram_config.get("chat_id") and 
            telegram_config.get("enabled", True)
        )

    async def _send_discord_notifications(self, transactions: List[Dict[str, Any]]) -> None:
        """Send Discord notifications - placeholder implementation"""
        # Would import and use leggen.notifications.discord
        logger.info(f"Sending {len(transactions)} transaction notifications to Discord")

    async def _send_telegram_notifications(self, transactions: List[Dict[str, Any]]) -> None:
        """Send Telegram notifications - placeholder implementation"""
        # Would import and use leggen.notifications.telegram
        logger.info(f"Sending {len(transactions)} transaction notifications to Telegram")

    async def _send_discord_test(self, message: str) -> None:
        """Send Discord test notification"""
        logger.info(f"Sending Discord test: {message}")

    async def _send_telegram_test(self, message: str) -> None:
        """Send Telegram test notification"""
        logger.info(f"Sending Telegram test: {message}")

    async def _send_discord_expiry(self, notification_data: Dict[str, Any]) -> None:
        """Send Discord expiry notification"""
        logger.info(f"Sending Discord expiry notification: {notification_data}")

    async def _send_telegram_expiry(self, notification_data: Dict[str, Any]) -> None:
        """Send Telegram expiry notification"""
        logger.info(f"Sending Telegram expiry notification: {notification_data}")