from typing import List, Optional
from backend.models.models import EmailSenderDoc
from common.log.module_logger import ModuleLogger


class EmailSenderHandler:
    def __init__(self):
        self.module_logger = ModuleLogger(sender_id="EmailSenderHandler")

    async def get_email_senders(self, tenant_id: str) -> List[str]:
        """get email senders for tenant"""
        try:
            doc = await EmailSenderDoc.find_one({"tenant_id": tenant_id, "is_active": True})
            return doc.email_senders if doc else []
        except Exception as e:
            await self.module_logger.log_error(
                error="Failed to get email senders",
                properties={"tenant_id": tenant_id, "error": str(e)}
            )
            return []

    async def set_email_senders(self, tenant_id: str, email_senders: List[str]):
        """set email senders for tenant"""
        try:
            doc = await EmailSenderDoc.find_one({"tenant_id": tenant_id})
            if doc:
                await doc.set({"email_senders": email_senders})
                await self.module_logger.log_info(
                    info="Email senders set in database",
                    properties={
                        "tenant_id": tenant_id,
                        "sender_count": len(email_senders)
                    }
                )
                return {"success": True, "email_senders": email_senders}
            else:
                doc = EmailSenderDoc(tenant_id=tenant_id, email_senders=email_senders)
                await doc.create()
                await self.module_logger.log_info(
                    info="Email sender doc created with senders",
                    properties={
                        "tenant_id": tenant_id,
                        "sender_count": len(email_senders)
                    }
                )
                return {"success": True, "email_senders": doc.email_senders}
        except Exception as e:
            await self.module_logger.log_error(
                error="Failed to set email senders",
                properties={
                    "tenant_id": tenant_id,
                    "error": str(e)
                }
            )
            raise

    async def add_email_senders(self, tenant_id: str, new_senders: List[str]):
        """add email senders to tenant"""
        try:
            if not new_senders or not isinstance(new_senders, list):
                return {"success": False, "msg": "No sender provided"}

            doc = await EmailSenderDoc.find_one({"tenant_id": tenant_id, "is_active": True})
            if doc:
                original_set = set(doc.email_senders)
                new_set = set(new_senders)
                to_add = new_set - original_set
                if not to_add:
                    return {"success": False, "msg": "All senders already exist"}    
                updated_list = list(original_set | new_set)
                await doc.set({"email_senders": updated_list})
                await self.module_logger.log_info(
                    info="Email senders added to database",
                    properties={
                        "tenant_id": tenant_id,
                        "added_count": len(to_add),
                        "total_count": len(updated_list)
                    }
                )
                return {"success": True, "email_senders": updated_list}
            else:
                doc = EmailSenderDoc(tenant_id=tenant_id, email_senders=new_senders)
                await doc.create()
                await self.module_logger.log_info(
                    info="Email sender doc created with new senders",
                    properties={
                        "tenant_id": tenant_id,
                        "sender_count": len(new_senders)
                    }
                )
                return {"success": True, "email_senders": doc.email_senders}
        except Exception as e:
            await self.module_logger.log_error(
                error="Failed to add email senders",
                properties={
                    "tenant_id": tenant_id,
                    "error": str(e)
                }
            )
            raise

    async def remove_email_senders(self, tenant_id: str, emails_to_remove: List[str]):
        """remove email senders from tenant"""
        try:
            doc = await EmailSenderDoc.find_one({"tenant_id": tenant_id, "is_active": True})
            if not doc or not doc.email_senders:
                return {"success": False, "msg": "No sender found"}
            
            original_count = len(doc.email_senders)
            doc.email_senders = [s for s in doc.email_senders if s not in emails_to_remove]
            if len(doc.email_senders) == original_count:
                return {"success": False, "msg": "No sender matched for removal"}
            
            await doc.set({"email_senders": doc.email_senders})
            await self.module_logger.log_info(
                info="Email senders removed from database",
                properties={
                    "tenant_id": tenant_id,
                    "removed_count": original_count - len(doc.email_senders),
                    "remaining_count": len(doc.email_senders)
                }
            )
            return {"success": True, "remaining": doc.email_senders}
        except Exception as e:
            await self.module_logger.log_error(
                error="Failed to remove email senders",
                properties={
                    "tenant_id": tenant_id,
                    "error": str(e)
                }
            )
            raise

    async def clear_email_senders(self, tenant_id: str):
        """clear up email senders for tenant"""
        try:
            doc = await EmailSenderDoc.find_one({"tenant_id": tenant_id, "is_active": True})
            if doc:
                await doc.set({"email_senders": []})
                await self.module_logger.log_info(
                    info="Email senders cleared from database",
                    properties={"tenant_id": tenant_id}
                )
                return {"success": True}
            return {"success": False, "msg": "No sender config found"}
        except Exception as e:
            await self.module_logger.log_error(
                error="Failed to clear email senders",
                properties={
                    "tenant_id": tenant_id,
                    "error": str(e)
                }
            )
            raise

    async def delete_email_sender(self, tenant_id: str):
        """delete email sender for tenant"""
        try:
            doc = await EmailSenderDoc.find_one({"tenant_id": tenant_id})
            if doc:
                await doc.delete()
                await self.module_logger.log_info(
                    info="Email sender configuration deleted from database",
                    properties={"tenant_id": tenant_id}
                )
                return {"success": True}
            return {"success": False, "msg": "No sender config found"}
        except Exception as e:
            await self.module_logger.log_error(
                error="Failed to delete email sender",
                properties={
                    "tenant_id": tenant_id,
                    "error": str(e)
                }
            )
            raise