from datetime import datetime
from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from pydantic import BaseModel, EmailStr
from typing import Optional, List

from app.db.session import get_db
from app.db.models import EmailConfig, User
from app.api.deps import get_current_user

router = APIRouter(prefix="/email-configs", tags=["email-configs"])


class EmailConfigCreate(BaseModel):
    name: str
    smtp_host: str
    smtp_port: int
    smtp_user: Optional[str] = None
    smtp_password: Optional[str] = None
    from_email: EmailStr
    from_name: Optional[str] = None
    use_tls: bool = True
    is_default: bool = False


class EmailConfigUpdate(BaseModel):
    name: Optional[str] = None
    smtp_host: Optional[str] = None
    smtp_port: Optional[int] = None
    smtp_user: Optional[str] = None
    smtp_password: Optional[str] = None
    from_email: Optional[EmailStr] = None
    from_name: Optional[str] = None
    use_tls: Optional[bool] = None
    is_default: Optional[bool] = None


class EmailConfigOut(BaseModel):
    id: int
    name: str
    smtp_host: str
    smtp_port: int
    smtp_user: Optional[str] = None
    from_email: str
    from_name: Optional[str] = None
    use_tls: bool
    is_default: bool
    created_at: datetime
    updated_at: datetime
    
    class Config:
        from_attributes = True


@router.post("", response_model=EmailConfigOut, status_code=201)
async def create_email_config(
    data: EmailConfigCreate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """Создать новую email конфигурацию"""
    try:
        # Если это конфигурация по умолчанию, снимаем флаг с других
        if data.is_default:
            db.query(EmailConfig).filter(
                EmailConfig.tenant_id == current_user.tenant_id,
                EmailConfig.is_default == True
            ).update({"is_default": False})
        
        db_email_config = EmailConfig(
            tenant_id=current_user.tenant_id,
            name=data.name,
            smtp_host=data.smtp_host,
            smtp_port=data.smtp_port,
            smtp_user=data.smtp_user,
            smtp_password=data.smtp_password,
            from_email=data.from_email,
            from_name=data.from_name,
            use_tls=data.use_tls,
            is_default=data.is_default
        )
        db.add(db_email_config)
        db.commit()
        db.refresh(db_email_config)
        
        return EmailConfigOut(
            id=db_email_config.id,
            name=db_email_config.name,
            smtp_host=db_email_config.smtp_host,
            smtp_port=db_email_config.smtp_port,
            smtp_user=db_email_config.smtp_user,
            from_email=db_email_config.from_email,
            from_name=db_email_config.from_name,
            use_tls=db_email_config.use_tls,
            is_default=db_email_config.is_default,
            created_at=db_email_config.created_at,
            updated_at=db_email_config.updated_at
        )
    except Exception as e:
        db.rollback()
        raise HTTPException(
            status_code=500,
            detail=f"Ошибка создания email конфигурации: {str(e)}"
        )


@router.get("", response_model=List[EmailConfigOut])
async def list_email_configs(
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """Получить список email конфигураций"""
    configs = db.query(EmailConfig).filter(
        EmailConfig.tenant_id == current_user.tenant_id
    ).all()
    
    result = []
    for config in configs:
        result.append(EmailConfigOut(
            id=config.id,
            name=config.name,
            smtp_host=config.smtp_host,
            smtp_port=config.smtp_port,
            smtp_user=config.smtp_user,
            from_email=config.from_email,
            from_name=config.from_name,
            use_tls=config.use_tls,
            is_default=config.is_default,
            created_at=config.created_at,
            updated_at=config.updated_at
        ))
    
    return result


@router.put("/{config_id}", response_model=EmailConfigOut)
async def update_email_config(
    config_id: int,
    data: EmailConfigUpdate,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """Обновить email конфигурацию"""
    config = db.query(EmailConfig).filter(
        EmailConfig.id == config_id,
        EmailConfig.tenant_id == current_user.tenant_id
    ).first()
    
    if not config:
        raise HTTPException(status_code=404, detail="Email конфигурация не найдена")
    
    if data.name is not None:
        config.name = data.name
    if data.smtp_host is not None:
        config.smtp_host = data.smtp_host
    if data.smtp_port is not None:
        config.smtp_port = data.smtp_port
    if data.smtp_user is not None:
        config.smtp_user = data.smtp_user
    if data.smtp_password is not None:
        config.smtp_password = data.smtp_password
    if data.from_email is not None:
        config.from_email = data.from_email
    if data.from_name is not None:
        config.from_name = data.from_name
    if data.use_tls is not None:
        config.use_tls = data.use_tls
    if data.is_default is not None:
        # Если делаем эту конфигурацию по умолчанию, снимаем флаг с других
        if data.is_default:
            db.query(EmailConfig).filter(
                EmailConfig.tenant_id == current_user.tenant_id,
                EmailConfig.is_default == True,
                EmailConfig.id != config_id
            ).update({"is_default": False})
        config.is_default = data.is_default
    
    config.updated_at = datetime.utcnow()
    db.commit()
    db.refresh(config)
    
    return EmailConfigOut(
        id=config.id,
        name=config.name,
        smtp_host=config.smtp_host,
        smtp_port=config.smtp_port,
        smtp_user=config.smtp_user,
        from_email=config.from_email,
        from_name=config.from_name,
        use_tls=config.use_tls,
        is_default=config.is_default,
        created_at=config.created_at,
        updated_at=config.updated_at
    )


@router.delete("/{config_id}")
async def delete_email_config(
    config_id: int,
    current_user: User = Depends(get_current_user),
    db: Session = Depends(get_db)
):
    """Удалить email конфигурацию"""
    config = db.query(EmailConfig).filter(
        EmailConfig.id == config_id,
        EmailConfig.tenant_id == current_user.tenant_id
    ).first()
    
    if not config:
        raise HTTPException(status_code=404, detail="Email конфигурация не найдена")
    
    db.delete(config)
    db.commit()
    
    return {"ok": True, "message": "Email конфигурация удалена"}