#!/usr/bin/env python3
"""
Email Account Discovery Tool for Estate Executors
Analyzes email exports to identify online service accounts.
"""

import re
import csv
import os
from pathlib import Path
from collections import defaultdict

# Common service patterns for account identification
SERVICE_PATTERNS = {
    'financial': [
        r'chase|bank of america|wells fargo|citibank|pnc',
        r'paypal|venmo|square|cash app',
        r'fidelity|schwab|vanguard|fidelity',
        r'coinbase|binance|kraken|blockchain',
    ],
    'social': [
        r'facebook|instagram|twitter|x\.com|linkedin',
        r'tiktok|snapchat|reddit|pinterest',
    ],
    'streaming': [
        r'netflix|spotify|hulu|disney\+|hbo',
        r'youtube|twitch|amazon prime',
    ],
    'cloud': [
        r'google drive|drive\.google|dropbox|icloud',
        r'onedrive|mega|box\.com',
    ],
}

def analyze_email_file(filepath):
    """Analyze email file and extract service mentions."""
    accounts = defaultdict(list)

    service_indicators = [
        (r'welcome to ([a-zA-Z0-9]+)', 'registration'),
        (r'your ([a-zA-Z0-9]+) account', 'account'),
        (r'confirm your email.*?([a-zA-Z0-9]+)', 'verification'),
    ]

    # Read and analyze email content
    with open(filepath, 'r', encoding='utf-8', errors='ignore') as f:
        content = f.read().lower()

        for category, patterns in SERVICE_PATTERNS.items():
            for pattern in patterns:
                matches = re.findall(pattern, content)
                for match in matches:
                    accounts[category].append({
                        'service': match,
                        'type': 'identified',
                    })

    return accounts

def generate_inventory_report(accounts, output_file='estate_accounts.csv'):
    """Generate CSV report of discovered accounts."""
    with open(output_file, 'w', newline='') as f:
        writer = csv.writer(f)
        writer.writerow(['Category', 'Service', 'Action Required', 'Priority', 'Notes'])

        priorities = {
            'financial': 'HIGH',
            'social': 'MEDIUM',
            'streaming': 'MEDIUM',
            'cloud': 'HIGH',
        }

        for category, services in accounts.items():
            for service in services:
                writer.writerow([
                    category,
                    service['service'],
                    'Review and close/transfer',
                    priorities.get(category, 'LOW'),
                    ''
                ])

    print(f"Inventory report generated: {output_file}")

if __name__ == '__main__':
    import sys

    if len(sys.argv) < 2:
        print("Usage: python account_discovery.py <email_export_directory>")
        sys.exit(1)

    email_dir = Path(sys.argv[1])
    all_accounts = defaultdict(list)

    for email_file in email_dir.glob('*'):
        if email_file.is_file():
            accounts = analyze_email_file(email_file)
            for category, services in accounts.items():
                all_accounts[category].extend(services)

    generate_inventory_report(all_accounts)

#!/usr/bin/env python3
"""
Estate Account Manager
Tracks and manages digital accounts during estate administration.
"""

import json
import csv
from datetime import datetime
from pathlib import Path

class EstateAccountManager:
    def __init__(self, inventory_file='estate_inventory.json'):
        self.inventory_file = Path(inventory_file)
        self.data = self._load_inventory()

    def _load_inventory(self):
        if self.inventory_file.exists():
            with open(self.inventory_file) as f:
                return json.load(f)
        return {"accounts": [], "metadata": {}}

    def add_account(self, service_name, account_type, priority='medium',
                    monetary_value=0, notes=''):
        account = {
            "id": len(self.data['accounts']) + 1,
            "service_name": service_name,
            "account_type": account_type,
            "priority": priority,
            "monetary_value": monetary_value,
            "notes": notes,
            "date_documented": datetime.now().isoformat(),
            "completed": False
        }
        self.data['accounts'].append(account)
        self._save_inventory()
        return account['id']

    def mark_completed(self, account_id):
        for account in self.data['accounts']:
            if account['id'] == account_id:
                account['completed'] = True
                account['date_completed'] = datetime.now().isoformat()
        self._save_inventory()

    def get_pending_accounts(self, priority=None):
        accounts = [a for a in self.data['accounts'] if not a['completed']]
        if priority:
            accounts = [a for a in accounts if a['priority'] == priority]
        return accounts

    def generate_summary(self):
        total = len(self.data['accounts'])
        completed = len([a for a in self.data['accounts'] if a['completed']])
        pending = total - completed
        total_value = sum(a.get('monetary_value', 0) for a in self.data['accounts'])

        return {
            "total_accounts": total,
            "completed": completed,
            "pending": pending,
            "total_monetary_value": total_value
        }

    def _save_inventory(self):
        with open(self.inventory_file, 'w') as f:
            json.dump(self.data, f, indent=2)

if __name__ == '__main__':
    manager = EstateAccountManager()

    # Add discovered accounts
    manager.add_account("Chase Bank", "financial", "high", 50000, "Primary checking")
    manager.add_account("Netflix", "subscription", "low", 15, "Family plan")
    manager.add_account("GitHub", "developer", "medium", 0, "Contains code repositories")

    # Print status
    summary = manager.generate_summary()
    print(f"Estate Account Summary:")
    print(f"  Total: {summary['total_accounts']}")
    print(f"  Completed: {summary['completed']}")
    print(f"  Pending: {summary['pending']}")
    print(f"  Value: ${summary['total_monetary_value']}")