from typing import Optional
from uuid import UUID
from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy import select
import smtplib
import logging
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from pydantic import BaseModel

logger = logging.getLogger(__name__)

from app.database import get_db
from app.models.user import User
from app.models.settings import TenantSettings
from app.schemas.settings import (
    TenantSettingsResponse, 
    TenantSettingsUpdate,
    SMTPTestRequest,
    SMTPTestResponse
)
from app.api.deps import get_current_user
from app.services.email_service import EmailService


class TestAlertEmailRequest(BaseModel):
    recipient_email: str
    alert_type: str = "threshold"
    device_name: str = "جهاز اختباري"
    reading_type: str = "temperature"
    current_value: float = 35.5
    threshold_value: float = 30.0
    condition: str = "above"
    severity: str = "high"

router = APIRouter()


@router.get("")
async def get_settings(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """Get tenant settings"""
    if not current_user.tenant_id:
        raise HTTPException(status_code=400, detail="User has no tenant")
    
    result = await db.execute(
        select(TenantSettings).where(TenantSettings.tenant_id == current_user.tenant_id)
    )
    settings = result.scalar_one_or_none()
    
    if not settings:
        # Create default settings
        settings = TenantSettings(tenant_id=current_user.tenant_id)
        db.add(settings)
        await db.commit()
        await db.refresh(settings)
    
    # إنشاء response مع كلمة المرور
    print(f"=== GET SETTINGS ===")
    print(f"DB smtp_password: {settings.smtp_password}")
    
    response_data = {
        "id": settings.id,
        "tenant_id": settings.tenant_id,
        "smtp_enabled": settings.smtp_enabled,
        "smtp_host": settings.smtp_host,
        "smtp_port": settings.smtp_port,
        "smtp_username": settings.smtp_username,
        "smtp_password": settings.smtp_password or "",
        "smtp_from_email": settings.smtp_from_email,
        "smtp_from_name": settings.smtp_from_name,
        "smtp_use_tls": settings.smtp_use_tls,
        "smtp_use_ssl": settings.smtp_use_ssl,
        "has_smtp_password": bool(settings.smtp_password),
        "alert_email_enabled": settings.alert_email_enabled,
        "alert_email_recipients": settings.alert_email_recipients,
        "alert_sms_enabled": settings.alert_sms_enabled,
        "alert_sms_recipients": settings.alert_sms_recipients,
        "alert_webhook_enabled": settings.alert_webhook_enabled,
        "alert_webhook_url": settings.alert_webhook_url,
        "alert_cooldown_minutes": getattr(settings, 'alert_cooldown_minutes', 15),
        "default_temp_high": settings.default_temp_high,
        "default_temp_low": settings.default_temp_low,
        "default_humidity_high": settings.default_humidity_high,
        "default_humidity_low": settings.default_humidity_low,
        "dashboard_refresh_interval": settings.dashboard_refresh_interval,
        "data_retention_days": settings.data_retention_days,
        "timezone": settings.timezone,
        "language": settings.language,
        "created_at": settings.created_at,
        "updated_at": settings.updated_at,
    }
    
    print(f"Response smtp_password: {response_data['smtp_password']}")
    return response_data


@router.patch("")
async def update_settings(
    data: TenantSettingsUpdate,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """Update tenant settings"""
    if not current_user.tenant_id:
        raise HTTPException(status_code=400, detail="User has no tenant")
    
    result = await db.execute(
        select(TenantSettings).where(TenantSettings.tenant_id == current_user.tenant_id)
    )
    settings = result.scalar_one_or_none()
    
    if not settings:
        settings = TenantSettings(tenant_id=current_user.tenant_id)
        db.add(settings)
    
    # Update fields - لا تكتب فوق كلمة المرور إذا كانت فارغة
    update_data = data.model_dump(exclude_unset=True)
    for field, value in update_data.items():
        # إذا كان الحقل هو smtp_password وكانت القيمة فارغة، لا تحدث
        if field == "smtp_password" and (value is None or value == ""):
            continue
        setattr(settings, field, value)
    
    await db.commit()
    await db.refresh(settings)
    
    # فحص التنبيهات عند تغيير الإعدادات
    if 'alert_cooldown_minutes' in update_data or 'alert_email_enabled' in update_data:
        try:
            from app.tasks.alert_tasks import check_device_alerts
            alert_result = check_device_alerts()
            logger.info(f"Alert check after settings update: {alert_result}")
        except Exception as alert_error:
            logger.error(f"Error checking alerts after settings update: {alert_error}")
    
    # إنشاء response مع كلمة المرور
    response_data = {
        "id": settings.id,
        "tenant_id": settings.tenant_id,
        "smtp_enabled": settings.smtp_enabled,
        "smtp_host": settings.smtp_host,
        "smtp_port": settings.smtp_port,
        "smtp_username": settings.smtp_username,
        "smtp_password": settings.smtp_password or "",
        "smtp_from_email": settings.smtp_from_email,
        "smtp_from_name": settings.smtp_from_name,
        "smtp_use_tls": settings.smtp_use_tls,
        "smtp_use_ssl": settings.smtp_use_ssl,
        "has_smtp_password": bool(settings.smtp_password),
        "alert_email_enabled": settings.alert_email_enabled,
        "alert_email_recipients": settings.alert_email_recipients,
        "alert_sms_enabled": settings.alert_sms_enabled,
        "alert_sms_recipients": settings.alert_sms_recipients,
        "alert_webhook_enabled": settings.alert_webhook_enabled,
        "alert_webhook_url": settings.alert_webhook_url,
        "alert_cooldown_minutes": getattr(settings, 'alert_cooldown_minutes', 15),
        "default_temp_high": settings.default_temp_high,
        "default_temp_low": settings.default_temp_low,
        "default_humidity_high": settings.default_humidity_high,
        "default_humidity_low": settings.default_humidity_low,
        "dashboard_refresh_interval": settings.dashboard_refresh_interval,
        "data_retention_days": settings.data_retention_days,
        "timezone": settings.timezone,
        "language": settings.language,
        "created_at": settings.created_at,
        "updated_at": settings.updated_at,
    }
    return response_data


@router.post("/smtp/test", response_model=SMTPTestResponse)
async def test_smtp(
    data: SMTPTestRequest,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """Test SMTP configuration by sending a test email"""
    # استخدام الإعدادات من الطلب مباشرة أو من قاعدة البيانات
    smtp_host = data.smtp_host
    smtp_port = data.smtp_port or 587
    smtp_username = data.smtp_username
    smtp_password = data.smtp_password
    smtp_from_email = data.smtp_from_email
    smtp_from_name = data.smtp_from_name or "SmartLife"
    smtp_use_tls = data.smtp_use_tls if data.smtp_use_tls is not None else True
    smtp_use_ssl = data.smtp_use_ssl if data.smtp_use_ssl is not None else False
    
    # إذا لم تُرسل الإعدادات، استخدم الإعدادات المحفوظة
    if not smtp_host and current_user.tenant_id:
        result = await db.execute(
            select(TenantSettings).where(TenantSettings.tenant_id == current_user.tenant_id)
        )
        settings = result.scalar_one_or_none()
        
        if settings:
            smtp_host = settings.smtp_host
            smtp_port = settings.smtp_port
            smtp_username = settings.smtp_username
            smtp_password = settings.smtp_password
            smtp_from_email = settings.smtp_from_email
            smtp_from_name = settings.smtp_from_name or "SmartLife"
            smtp_use_tls = settings.smtp_use_tls
            smtp_use_ssl = settings.smtp_use_ssl
    
    if not smtp_host or not smtp_username:
        return SMTPTestResponse(success=False, message="إعدادات SMTP غير مكتملة - يجب تحديد الخادم واسم المستخدم")
    
    if not smtp_password:
        return SMTPTestResponse(success=False, message="يجب تحديد كلمة مرور SMTP")
    
    try:
        print(f"=== SMTP TEST ===")
        print(f"Host: {smtp_host}:{smtp_port}")
        print(f"User: {smtp_username}")
        print(f"From: {smtp_from_email or smtp_username}")
        print(f"To: {data.recipient_email}")
        print(f"TLS: {smtp_use_tls}, SSL: {smtp_use_ssl}")
        
        # Create message
        msg = MIMEMultipart()
        msg['From'] = f"{smtp_from_name} <{smtp_from_email or smtp_username}>"
        msg['To'] = data.recipient_email
        msg['Subject'] = "SmartLife - اختبار إعدادات البريد الإلكتروني"
        
        body = """
        <html>
        <body dir="rtl" style="font-family: Arial, sans-serif;">
            <h2>🎉 تم بنجاح!</h2>
            <p>تم إرسال هذا البريد الإلكتروني للتحقق من صحة إعدادات SMTP الخاصة بك.</p>
            <p>إعدادات البريد الإلكتروني تعمل بشكل صحيح.</p>
            <hr>
            <p style="color: #666; font-size: 12px;">SmartLife Monitoring System</p>
        </body>
        </html>
        """
        msg.attach(MIMEText(body, 'html', 'utf-8'))
        
        # Connect and send
        print(f"Connecting to SMTP server...")
        if smtp_use_ssl:
            server = smtplib.SMTP_SSL(smtp_host, smtp_port, timeout=30)
        else:
            server = smtplib.SMTP(smtp_host, smtp_port, timeout=30)
            if smtp_use_tls:
                print("Starting TLS...")
                server.starttls()
        
        print("Logging in...")
        server.login(smtp_username, smtp_password)
        print("Sending message...")
        server.send_message(msg)
        print("Quitting...")
        server.quit()
        print("✓ Email sent successfully!")
        
        return SMTPTestResponse(success=True, message="تم إرسال البريد الإلكتروني بنجاح")
        
    except smtplib.SMTPAuthenticationError:
        return SMTPTestResponse(success=False, message="فشل في المصادقة - تحقق من اسم المستخدم وكلمة المرور")
    except smtplib.SMTPConnectError:
        return SMTPTestResponse(success=False, message="فشل في الاتصال بخادم SMTP")
    except Exception as e:
        return SMTPTestResponse(success=False, message=f"خطأ: {str(e)}")


@router.get("/smtp", response_model=dict)
async def get_smtp_settings(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """Get SMTP settings only"""
    if not current_user.tenant_id:
        raise HTTPException(status_code=400, detail="User has no tenant")
    
    result = await db.execute(
        select(TenantSettings).where(TenantSettings.tenant_id == current_user.tenant_id)
    )
    settings = result.scalar_one_or_none()
    
    if not settings:
        return {
            "smtp_enabled": False,
            "smtp_host": None,
            "smtp_port": 587,
            "smtp_username": None,
            "smtp_from_email": None,
            "smtp_from_name": None,
            "smtp_use_tls": True,
            "smtp_use_ssl": False
        }
    
    return {
        "smtp_enabled": settings.smtp_enabled,
        "smtp_host": settings.smtp_host,
        "smtp_port": settings.smtp_port,
        "smtp_username": settings.smtp_username,
        "smtp_from_email": settings.smtp_from_email,
        "smtp_from_name": settings.smtp_from_name,
        "smtp_use_tls": settings.smtp_use_tls,
        "smtp_use_ssl": settings.smtp_use_ssl
    }


@router.get("/alerts", response_model=dict)
async def get_alert_settings(
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """Get alert notification settings"""
    if not current_user.tenant_id:
        raise HTTPException(status_code=400, detail="User has no tenant")
    
    result = await db.execute(
        select(TenantSettings).where(TenantSettings.tenant_id == current_user.tenant_id)
    )
    settings = result.scalar_one_or_none()
    
    if not settings:
        return {
            "alert_email_enabled": True,
            "alert_email_recipients": None,
            "alert_sms_enabled": False,
            "alert_sms_recipients": None,
            "alert_webhook_enabled": False,
            "alert_webhook_url": None,
            "default_temp_high": 30,
            "default_temp_low": 10,
            "default_humidity_high": 70,
            "default_humidity_low": 20
        }
    
    return {
        "alert_email_enabled": settings.alert_email_enabled,
        "alert_email_recipients": settings.alert_email_recipients,
        "alert_sms_enabled": settings.alert_sms_enabled,
        "alert_sms_recipients": settings.alert_sms_recipients,
        "alert_webhook_enabled": settings.alert_webhook_enabled,
        "alert_webhook_url": settings.alert_webhook_url,
        "default_temp_high": settings.default_temp_high,
        "default_temp_low": settings.default_temp_low,
        "default_humidity_high": settings.default_humidity_high,
        "default_humidity_low": settings.default_humidity_low
    }


@router.post("/smtp/test-alert", response_model=SMTPTestResponse)
async def test_alert_email(
    data: TestAlertEmailRequest,
    current_user: User = Depends(get_current_user),
    db: AsyncSession = Depends(get_db)
):
    """إرسال إيميل تنبيه تجريبي باستخدام نموذج التنبيهات"""
    print(f"=== TEST ALERT EMAIL REQUEST ===")
    print(f"Recipient: {data.recipient_email}")
    
    if not current_user.tenant_id:
        print("ERROR: User has no tenant")
        raise HTTPException(status_code=400, detail="User has no tenant")
    
    result = await db.execute(
        select(TenantSettings).where(TenantSettings.tenant_id == current_user.tenant_id)
    )
    settings = result.scalar_one_or_none()
    
    if not settings:
        print("ERROR: No settings found for tenant")
        return SMTPTestResponse(success=False, message="لم يتم العثور على إعدادات")
    
    print(f"Settings found: smtp_enabled={settings.smtp_enabled}")
    print(f"SMTP: host={settings.smtp_host}, port={settings.smtp_port}, user={settings.smtp_username}")
    print(f"SMTP password exists: {bool(settings.smtp_password)}")
    
    if not settings.smtp_enabled:
        print("ERROR: SMTP is not enabled")
        return SMTPTestResponse(success=False, message="SMTP غير مفعل - يرجى تفعيله أولاً من تبويب SMTP")
    
    if not settings.smtp_host:
        print("ERROR: No SMTP host")
        return SMTPTestResponse(success=False, message="يرجى إدخال خادم SMTP")
    if not settings.smtp_username:
        print("ERROR: No SMTP username")
        return SMTPTestResponse(success=False, message="يرجى إدخال اسم المستخدم SMTP")
    if not settings.smtp_password:
        print("ERROR: No SMTP password")
        return SMTPTestResponse(success=False, message="يرجى إدخال كلمة مرور SMTP")
    
    try:
        print("Creating EmailService...")
        email_service = EmailService(settings)
        print(f"EmailService created. Sending to: {data.recipient_email}")
        sent = email_service.send_alert_email(
            to_emails=[data.recipient_email],
            alert_type=data.alert_type,
            device_name=data.device_name,
            device_id="TEST-001",
            reading_type=data.reading_type,
            current_value=data.current_value,
            threshold_value=data.threshold_value,
            condition=data.condition,
            severity=data.severity,
            location="موقع تجريبي"
        )
        
        print(f"Emails sent count: {sent}")
        logger.info(f"Emails sent: {sent}")
        
        if sent > 0:
            return SMTPTestResponse(success=True, message="تم إرسال إيميل التنبيه التجريبي بنجاح")
        else:
            return SMTPTestResponse(success=False, message="فشل في إرسال الإيميل - تحقق من إعدادات SMTP")
            
    except Exception as e:
        logger.error(f"Error sending test alert: {str(e)}")
        return SMTPTestResponse(success=False, message=f"خطأ: {str(e)}")