"""Repository for BusinessInsuranceModel operations."""
from typing import List, Optional
from sqlmodel import Session, select
from app.models.BusinessInsuranceModel import BusinessInsuranceModel
from app.schemas.BusinessInsuranceMainSchema import BusinessInsuranceMainCreate, BusinessInsuranceMainUpdate
from app.utils.transaction_generator import generate_transaction_number
from app.core.encryption import encryption_service


class BusinessInsuranceMainRepository:
    """Repository for business insurance main operations."""
    
    def __init__(self, session: Session):
        self.session = session

    def _decrypt_fields(self, db_obj: Optional[BusinessInsuranceModel]) -> Optional[BusinessInsuranceModel]:
        """Decrypt sensitive fields of BusinessInsuranceModel"""
        if not db_obj:
            return db_obj
        
        for field in ["owner_email", "owner_mobile", "tax_id"]:
            val = getattr(db_obj, field, None)
            if val:
                try:
                    setattr(db_obj, field, encryption_service.decrypt(val))
                except Exception:
                    # Fallback to original value if decryption fails
                    pass
        return db_obj
    
    def create(self, payload: BusinessInsuranceMainCreate, user_id: Optional[int] = None) -> BusinessInsuranceModel:
        """Create a new business insurance record."""
        # Extract data from payload
        business_info = payload.business_info
        insurance_history = payload.insurance_history
        selected_coverages = payload.selected_coverages
        coverage_data = payload.coverage_data or {}
        risk_factors = payload.risk_factors
        coverage_preferences = payload.coverage_preferences
        additional_info = payload.additional_info
        
        # Create business insurance record
        business_insurance = BusinessInsuranceModel(
            user_id=user_id,
            # Business Information
            business_name=business_info.business_name,
            est_year=business_info.est_year,
            tax_id=encryption_service.encrypt(business_info.tax_id),
            business_type=business_info.business_type,
            industry=business_info.industry,
            employees=business_info.employees,
            annual_revenue=business_info.annual_revenue,
            street=business_info.street,
            city=business_info.city,
            state=business_info.state,
            zip_code=business_info.zip_code,
            owner_name=business_info.owner_name,
            title=business_info.title,
            owner_mobile=encryption_service.encrypt(business_info.owner_mobile),
            owner_email=encryption_service.encrypt(business_info.owner_email),
            
            # Insurance History
            reason=insurance_history.reason,
            has_insurance=insurance_history.has_insurance,
            has_claims_5y=insurance_history.has_claims_5y,
            current_provider=insurance_history.current_provider,
            policy_expiry=insurance_history.policy_expiry,
            
            # Selected Coverages
            coverages=str(selected_coverages.coverages),
            coverage_types=selected_coverages.coverage_types,
            
            # Coverage Data
            bop_data=coverage_data.get("bop"),
            auto_data=coverage_data.get("auto"),
            property_data=coverage_data.get("property"),
            cyber_data=coverage_data.get("cyber"),
            gl_data=coverage_data.get("gl"),
            group_health_data=coverage_data.get("groupHealth"),
            group_life_data=coverage_data.get("groupLife"),
            ocean_data=coverage_data.get("ocean"),
            eando_data=coverage_data.get("eando"),
            umbrella_data=coverage_data.get("umbrella"),
            workers_data=coverage_data.get("workers"),
            
            # Additional Data
            risk_factors=risk_factors,
            coverage_preferences=coverage_preferences,
            additional_info=additional_info,
            consent_accepted=payload.consent_accepted,
            hipaa_accepted=payload.hipaa_accepted,
            
            # System fields
            transaction_no=generate_transaction_number("BUS"),
            quote_status="Draft"
        )
        
        self.session.add(business_insurance)
        self.session.commit()
        self.session.refresh(business_insurance)
        return self._decrypt_fields(business_insurance)
    
    def get_by_id(self, business_id: int) -> Optional[BusinessInsuranceModel]:
        """Get business insurance by ID."""
        return self._decrypt_fields(self.session.get(BusinessInsuranceModel, business_id))
    
    def get_by_transaction_no(self, transaction_no: str) -> Optional[BusinessInsuranceModel]:
        """Get business insurance by transaction number."""
        statement = select(BusinessInsuranceModel).where(
            BusinessInsuranceModel.transaction_no == transaction_no
        )
        return self._decrypt_fields(self.session.exec(statement).first())
    
    def get_all(self, skip: int = 0, limit: int = 100) -> List[BusinessInsuranceModel]:
        """Get all business insurance records."""
        statement = select(BusinessInsuranceModel).offset(skip).limit(limit)
        results = self.session.exec(statement).all()
        for res in results:
            self._decrypt_fields(res)
        return results
    
    def get(self, business_id: int) -> Optional[BusinessInsuranceModel]:
        """Get business insurance by ID (alias for get_by_id)."""
        return self.get_by_id(business_id)
    
    def list(self, skip: int = 0, limit: int = 100, transaction_no: Optional[str] = None, quote_status: Optional[str] = None, user_id: Optional[int] = None) -> List[BusinessInsuranceModel]:
        """List business insurance records with filters."""
        statement = select(BusinessInsuranceModel)
        
        if user_id is not None:
            statement = statement.where(BusinessInsuranceModel.user_id == user_id)
        if transaction_no:
            statement = statement.where(BusinessInsuranceModel.transaction_no == transaction_no)
        if quote_status:
            statement = statement.where(BusinessInsuranceModel.quote_status == quote_status)
            
        statement = statement.offset(skip).limit(limit)
        results = self.session.exec(statement).all()
        for res in results:
            self._decrypt_fields(res)
        return results
    
    def update(self, business_id: int, payload: BusinessInsuranceMainUpdate) -> Optional[BusinessInsuranceModel]:
        """Update business insurance record."""
        business_insurance = self.session.get(BusinessInsuranceModel, business_id)
        if not business_insurance:
            return None
        
        # Update fields from payload
        if payload.business_info:
            business_info = payload.business_info
            business_insurance.business_name = business_info.business_name
            business_insurance.est_year = business_info.est_year
            business_insurance.tax_id = encryption_service.encrypt(business_info.tax_id)
            business_insurance.business_type = business_info.business_type
            business_insurance.industry = business_info.industry
            business_insurance.employees = business_info.employees
            business_insurance.annual_revenue = business_info.annual_revenue
            business_insurance.street = business_info.street
            business_insurance.city = business_info.city
            business_insurance.state = business_info.state
            business_insurance.zip_code = business_info.zip_code
            business_insurance.owner_name = business_info.owner_name
            business_insurance.title = business_info.title
            business_insurance.owner_mobile = encryption_service.encrypt(business_info.owner_mobile)
            business_insurance.owner_email = encryption_service.encrypt(business_info.owner_email)
        
        if payload.coverage_data:
            for coverage_type, data in payload.coverage_data.items():
                field_name = f"{coverage_type}_data"
                if hasattr(business_insurance, field_name):
                    setattr(business_insurance, field_name, data)
        
        if payload.quote_status:
            business_insurance.quote_status = payload.quote_status
        
        self.session.add(business_insurance)
        self.session.commit()
        self.session.refresh(business_insurance)
        return self._decrypt_fields(business_insurance)
    
    def delete(self, business_id: int) -> bool:
        """Delete business insurance record."""
        # Retrieve without decryption to perform deletion
        business_insurance = self.session.get(BusinessInsuranceModel, business_id)
        if not business_insurance:
            return False
        
        self.session.delete(business_insurance)
        self.session.commit()
        return True