Notifications

async def send_task_completion_notification(
    self,
    account_id: str,
    task_name: str,
    thread_id: str,
    agent_name: Optional[str] = None,
    result_summary: Optional[str] = None
) -> Dict[str, Any]:
    # Check if user is actively viewing the thread
    should_send = await presence_service.should_send_notification(
        account_id=account_id,
        thread_id=thread_id,
        channel="email"
    )
    
    if not should_send:
        logger.info(f"Suppressing notification (user actively viewing thread)")
        return {"success": False, "reason": "User is actively viewing thread"}
    
    # Get account info
    account_info = await self._get_account_info(account_id)
    
    # Build task URL
    task_url = f"https://www.kortix.com/projects/{project_id}/thread/{thread_id}"
    
    # Trigger Novu workflow
    result = await self.novu.trigger_workflow(
        workflow_id="task-completed",
        subscriber_id=account_id,
        payload={
            "first_name": account_info.get("first_name"),
            "task_name": task_name,
            "task_url": task_url
        },
        subscriber_email=account_info.get("email"),
        subscriber_name=account_info.get("name")
    )
    
    return {"success": True, "result": result}

async def send_task_failed_notification(
    self,
    account_id: str,
    task_name: str,
    task_url: str,
    failure_reason: str,
    first_name: Optional[str] = None,
    thread_id: Optional[str] = None
) -> Dict[str, Any]:
    # Check presence if thread_id provided
    if thread_id:
        should_send = await presence_service.should_send_notification(
            account_id=account_id,
            thread_id=thread_id,
            channel="email"
        )
        
        if not should_send:
            return {"success": False, "reason": "User actively viewing"}
    
    account_info = await self._get_account_info(account_id)
    
    result = await self.novu.trigger_workflow(
        workflow_id="task-failed",
        subscriber_id=account_id,
        payload={
            "first_name": first_name or account_info.get("first_name"),
            "task_name": task_name,
            "task_url": task_url,
            "failure_reason": failure_reason
        },
        subscriber_email=account_info.get("email"),
        subscriber_name=account_info.get("name")
    )
    
    return {"success": True, "result": result}

async def send_welcome_email(self, account_id: str) -> Dict[str, Any]:
    account_info = await self._get_account_info(account_id)
    
    if not account_info or not account_info.get("email"):
        return {"success": False, "error": "No email found"}
    
    result = await self.novu.trigger_workflow(
        workflow_id="welcome-email",
        subscriber_id=account_id,
        subscriber_email=account_info.get("email"),
        subscriber_name=account_info.get("name"),
        avatar=account_info.get("avatar")
    )
    
    if not result:
        return {"success": False, "error": "Failed to trigger workflow"}
    
    return {"success": True, "result": result}

async def send_referral_code_notification(
    self,
    recipient_email: str,
    referral_url: str,
    inviter_id: str,
) -> Dict[str, Any]:
    inviter_info = await self._get_account_info(inviter_id)
    
    if not inviter_info or not inviter_info.get("email"):
        return {"success": False, "error": "Inviter not found"}
    
    inviter_name = inviter_info.get("name", "A friend")
    recipient_name = self._extract_name_from_email(recipient_email)
    
    success = email_service.send_referral_email(
        recipient_email=recipient_email,
        recipient_name=recipient_name,
        sender_name=inviter_name,
        referral_url=referral_url
    )
    
    if success:
        return {"success": True}
    else:
        return {"success": False, "error": "Failed to send email"}

# Check if user is actively viewing the thread
should_send = await presence_service.should_send_notification(
    account_id=account_id,
    thread_id=thread_id,
    channel="email"
)

if not should_send:
    logger.info(f"Suppressing notification (user actively viewing)")
    return {"success": False, "reason": "User is actively viewing thread"}

result = await self.novu.trigger_workflow(
    workflow_id="task-completed",
    subscriber_id=account_id,
    payload={
        "first_name": account_info.get("first_name"),
        "task_name": task_name,
        "task_url": task_url
    },
    subscriber_email=account_info.get("email"),
    subscriber_name=account_info.get("name")
)

async def trigger_workflow_admin(
    self,
    workflow_id: str,
    payload_template: Dict[str, Any],
    subscriber_id: Optional[str] = None,
    subscriber_email: Optional[str] = None,
    broadcast: bool = False
) -> Dict[str, Any]:
    if broadcast:
        return await self._broadcast_workflow(workflow_id, payload_template)
    elif subscriber_email:
        return await self._trigger_workflow_by_email(workflow_id, payload_template, subscriber_email)
    elif subscriber_id:
        return await self._trigger_workflow_for_user(workflow_id, payload_template, subscriber_id)
    else:
        raise ValueError("Either subscriber_id, subscriber_email, or broadcast=True required")

def _replace_template_variables(
    self,
    payload_template: Dict[str, Any],
    account_info: Dict[str, Any]
) -> Dict[str, Any]:
    template_str = json.dumps(payload_template)
    
    replacements = {
        "{{email}}": account_info.get("email", ""),
        "{{name}}": account_info.get("name", ""),
        "{{first_name}}": account_info.get("first_name", ""),
        "{{phone}}": account_info.get("phone", ""),
        "{{avatar}}": account_info.get("avatar", ""),
    }
    
    for variable, value in replacements.items():
        template_str = template_str.replace(variable, str(value) if value else "")
    
    return json.loads(template_str)

@router.post("/webhooks/novu")
async def handle_novu_webhook(request: Request):
    payload = await request.json()
    
    event_type = payload.get('type')
    
    if event_type == 'notification.sent':
        logger.info(f"Notification sent: {payload.get('transactionId')}")
    elif event_type == 'notification.failed':
        logger.warning(f"Notification failed: {payload.get('transactionId')}")
    elif event_type == 'subscriber.created':
        logger.info(f"Subscriber created: {payload.get('subscriberId')}")
    
    return {"status": "ok"}

async def _get_account_info(self, account_id: str) -> Dict[str, Any]:
    client = await self.db.client
    
    # Get user from Supabase Auth
    user = await client.auth.admin.get_user_by_id(account_id)
    
    if user and user.user:
        email = user.user.email
        user_metadata = user.user.user_metadata or {}
        
        name = (
            user_metadata.get('full_name') or
            user_metadata.get('name') or
            user_metadata.get('display_name') or
            (email.split('@')[0] if email else None)
        )
        
        phone = user_metadata.get('phone') or user_metadata.get('phone_number')
        avatar = user_metadata.get('avatar_url') or user_metadata.get('picture')
    
    return {
        "email": email,
        "name": name,
        "phone": phone,
        "avatar": avatar,
        "first_name": name.split()[0] if name else "User"
    }

def check_notifications_enabled():
    if config.ENV_MODE != EnvMode.STAGING:
        raise HTTPException(
            status_code=403,
            detail=f"Notifications only available in staging mode"
        )