"""
Production-ready base repository with encryption/decryption support
"""
from typing import Generic, TypeVar, Type, Optional, List, Dict, Any
from sqlmodel import Session, select, SQLModel
from app.core.encryption import encryption_service
import json
import logging

logger = logging.getLogger(__name__)

ModelType = TypeVar("ModelType", bound=SQLModel)
CreateSchemaType = TypeVar("CreateSchemaType", bound=SQLModel)
UpdateSchemaType = TypeVar("UpdateSchemaType", bound=SQLModel)

class BaseRepository(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
    """Base repository with encryption/decryption and JSON field handling"""
    
    def __init__(self, model: Type[ModelType], session: Session):
        self.model = model
        self.session = session
    
    def _encrypt_fields(self, obj_data: Dict[str, Any]) -> Dict[str, Any]:
        """Encrypt sensitive fields before storing"""
        if hasattr(self.model, 'get_encrypted_fields'):
            encrypted_fields = self.model().get_encrypted_fields()
            for field in encrypted_fields:
                if field in obj_data and obj_data[field]:
                    obj_data[field] = encryption_service.encrypt(str(obj_data[field]))
        return obj_data
    
    def _decrypt_fields(self, db_obj: ModelType) -> ModelType:
        """Decrypt sensitive fields after retrieval"""
        if hasattr(db_obj, 'get_encrypted_fields'):
            encrypted_fields = db_obj.get_encrypted_fields()
            for field in encrypted_fields:
                if hasattr(db_obj, field) and getattr(db_obj, field):
                    try:
                        decrypted_value = encryption_service.decrypt(getattr(db_obj, field))
                        setattr(db_obj, field, decrypted_value)
                    except Exception as e:
                        logger.warning(f"Failed to decrypt field {field}: {e}")
        return db_obj
    
    def _convert_json_fields_to_strings(self, obj_data: Dict[str, Any]) -> Dict[str, Any]:
        """Convert list/dict fields to JSON strings for storage"""
        for key, value in obj_data.items():
            if isinstance(value, (list, dict)) and value is not None:
                obj_data[key] = json.dumps(value, default=str)
        return obj_data
    
    def _convert_json_fields_to_objects(self, db_obj: ModelType) -> ModelType:
        """Convert JSON string fields back to Python objects"""
        for field_name in dir(db_obj):
            if not field_name.startswith('_'):
                field_value = getattr(db_obj, field_name, None)
                if isinstance(field_value, str) and field_value:
                    try:
                        # Try to parse as JSON
                        if field_value.startswith(('[', '{')):
                            parsed_value = json.loads(field_value)
                            setattr(db_obj, field_name, parsed_value)
                    except (json.JSONDecodeError, TypeError):
                        # Not JSON, leave as string
                        pass
        return db_obj
    
    def create(self, obj_in: CreateSchemaType) -> ModelType:
        """Create new record with encryption and JSON handling"""
        obj_data = obj_in.model_dump() if hasattr(obj_in, 'model_dump') else obj_in.dict()
        
        # Enforce user_id of the current user for any authenticated session
        from app.core.security import current_user_var
        user = current_user_var.get()
        if user:
            if "user_id" in obj_data or hasattr(self.model, "user_id"):
                obj_data["user_id"] = user["user_id"]
            if user.get("role") == "customer":
                for field in ["email_address", "email", "email_id"]:
                    if field in obj_data or hasattr(self.model, field):
                        obj_data[field] = user["email"]
        
        # Convert lists/dicts to JSON strings
        obj_data = self._convert_json_fields_to_strings(obj_data)
        
        # Encrypt sensitive fields
        obj_data = self._encrypt_fields(obj_data)
        
        # Create database object
        db_obj = self.model(**obj_data)
        return self.create_db_object(db_obj)
    
    def create_db_object(self, db_obj: ModelType) -> ModelType:
        """Create database object and return with decryption"""
        # Enforce user_id of the current user for any authenticated session
        from app.core.security import current_user_var
        user = current_user_var.get()
        if user:
            if hasattr(db_obj, "user_id"):
                setattr(db_obj, "user_id", user["user_id"])
            if user.get("role") == "customer":
                for field in ["email_address", "email", "email_id"]:
                    if hasattr(db_obj, field):
                        setattr(db_obj, field, user["email"])
                    
        self.session.add(db_obj)
        self.session.commit()
        self.session.refresh(db_obj)
        
        # Decrypt and convert JSON fields for response
        db_obj = self._decrypt_fields(db_obj)
        db_obj = self._convert_json_fields_to_objects(db_obj)
        
        return db_obj
    
    def get(self, id: int) -> Optional[ModelType]:
        """Get record by ID with decryption and ownership enforcement"""
        db_obj = self.session.get(self.model, id)
        if db_obj:
            if hasattr(db_obj, "deleted_at") and getattr(db_obj, "deleted_at") is not None:
                return None
            db_obj = self._decrypt_fields(db_obj)
            db_obj = self._convert_json_fields_to_objects(db_obj)
            
            from app.core.security import current_user_var
            user = current_user_var.get()
            if user and user.get("role") == "customer":
                # Check user_id first
                record_user_id = getattr(db_obj, "user_id", None)
                if record_user_id is not None:
                    if record_user_id != user["user_id"]:
                        from fastapi import HTTPException
                        raise HTTPException(status_code=403, detail="You do not have permission to access this resource.")
                else:
                    # Fallback to email
                    email_val = None
                    for field in ["email_address", "email", "email_id"]:
                        if hasattr(db_obj, field):
                            email_val = getattr(db_obj, field)
                            break
                    if email_val and email_val.lower() != user["email"].lower():
                        from fastapi import HTTPException
                        raise HTTPException(status_code=403, detail="You do not have permission to access this resource.")
        return db_obj
    
    def get_multi(self, skip: int = 0, limit: int = 100) -> List[ModelType]:
        """Get multiple records with decryption and customer filtration"""
        from app.core.security import current_user_var
        user = current_user_var.get()
        if user and user.get("role") == "customer":
            has_user_id = hasattr(self.model, "user_id")
            email_field = None
            for field in ["email_address", "email", "email_id"]:
                if hasattr(self.model, field):
                    email_field = field
                    break
            
            from sqlmodel import or_
            filters = []
            if has_user_id:
                filters.append(self.model.user_id == user["user_id"])
            else:
                if email_field:
                    filters.append(getattr(self.model, email_field) == user["email"])
            
            if filters:
                stmt = select(self.model).where(or_(*filters))
                if hasattr(self.model, "deleted_at"):
                    stmt = stmt.where(self.model.deleted_at == None)
                stmt = stmt.offset(skip).limit(limit)
            else:
                return []
        else:
            stmt = select(self.model)
            if hasattr(self.model, "deleted_at"):
                stmt = stmt.where(self.model.deleted_at == None)
            stmt = stmt.offset(skip).limit(limit)
            
        db_objs = self.session.exec(stmt).all()
        
        # Decrypt and convert JSON fields for all objects
        for db_obj in db_objs:
            db_obj = self._decrypt_fields(db_obj)
            db_obj = self._convert_json_fields_to_objects(db_obj)
        
        return db_objs
    
    def update(self, db_obj: ModelType, obj_in: UpdateSchemaType) -> ModelType:
        """Update record with encryption and ownership enforcement"""
        from app.core.security import current_user_var
        user = current_user_var.get()
        if user and user.get("role") == "customer":
            # Check user_id first
            record_user_id = getattr(db_obj, "user_id", None)
            if record_user_id is not None:
                if record_user_id != user["user_id"]:
                    from fastapi import HTTPException
                    raise HTTPException(status_code=403, detail="You do not have permission to access this resource.")
            else:
                # Fallback to email
                email_val = None
                for field in ["email_address", "email", "email_id"]:
                    if hasattr(db_obj, field):
                        email_val = getattr(db_obj, field)
                        break
                if email_val and email_val.lower() != user["email"].lower():
                    from fastapi import HTTPException
                    raise HTTPException(status_code=403, detail="You do not have permission to access this resource.")
                
        obj_data = obj_in.model_dump(exclude_unset=True) if hasattr(obj_in, 'model_dump') else obj_in.dict(exclude_unset=True)
        
        # Convert lists/dicts to JSON strings
        obj_data = self._convert_json_fields_to_strings(obj_data)
        
        # Encrypt sensitive fields
        obj_data = self._encrypt_fields(obj_data)
        
        # Update timestamp
        from datetime import datetime
        obj_data['updated_at'] = datetime.now()
        
        # Update object
        for field, value in obj_data.items():
            if hasattr(db_obj, field):
                setattr(db_obj, field, value)
        
        self.session.add(db_obj)
        self.session.commit()
        self.session.refresh(db_obj)
        
        # Decrypt and convert JSON fields for response
        db_obj = self._decrypt_fields(db_obj)
        db_obj = self._convert_json_fields_to_objects(db_obj)
        
        return db_obj
    
    def remove(self, id: int) -> bool:
        """Remove record by ID with ownership check"""
        db_obj = self.session.get(self.model, id)
        if db_obj:
            from app.core.security import current_user_var
            user = current_user_var.get()
            if user and user.get("role") == "customer":
                db_obj = self._decrypt_fields(db_obj)
                # Check user_id first
                record_user_id = getattr(db_obj, "user_id", None)
                if record_user_id is not None:
                    if record_user_id != user["user_id"]:
                        from fastapi import HTTPException
                        raise HTTPException(status_code=403, detail="You do not have permission to access this resource.")
                else:
                    # Fallback to email
                    email_val = None
                    for field in ["email_address", "email", "email_id"]:
                        if hasattr(db_obj, field):
                            email_val = getattr(db_obj, field)
                            break
                    if email_val and email_val.lower() != user["email"].lower():
                        from fastapi import HTTPException
                        raise HTTPException(status_code=403, detail="You do not have permission to access this resource.")
                    
            if hasattr(db_obj, "deleted_at"):
                from datetime import datetime
                db_obj.deleted_at = datetime.utcnow()
                self.session.add(db_obj)
            else:
                self.session.delete(db_obj)
            self.session.commit()
            return True
        return False
    
    def search_by_field(self, field_name: str, value: str) -> List[ModelType]:
        """Search by field, supporting in-memory decryption and filtering for encrypted fields"""
        if hasattr(self.model, 'get_encrypted_fields') and field_name in self.model().get_encrypted_fields():
            # For encrypted fields, because encryption is non-deterministic, we must decrypt in-memory and filter
            stmt = select(self.model)
            db_objs = self.session.exec(stmt).all()
            matching_objs = []
            for db_obj in db_objs:
                db_obj = self._decrypt_fields(db_obj)
                db_obj = self._convert_json_fields_to_objects(db_obj)
                field_val = getattr(db_obj, field_name, None)
                if field_val and value.lower() in str(field_val).lower():
                    matching_objs.append(db_obj)
            return matching_objs
        else:
            # Unencrypted field can use normal database contains query
            stmt = select(self.model).where(getattr(self.model, field_name).contains(value))
            db_objs = self.session.exec(stmt).all()
            for db_obj in db_objs:
                db_obj = self._decrypt_fields(db_obj)
                db_obj = self._convert_json_fields_to_objects(db_obj)
            return db_objs