import logging
from typing import List, Dict, Any
import hashlib

class ConflictResolver:
    def __init__(self, ai_client=None, model_name: str = "gpt-3.5-turbo"):
        self.model_name = model_name
        self.ai_client = ai_client or self._default_ai_client
        self.logger = logging.getLogger(__name__)
        logging.basicConfig(level=logging.INFO)

    def _default_ai_client(self, conflict: Dict) -> str:
        """Mock AI client that resolves conflicts by appending a resolution note."""
        try:
            file_path = conflict["file_path"]
            return f"Resolved content for {file_path} (AI: {self.model_name})"
        except KeyError as e:
            self.logger.error(f"Missing conflict key: {e}")
            raise ValueError(f"Conflict dictionary missing key: {e}") from e

    def detect_conflicts(self, base_files: Dict[str, str], feature_files: Dict[str, str]) -> List[Dict]:
        """Detects conflicts between base and feature files using git-style conflict markers."""
        conflicts = []
        all_files = set(base_files.keys()) | set(feature_files.keys())

        for file_path in all_files:
            base_content = base_files.get(file_path, "")
            feature_content = feature_files.get(file_path, "")

            # Check for conflict markers (simplified)
            if base_content != feature_content and \
               ("<<<<<<<" in base_content or "<<<<<<<" in feature_content):
                conflicts.append({
                    "file_path": file_path,
                    "base_content": base_content,
                    "feature_content": feature_content,
                    "conflict_marker": "<<<<<<< HEAD"
                })
        return conflicts

    def resolve_conflicts(self, conflicts: List[Dict]) -> Dict[str, str]:
        """Resolves conflicts using AI client and returns resolved files."""
        resolved_files = {}
        for conflict in conflicts:
            try:
                resolved_content = self.ai_client(conflict)
                resolved_files[conflict["file_path"]] = resolved_content
            except Exception as e:
                self.logger.error(f"Conflict resolution failed for {conflict['file_path']}: {str(e)}")
                raise RuntimeError(f"Resolution failed: {str(e)}") from e
        return resolved_files

    def create_merge_commit(self, resolved_files: Dict[str, str], commit_message: str = "Merge branch 'feature' into main") -> str:
        """Creates a clean merge commit with resolved files."""
        commit_hash = self._generate_commit_hash(resolved_files)
        self.logger.info(f"Created merge commit: {commit_hash} with message: {commit_message}")
        return commit_hash

    def _generate_commit_hash(self, files: Dict[str, str]) -> str:
        """Generates a deterministic commit hash from file contents."""
        content = "".join(f"{path}:{content}" for path, content in files.items())
        return f"commit_{hashlib.sha256(content.encode()).hexdigest()[:8]}"

if __name__ == "__main__":
    # Example usage for testing
    base = {"src/config.py": "# Base config\nversion = 1.0"}
    feature = {"src/config.py": "# Feature config\nversion = 2.0\n<<<<<<< HEAD"}

    resolver = ConflictResolver()
    conflicts = resolver.detect_conflicts(base, feature)
    resolved = resolver.resolve_conflicts(conflicts)
    commit_hash = resolver.create_merge_commit(resolved)

    logging.info(f"Merge commit created: {commit_hash}")
    logging.info(f"Resolved files: {resolved}")