from typing import List, Optional
from sqlmodel import Session, select
from app.core.base_repository import BaseRepository
from app.models.LifeInsuranceModel import LifeInsuranceModel
from app.schemas.LifeinsuranceSchema import LifeInsuranceCreate, LifeInsuranceUpdate
from app.utils.transaction_generator import generate_transaction_number
import json

class LifeInsuranceRepository(BaseRepository[LifeInsuranceModel, LifeInsuranceCreate, LifeInsuranceUpdate]):
    def __init__(self, session: Session):
        super().__init__(LifeInsuranceModel, session)

    def create(self, obj_in: LifeInsuranceCreate) -> LifeInsuranceModel:
        obj_data = obj_in.model_dump()
        
        # Generate transaction number
        obj_data['transaction_no'] = generate_transaction_number('life')
        
        # Convert lists to JSON strings for storage
        if obj_data.get('existing_conditions'):
            obj_data['existing_conditions'] = json.dumps(obj_data['existing_conditions'])
        if obj_data.get('medications'):
            obj_data['medications'] = json.dumps(obj_data['medications'])
        if obj_data.get('family_history'):
            obj_data['family_history'] = json.dumps(obj_data['family_history'])
        if obj_data.get('riders'):
            obj_data['riders'] = json.dumps(obj_data['riders'])
        
        # Encrypt sensitive fields
        obj_data = self._encrypt_fields(obj_data)
        
        db_obj = self.model(**obj_data)
        created_obj = super().create_db_object(db_obj)
        
        # Convert JSON fields back to lists for response
        self._convert_json_fields_to_lists(created_obj)
        return created_obj

    def update(self, db_obj: LifeInsuranceModel, obj_in: LifeInsuranceUpdate) -> LifeInsuranceModel:
        obj_data = obj_in.model_dump(exclude_unset=True)
        
        # Convert lists to JSON strings for storage
        if 'riders' in obj_data and obj_data['riders']:
            obj_data['riders'] = json.dumps(obj_data['riders'])
        
        updated_obj = super().update(db_obj, obj_in)
        
        # Convert JSON fields back to lists for response
        self._convert_json_fields_to_lists(updated_obj)
        return updated_obj

    def get(self, id: int) -> Optional[LifeInsuranceModel]:
        db_obj = super().get(id)
        if db_obj:
            self._convert_json_fields_to_lists(db_obj)
        return db_obj

    def get_multi(self, skip: int = 0, limit: int = 100) -> List[LifeInsuranceModel]:
        db_objs = super().get_multi(skip=skip, limit=limit)
        for db_obj in db_objs:
            self._convert_json_fields_to_lists(db_obj)
        return db_objs

    def _convert_json_fields_to_lists(self, db_obj: LifeInsuranceModel):
        """Convert JSON string fields back to Python lists"""
        json_fields = ['existing_conditions', 'medications', 'family_history', 'riders']
        
        for field in json_fields:
            field_value = getattr(db_obj, field, None)
            if field_value and isinstance(field_value, str):
                try:
                    setattr(db_obj, field, json.loads(field_value))
                except (json.JSONDecodeError, TypeError):
                    setattr(db_obj, field, [])

    def search_by_name(self, name: str) -> List[LifeInsuranceModel]:
        results = self.search_by_field("full_name", name)
        for result in results:
            self._convert_json_fields_to_lists(result)
        return results

    def search_by_email(self, email: str) -> List[LifeInsuranceModel]:
        results = self.search_by_field("email_address", email)
        for result in results:
            self._convert_json_fields_to_lists(result)
        return results

    def get_by_status(self, status: str) -> List[LifeInsuranceModel]:
        stmt = select(self.model).where(self.model.quote_status == status)
        results = self.session.exec(stmt).all()
        for result in results:
            self._convert_json_fields_to_lists(result)
        return results

    def get_by_coverage_amount_range(self, min_amount: float, max_amount: float) -> List[LifeInsuranceModel]:
        stmt = select(self.model).where(
            self.model.coverage_amount >= min_amount,
            self.model.coverage_amount <= max_amount
        )
        results = self.session.exec(stmt).all()
        for result in results:
            self._convert_json_fields_to_lists(result)
        return results