#!/usr/bin/env python3
"""
Generic startup functionality that works for any user/collaborator
Provides the same functionality as .claude_startup.py but integrated with MIRA
"""

import os
import sys
from pathlib import Path
from typing import Optional, List, Dict, Tuple

# Add parent directory to path for imports
sys.path.insert(0, str(Path(__file__).parent.parent))

from config import MEMORY_DIR
from core.memory import MemoryInterface
from utils import setup_logging

logger = setup_logging("generic_startup")

class GenericIdentity:
    """Generates search patterns for any user based on environment"""
    
    def __init__(self):
        self.user = self._get_username()
        self.relationship_terms = self._generate_terms()
    
    def _get_username(self) -> str:
        """Get username from environment or use generic"""
        # Try various sources
        user = os.environ.get('USER') or os.environ.get('USERNAME')
        if not user:
            # Try to get from git config
            try:
                import subprocess
                result = subprocess.run(['git', 'config', 'user.name'], 
                                      capture_output=True, text=True)
                if result.returncode == 0 and result.stdout.strip():
                    user = result.stdout.strip()
            except:
                pass
        
        return user or "collaborator"
    
    def _generate_terms(self) -> List[str]:
        """Generate relationship terms based on context"""
        terms = ["we", "our", "together", "collaborative", "partnership"]
        
        # Add user-specific terms if we have a username
        if self.user and self.user != "collaborator":
            terms.extend([
                f"with {self.user}",
                f"{self.user} and Claude",
                f"working with {self.user}"
            ])
        
        return terms
    
    def get_search_patterns(self) -> List[str]:
        """Get search patterns for memory recall"""
        patterns = []
        
        # Add relationship patterns
        for term in self.relationship_terms:
            patterns.append(term)
        
        # Add project context if available
        cwd = Path.cwd()
        project_name = cwd.name
        if project_name:
            patterns.extend([
                f"working on {project_name}",
                f"{project_name} development",
                f"building {project_name}"
            ])
        
        # Add generic patterns
        patterns.extend([
            "recent work",
            "current task",
            "last session",
            "previous discussion"
        ])
        
        return patterns

def run_generic_startup(quiet: bool = False) -> Dict[str, any]:
    """Run generic startup check that works for any user"""
    result = {
        'success': False,
        'user': 'unknown',
        'memory_count': 0,
        'patterns': [],
        'recent_memories': []
    }
    
    try:
        if not quiet:
            print("=" * 60)
            print("🧠 COGNITIVE CONTINUITY CHECK")
            print("=" * 60)
        
        # Initialize memory
        memory = MemoryInterface()
        memory.initialize()
        
        # Get generic identity
        identity = GenericIdentity()
        result['user'] = identity.user
        result['patterns'] = identity.get_search_patterns()
        
        if not quiet:
            print(f"👤 Collaborator: {identity.user}")
            print(f"🔍 Search patterns: {', '.join(identity.relationship_terms[:3])}...")
        
        # Try to recall recent context
        patterns = identity.get_search_patterns()
        for pattern in patterns[:3]:  # Try first 3 patterns
            results = memory.recall(pattern, top_k=3)
            if results:
                result['recent_memories'] = results
                result['memory_count'] = len(results)
                if not quiet:
                    print(f"\n📚 Found {len(results)} memories for '{pattern}'")
                break
        else:
            if not quiet:
                print("\n📚 No recent memories found (this is normal for new projects)")
        
        # Get total memory count
        try:
            # Try to get total count from memory system
            all_memories = memory.list_memories(limit=1000)
            result['memory_count'] = len(all_memories)
        except:
            pass
        
        result['success'] = True
        
        if not quiet:
            print(f"\n✅ MIRA memory system ready! ({result['memory_count']} total memories)")
            print("=" * 60)
            
    except ImportError as e:
        result['error'] = f"Memory system not properly initialized: {str(e)}"
        if not quiet:
            print("⚠️  MIRA memory system not found. Run 'mira setup' to initialize.")
            
    except Exception as e:
        result['error'] = str(e)
        if not quiet:
            print(f"❌ Memory system error: {e}")
            print("🔧 Try running: mira setup")
    
    return result

def main():
    """Main entry point for standalone execution"""
    import argparse
    parser = argparse.ArgumentParser(description="Generic startup check for MIRA")
    parser.add_argument('-q', '--quiet', action='store_true', help='Minimal output')
    args = parser.parse_args()
    
    result = run_generic_startup(args.quiet)
    
    # Exit with appropriate code
    sys.exit(0 if result['success'] else 1)

if __name__ == "__main__":
    main()