"""Business Insurance repository for database operations."""
from typing import List, Dict, Any

from sqlmodel import Session

from app.schemas.BusinessInsuranceSchema import BusinessInsuranceCreate
from app.utils.transaction_generator import generate_transaction_number
from app.services.coverage_mapper import coverage_mapper


class BusinessInsuranceRepository:
    """Repository for business insurance operations."""
    
    def __init__(self, session: Session):
        self.session = session
    
    def create(self, obj_in: BusinessInsuranceCreate) -> Dict[str, Any]:
        """Create individual coverage records in their respective tables."""
        business_info_dict = {
            "business_name": obj_in.business_info.business_name,
            "est_year": obj_in.business_info.est_year,
            "tax_id": obj_in.business_info.tax_id,
            "business_type": obj_in.business_info.business_type,
            "industry": obj_in.business_info.industry,
            "employees": obj_in.business_info.employees,
            "annual_revenue": obj_in.business_info.annual_revenue,
            "street": obj_in.business_info.street,
            "city": obj_in.business_info.city,
            "state": obj_in.business_info.state,
            "zip_code": obj_in.business_info.zip,
            "owner_name": obj_in.business_info.owner_name,
            "title": obj_in.business_info.title,
            "owner_mobile": obj_in.business_info.owner_mobile,
            "owner_email": obj_in.business_info.owner_email,
        }
        
        # Create individual coverage records
        created_records = self._create_coverage_records(
            obj_in.selected_coverages.coverages, 
            obj_in.coverage_data, 
            business_info_dict
        )
        
        return {
            "business_name": business_info_dict["business_name"],
            "transaction_no": generate_transaction_number('business'),
            "created_coverages": created_records,
            "status": "success"
        }

    # def search_by_business_name(self, business_name: str) -> List[BusinessInsuranceModel]:
    #     """Search by business name."""
    #     return self.search_by_field("business_name", business_name)

    # def search_by_email(self, email: str) -> List[BusinessInsuranceModel]:
    #     """Search by owner email address."""
    #     return self.search_by_field("owner_email", email)

    # def get_by_state(self, state: str) -> List[BusinessInsuranceModel]:
    #     """Get records by state."""
    #     stmt = select(self.model).where(self.model.state == state)
    #     results = self.session.exec(stmt).all()
    #     for result in results:
    #         result = self._decrypt_fields(result)
    #         result = self._convert_json_fields_to_objects(result)
    #     return results

    # def get_by_status(self, status: str) -> List[BusinessInsuranceModel]:
    #     """Get records by quote status."""
    #     stmt = select(self.model).where(self.model.quote_status == status)
    #     results = self.session.exec(stmt).all()
    #     for result in results:
    #         result = self._decrypt_fields(result)
    #         result = self._convert_json_fields_to_objects(result)
    #     return results

    # def get_by_industry(self, industry: str) -> List[BusinessInsuranceModel]:
    #     """Get records by industry."""
    #     stmt = select(self.model).where(self.model.industry == industry)
    #     results = self.session.exec(stmt).all()
    #     for result in results:
    #         result = self._decrypt_fields(result)
    #         result = self._convert_json_fields_to_objects(result)
    #     return results

    # def get_by_coverage_type(self, coverage_type: str) -> List[BusinessInsuranceModel]:
    #     """Get records by coverage type."""
    #     stmt = select(self.model).where(self.model.coverages.contains(coverage_type))
    #     results = self.session.exec(stmt).all()
    #     for result in results:
    #         result = self._decrypt_fields(result)
    #         result = self._convert_json_fields_to_objects(result)
    #     return results
    
    def _create_coverage_records(self, selected_coverages: List[str], coverage_data: Dict[str, Any], business_info: Dict[str, Any]) -> Dict[str, Any]:
        """Create individual coverage records for each selected coverage type."""
        created_records = {}
        
        for coverage_type in selected_coverages:
            if coverage_type in coverage_data:
                coverage_record = coverage_mapper.create_coverage_record(
                    coverage_type, 
                    coverage_data[coverage_type], 
                    business_info
                )
                if coverage_record:
                    try:
                        self.session.add(coverage_record)
                        self.session.commit()
                        self.session.refresh(coverage_record)
                        created_records[coverage_type] = {
                            "id": coverage_record.id,
                            "status": "created"
                        }
                    except Exception as e:
                        self.session.rollback()
                        created_records[coverage_type] = {
                            "status": "failed",
                            "error": str(e)
                        }
        
        return created_records