gmail_multi_account.py

"""
Gmail Multi-Account Manager
Manage multiple Gmail accounts and unified inbox
"""

import os
import json
from gmail_crud import GmailCRUD


class MultiAccountGmail:
    """Manage multiple Gmail accounts with unified operations"""

    def __init__(self, config_file='json/accounts_config.json'):
        """
        Initialize multi-account manager

        Args:
            config_file: Path to accounts configuration file
        """
        self.config_file = config_file
        self.accounts = {}
        self.current_account = None
        self.load_config()

    def load_config(self):
        """Load accounts configuration from file"""
        if os.path.exists(self.config_file):
            with open(self.config_file, 'r') as f:
                config = json.load(f)
                self.config = config

                # Initialize accounts
                for account_name, account_info in config.get('accounts', {}).items():
                    print(f"Loading account: {account_name} ({account_info.get('email', 'N/A')})")

                # Set default account
                default = config.get('default_account')
                if default and default in config.get('accounts', {}):
                    self.current_account = default
                    print(f"✓ Default account: {default}")
        else:
            print(f"⚠ Config file not found: {self.config_file}")
            print("Creating example config...")
            self.create_example_config()

    def create_example_config(self):
        """Create example configuration file"""
        example_config = {
            "accounts": {
                "personal": {
                    "email": "your-email@gmail.com",
                    "credentials_file": "credentials_personal.json",
                    "token_file": "token_personal.json"
                }
            },
            "default_account": "personal"
        }

        with open(self.config_file, 'w') as f:
            json.dump(example_config, f, indent=2)

        print(f"✓ Created example config: {self.config_file}")
        print("Please edit this file with your account details")

    def save_config(self):
        """Save current configuration to file"""
        with open(self.config_file, 'w') as f:
            json.dump(self.config, f, indent=2)

    def add_account(self, name, email, credentials_file, token_file=None):
        """
        Add a new account

        Args:
            name: Account name (e.g., 'personal', 'work')
            email: Gmail address
            credentials_file: Path to OAuth credentials JSON
            token_file: Path to token file (default: token_{name}.json)
        """
        if token_file is None:
            token_file = f"token_{name}.json"

        if 'accounts' not in self.config:
            self.config['accounts'] = {}

        self.config['accounts'][name] = {
            'email': email,
            'credentials_file': credentials_file,
            'token_file': token_file
        }

        self.save_config()
        print(f"✓ Added account: {name} ({email})")

        # Set as default if first account
        if len(self.config['accounts']) == 1:
            self.config['default_account'] = name
            self.current_account = name
            self.save_config()

    def remove_account(self, name):
        """Remove an account"""
        if name in self.config.get('accounts', {}):
            del self.config['accounts'][name]
            self.save_config()
            print(f"✓ Removed account: {name}")

            # Clear current if removed
            if self.current_account == name:
                self.current_account = None
        else:
            print(f"✗ Account not found: {name}")

    def list_accounts(self):
        """List all configured accounts"""
        accounts = self.config.get('accounts', {})

        if not accounts:
            print("No accounts configured")
            return []

        print(f"\nConfigured Accounts ({len(accounts)}):")
        for name, info in accounts.items():
            current = " [CURRENT]" if name == self.current_account else ""
            default = " [DEFAULT]" if name == self.config.get('default_account') else ""
            print(f"  • {name}: {info.get('email', 'N/A')}{current}{default}")

        return list(accounts.keys())

    def switch_account(self, name):
        """Switch to a different account"""
        if name not in self.config.get('accounts', {}):
            print(f"✗ Account not found: {name}")
            return False

        self.current_account = name
        print(f"✓ Switched to account: {name}")
        return True

    def get_account_client(self, account_name=None):
        """
        Get GmailCRUD client for specific account

        Args:
            account_name: Account name (uses current if None)

        Returns:
            GmailCRUD instance or None
        """
        if account_name is None:
            account_name = self.current_account

        if account_name is None:
            print("✗ No account selected")
            return None

        accounts = self.config.get('accounts', {})
        if account_name not in accounts:
            print(f"✗ Account not found: {account_name}")
            return None

        # Get account from cache or create new
        if account_name not in self.accounts:
            account_info = accounts[account_name]

            # Create custom GmailCRUD with account-specific token file
            gmail = GmailCRUD(
                credentials_file=account_info['credentials_file'],
                token_file=account_info['token_file']
            )

            self.accounts[account_name] = gmail

        return self.accounts[account_name]

    # ==================== Unified Inbox Operations ====================

    def list_all_messages(self, max_results=10, query=''):
        """
        List messages from ALL accounts

        Args:
            max_results: Max messages per account
            query: Gmail search query

        Returns:
            List of dicts with 'account', 'account_email', and message data
        """
        all_messages = []
        accounts = self.config.get('accounts', {})

        print(f"Fetching messages from {len(accounts)} account(s)...")

        for account_name, account_info in accounts.items():
            print(f"\n📧 {account_name} ({account_info.get('email', 'N/A')})")

            gmail = self.get_account_client(account_name)
            if gmail:
                messages = gmail.list_messages(max_results=max_results, query=query)

                # Tag each message with account info
                for msg in messages:
                    msg['_account'] = account_name
                    msg['_account_email'] = account_info.get('email', 'N/A')

                all_messages.extend(messages)

        print(f"\n✓ Total messages: {len(all_messages)} from {len(accounts)} account(s)")
        return all_messages

    def search_all_accounts(self, query, max_results_per_account=50):
        """
        Search messages across ALL accounts

        Args:
            query: Gmail search query
            max_results_per_account: Max results per account

        Returns:
            List of messages from all accounts
        """
        all_results = []
        accounts = self.config.get('accounts', {})

        print(f"Searching '{query}' across {len(accounts)} account(s)...")

        for account_name, account_info in accounts.items():
            gmail = self.get_account_client(account_name)
            if gmail:
                messages = gmail.search_messages(query)[:max_results_per_account]

                # Tag with account
                for msg in messages:
                    msg['_account'] = account_name
                    msg['_account_email'] = account_info.get('email', 'N/A')

                all_results.extend(messages)

        print(f"✓ Found {len(all_results)} total messages")
        return all_results

    def get_unified_unread_count(self):
        """Get total unread count across all accounts"""
        total_unread = 0
        accounts = self.config.get('accounts', {})

        print("Checking unread across accounts...")

        for account_name, account_info in accounts.items():
            gmail = self.get_account_client(account_name)
            if gmail:
                unread = gmail.search_messages('is:unread')
                count = len(unread)
                total_unread += count
                print(f"  {account_name}: {count} unread")

        print(f"\n✓ Total unread: {total_unread}")
        return total_unread

    # ==================== Delegate to Current Account ====================

    def __getattr__(self, name):
        """
        Delegate unknown methods to current account's GmailCRUD

        This allows using multi-account manager like regular GmailCRUD:
        multi.send_message(...) -> uses current account
        """
        gmail = self.get_account_client()
        if gmail and hasattr(gmail, name):
            return getattr(gmail, name)
        raise AttributeError(f"'{type(self).__name__}' has no attribute '{name}'")


if __name__ == '__main__':
    print("="*60)
    print("Gmail Multi-Account Manager - Demo")
    print("="*60)

    # Initialize
    multi = MultiAccountGmail()

    # List accounts
    multi.list_accounts()

    if multi.current_account:
        print(f"\n--- Using account: {multi.current_account} ---")

        # Use like regular GmailCRUD
        messages = multi.list_messages(max_results=3)

        print("\n--- Unified Inbox (All Accounts) ---")
        all_messages = multi.list_all_messages(max_results=3)