"""
AP Knowledge Base - Father Sync

Sync with father's knowledge:
- Export memories for father review
- Import father teachings
- Conflict resolution
"""

import json
import hashlib
from pathlib import Path
from datetime import datetime
from typing import List, Dict, Optional, Tuple, Set
from dataclasses import dataclass, asdict

from memory_types import MemoryEntry, MemoryScope, SyncConflict, MemoryType
from memdir import MemoryDirectory


@dataclass
class SyncManifest:
    """Manifest for a sync operation."""
    export_timestamp: str
    source: str  # 'child' or 'father'
    memory_count: int
    version: str = "1.0"
    
    def to_dict(self) -> Dict:
        return asdict(self)
    
    @classmethod
    def from_dict(cls, data: Dict) -> "SyncManifest":
        return cls(**data)


class FatherSync:
    """
    Handles synchronization between AP (child) and father's knowledge base.
    
    Key concepts:
    - Export: Package memories for father's review
    - Import: Incorporate father's teachings
    - Conflict resolution: Handle divergent updates
    """
    
    def __init__(self, memdir: MemoryDirectory, father_inbox: Optional[Path] = None):
        self.memdir = memdir
        self.base_dir = memdir.base_dir
        
        # Father inbox/outbox directories
        self.sync_dir = self.base_dir / "sync"
        self.sync_dir.mkdir(exist_ok=True)
        
        self.outbox = self.sync_dir / "outbox"
        self.outbox.mkdir(exist_ok=True)
        
        self.inbox = father_inbox or (self.sync_dir / "inbox")
        self.inbox.mkdir(exist_ok=True)
        
        self.processed = self.sync_dir / "processed"
        self.processed.mkdir(exist_ok=True)
        
        # Sync state tracking
        self.sync_state_path = self.sync_dir / "sync_state.json"
        self.sync_state = self._load_sync_state()
    
    def _load_sync_state(self) -> Dict:
        """Load sync state from disk."""
        if self.sync_state_path.exists():
            try:
                return json.loads(self.sync_state_path.read_text())
            except Exception as e:
                print(f"Warning: Failed to load sync state: {e}")
        
        return {
            'last_export': None,
            'last_import': None,
            'exported_memories': {},  # memory_id -> export_timestamp
            'imported_memories': {},  # memory_id -> import_timestamp
            'conflicts': []  # List of unresolved conflicts
        }
    
    def _save_sync_state(self):
        """Save sync state to disk."""
        self.sync_state_path.write_text(json.dumps(self.sync_state, indent=2), encoding='utf-8')
    
    def _hash_memory(self, entry: MemoryEntry) -> str:
        """Generate a hash of memory content for change detection."""
        content = f"{entry.name}:{entry.description}:{entry.content}:{entry.modified_at.isoformat()}"
        return hashlib.sha256(content.encode()).hexdigest()[:16]
    
    def export_for_father(
        self,
        scope: Optional[MemoryScope] = None,
        types: Optional[List[MemoryType]] = None,
        tags: Optional[List[str]] = None,
        since_last_export: bool = True,
        include_archived: bool = False
    ) -> Path:
        """
        Export memories for father's review.
        
        Args:
            scope: Filter by scope (private memories usually not shared)
            types: Filter by memory types
            tags: Filter by tags
            since_last_export: Only export memories modified since last export
            include_archived: Include archived memories
        
        Returns:
            Path to the exported file
        """
        # Collect memories to export
        to_export = []
        
        for entry in self.memdir._memories.values():
            # Skip private memories by default
            if scope and entry.scope != scope:
                continue
            
            # Filter by type
            if types and entry.type not in types:
                continue
            
            # Filter by tags
            if tags:
                entry_tags = set(t.lower() for t in entry.tags)
                if not any(t.lower() in entry_tags for t in tags):
                    continue
            
            # Skip archived unless requested
            if entry.metadata.get('archived') and not include_archived:
                continue
            
            # Skip if already exported and not modified
            if since_last_export and self.sync_state['last_export']:
                last_export = datetime.fromisoformat(self.sync_state['last_export'])
                if entry.modified_at <= last_export:
                    # Check if hash matches
                    current_hash = self._hash_memory(entry)
                    if self.sync_state['exported_memories'].get(entry.id) == current_hash:
                        continue
            
            to_export.append(entry)
        
        # Build export package
        export_data = {
            'manifest': SyncManifest(
                export_timestamp=datetime.utcnow().isoformat(),
                source='child',
                memory_count=len(to_export)
            ).to_dict(),
            'memories': [entry.to_frontmatter() for entry in to_export],
            'metadata': {
                'export_reason': 'father_review',
                'includes_private': scope == MemoryScope.PRIVATE,
                'filters': {
                    'scope': scope.value if scope else None,
                    'types': [t.value for t in types] if types else None,
                    'tags': tags
                }
            }
        }
        
        # Write to outbox
        timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
        export_path = self.outbox / f"export_{timestamp}.json"
        export_path.write_text(json.dumps(export_data, indent=2), encoding='utf-8')
        
        # Update sync state
        self.sync_state['last_export'] = datetime.utcnow().isoformat()
        for entry in to_export:
            self.sync_state['exported_memories'][entry.id] = self._hash_memory(entry)
        self._save_sync_state()
        
        return export_path
    
    def import_from_father(self, auto_resolve: bool = False) -> Tuple[int, int, List[SyncConflict]]:
        """
        Import teachings from father.
        
        Args:
            auto_resolve: Automatically resolve simple conflicts
        
        Returns:
            (imported_count, skipped_count, conflicts)
        """
        imported = 0
        skipped = 0
        conflicts = []
        
        # Process all files in inbox
        for import_file in self.inbox.glob("import_*.json"):
            try:
                data = json.loads(import_file.read_text())
                
                # Validate manifest
                manifest = SyncManifest.from_dict(data.get('manifest', {}))
                
                if manifest.source != 'father':
                    print(f"Warning: Skipping import from unknown source: {manifest.source}")
                    continue
                
                # Process each memory
                for mem_text in data.get('memories', []):
                    entry = MemoryEntry.from_frontmatter(mem_text)
                    
                    # Check for existing memory
                    existing = self.memdir.get(entry.id)
                    
                    if existing:
                        # Check for conflicts
                        if self._has_conflict(existing, entry):
                            conflict = SyncConflict(
                                local_entry=existing,
                                remote_entry=entry,
                                conflict_type='content'
                            )
                            
                            if auto_resolve:
                                resolution = self._auto_resolve(conflict)
                                if resolution:
                                    conflict.resolution = resolution
                                    if resolution == 'keep_remote':
                                        self._apply_import(entry)
                                        imported += 1
                                    elif resolution == 'merge':
                                        merged = self._merge_memories(existing, entry)
                                        self.memdir.save(merged)
                                        imported += 1
                                    else:  # keep_local
                                        skipped += 1
                                else:
                                    conflicts.append(conflict)
                            else:
                                conflicts.append(conflict)
                                skipped += 1
                        else:
                            # No conflict, skip (already have it)
                            skipped += 1
                    else:
                        # New memory from father
                        entry.source = 'father'
                        self._apply_import(entry)
                        imported += 1
                
                # Move to processed
                processed_path = self.processed / import_file.name
                import_file.rename(processed_path)
                
            except Exception as e:
                print(f"Error processing {import_file}: {e}")
                skipped += 1
        
        # Update sync state
        self.sync_state['last_import'] = datetime.utcnow().isoformat()
        for conflict in conflicts:
            self.sync_state['conflicts'].append({
                'local_id': conflict.local_entry.id,
                'remote_id': conflict.remote_entry.id,
                'type': conflict.conflict_type,
                'detected_at': datetime.utcnow().isoformat()
            })
        self._save_sync_state()
        
        return imported, skipped, conflicts
    
    def _has_conflict(self, local: MemoryEntry, remote: MemoryEntry) -> bool:
        """Check if there's a conflict between local and remote."""
        # Different content = potential conflict
        if local.content != remote.content:
            return True
        if local.description != remote.description:
            return True
        return False
    
    def _auto_resolve(self, conflict: SyncConflict) -> Optional[str]:
        """
        Attempt to auto-resolve a conflict.
        
        Returns:
            Resolution strategy or None if manual resolution needed
        """
        local = conflict.local_entry
        remote = conflict.remote_entry
        
        # Father's version is newer
        if remote.modified_at > local.modified_at:
            # If father has higher confidence, accept his
            if remote.confidence > local.confidence:
                return 'keep_remote'
        
        # If local has been accessed recently, prefer local
        if local.accessed_at:
            days_since_access = (datetime.utcnow() - local.accessed_at).days
            if days_since_access < 7:
                return 'keep_local'
        
        # If content can be merged
        if self._can_merge(local, remote):
            return 'merge'
        
        # Default: no auto-resolution
        return None
    
    def _can_merge(self, a: MemoryEntry, b: MemoryEntry) -> bool:
        """Check if two memories can be automatically merged."""
        # Simple check: non-overlapping content additions
        a_lines = set(a.content.split('\n'))
        b_lines = set(b.content.split('\n'))
        
        # If one is subset of other, can merge
        if a_lines <= b_lines or b_lines <= a_lines:
            return True
        
        # If small overlap, probably can merge
        overlap = len(a_lines & b_lines)
        total = len(a_lines | b_lines)
        
        return overlap / total > 0.5 if total > 0 else True
    
    def _merge_memories(self, local: MemoryEntry, remote: MemoryEntry) -> MemoryEntry:
        """Merge two memories into one."""
        # Combine content
        local_lines = set(local.content.split('\n'))
        remote_lines = set(remote.content.split('\n'))
        merged_content = '\n'.join(sorted(local_lines | remote_lines))
        
        # Prefer father's description if longer
        description = remote.description if len(remote.description) > len(local.description) else local.description
        
        # Merge tags
        tags = list(set(local.tags + remote.tags))
        
        # Create merged entry
        merged = MemoryEntry(
            id=local.id,  # Keep local ID
            name=local.name,
            description=description,
            type=local.type,
            scope=local.scope,
            content=merged_content,
            tags=tags,
            created_at=local.created_at,
            modified_at=datetime.utcnow(),
            source='merged',
            confidence=max(local.confidence, remote.confidence),
            file_path=local.file_path,
            metadata={
                **local.metadata,
                'merged_from': remote.id,
                'merged_at': datetime.utcnow().isoformat(),
                'father_version': remote.modified_at.isoformat()
            }
        )
        
        return merged
    
    def _apply_import(self, entry: MemoryEntry):
        """Apply an imported memory."""
        entry.modified_at = datetime.utcnow()
        self.memdir.save(entry)
        
        # Track in sync state
        self.sync_state['imported_memories'][entry.id] = {
            'imported_at': datetime.utcnow().isoformat(),
            'original_source': entry.source
        }
    
    def resolve_conflict(
        self,
        conflict: SyncConflict,
        resolution: str,  # 'keep_local', 'keep_remote', 'merge', 'custom'
        custom_content: Optional[str] = None
    ) -> MemoryEntry:
        """
        Manually resolve a conflict.
        
        Args:
            conflict: The conflict to resolve
            resolution: Resolution strategy
            custom_content: Custom content if resolution is 'custom'
        
        Returns:
            The resolved memory entry
        """
        if resolution == 'keep_local':
            result = conflict.local_entry
        elif resolution == 'keep_remote':
            result = conflict.remote_entry
            result.id = conflict.local_entry.id
            result.file_path = conflict.local_entry.file_path
        elif resolution == 'merge':
            result = self._merge_memories(conflict.local_entry, conflict.remote_entry)
        elif resolution == 'custom' and custom_content:
            result = conflict.local_entry
            result.content = custom_content
            result.modified_at = datetime.utcnow()
        else:
            raise ValueError(f"Invalid resolution: {resolution}")
        
        # Save and track
        result.metadata['conflict_resolved'] = True
        result.metadata['resolution_strategy'] = resolution
        result.metadata['resolved_at'] = datetime.utcnow().isoformat()
        
        self.memdir.save(result)
        
        # Remove from unresolved conflicts
        self.sync_state['conflicts'] = [
            c for c in self.sync_state['conflicts']
            if not (c['local_id'] == conflict.local_entry.id and 
                    c['remote_id'] == conflict.remote_entry.id)
        ]
        self._save_sync_state()
        
        return result
    
    def get_pending_exports(self) -> List[Path]:
        """Get list of pending export files."""
        return sorted(self.outbox.glob("export_*.json"))
    
    def get_pending_imports(self) -> List[Path]:
        """Get list of pending import files."""
        return sorted(self.inbox.glob("import_*.json"))
    
    def get_unresolved_conflicts(self) -> List[SyncConflict]:
        """Get all unresolved conflicts."""
        conflicts = []
        
        for conf_data in self.sync_state.get('conflicts', []):
            local = self.memdir.get(conf_data['local_id'])
            # Remote entry would need to be reconstructed from import file
            # For now, just track that there's a conflict
            if local:
                conflicts.append(SyncConflict(
                    local_entry=local,
                    remote_entry=MemoryEntry(id=conf_data['remote_id'], name="unknown"),
                    conflict_type=conf_data['type']
                ))
        
        return conflicts
    
    def create_father_package(self, notes: str = "") -> Path:
        """
        Create a complete package for father's review.
        
        This includes:
        - All team-scope memories
        - Statistics and metadata
        - Child's questions or notes
        """
        # Export team memories
        export_path = self.export_for_father(
            scope=MemoryScope.TEAM,
            since_last_export=False
        )
        
        # Add notes
        data = json.loads(export_path.read_text())
        data['notes'] = notes
        data['questions'] = []  # Child can ask father questions
        data['stats'] = self.memdir.get_stats()
        
        export_path.write_text(json.dumps(data, indent=2), encoding='utf-8')
        
        return export_path
    
    def sync_status(self) -> Dict:
        """Get current sync status."""
        return {
            'last_export': self.sync_state['last_export'],
            'last_import': self.sync_state['last_import'],
            'pending_exports': len(self.get_pending_exports()),
            'pending_imports': len(self.get_pending_imports()),
            'unresolved_conflicts': len(self.get_unresolved_conflicts()),
            'total_exported': len(self.sync_state['exported_memories']),
            'total_imported': len(self.sync_state['imported_memories'])
        }