from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session

from app.database import get_db
from app.models.db_models import Account
from app.schemas.schemas import (
    AccountCreate,
    AccountListResponse,
    AccountResponse,
    AccountUpdate,
)
from app.services.encryption import decrypt, encrypt
from app.services.imap_client import async_test_connection

router = APIRouter(prefix="/api/accounts", tags=["accounts"])


@router.get("/", response_model=list[AccountListResponse])
def list_accounts(db: Session = Depends(get_db)):
    accounts = db.query(Account).order_by(Account.name).all()
    result = []
    for acc in accounts:
        data = AccountListResponse.model_validate(acc)
        data.filter_rule_count = len(acc.filter_rules)
        result.append(data)
    return result


@router.get("/{account_id}", response_model=AccountResponse)
def get_account(account_id: int, db: Session = Depends(get_db)):
    account = db.get(Account, account_id)
    if not account:
        raise HTTPException(404, "Konto nicht gefunden")
    return account


@router.post("/", response_model=AccountResponse, status_code=201)
def create_account(data: AccountCreate, db: Session = Depends(get_db)):
    account_data = data.model_dump()
    account_data["password"] = encrypt(account_data["password"])
    if account_data.get("smtp_password"):
        account_data["smtp_password"] = encrypt(account_data["smtp_password"])
    account = Account(**account_data)
    db.add(account)
    db.commit()
    db.refresh(account)
    return account


@router.put("/{account_id}", response_model=AccountResponse)
def update_account(account_id: int, data: AccountUpdate, db: Session = Depends(get_db)):
    account = db.get(Account, account_id)
    if not account:
        raise HTTPException(404, "Konto nicht gefunden")
    for key, value in data.model_dump(exclude_unset=True).items():
        if key == "password" and value:
            value = encrypt(value)
        elif key == "smtp_password" and value:
            value = encrypt(value)
        setattr(account, key, value)
    db.commit()
    db.refresh(account)
    return account


@router.delete("/{account_id}", status_code=204)
def delete_account(account_id: int, db: Session = Depends(get_db)):
    account = db.get(Account, account_id)
    if not account:
        raise HTTPException(404, "Konto nicht gefunden")
    db.delete(account)
    db.commit()


@router.post("/{account_id}/test")
async def test_account_connection(account_id: int, db: Session = Depends(get_db)):
    account = db.get(Account, account_id)
    if not account:
        raise HTTPException(404, "Konto nicht gefunden")
    success = await async_test_connection(
        host=account.imap_host,
        port=account.imap_port,
        username=account.username,
        password=decrypt(account.password),
        use_ssl=account.use_ssl,
    )
    return {"success": success, "message": "Verbindung erfolgreich" if success else "Verbindung fehlgeschlagen"}


@router.post("/{account_id}/poll-now")
async def poll_now(account_id: int, db: Session = Depends(get_db)):
    account = db.get(Account, account_id)
    if not account:
        raise HTTPException(404, "Konto nicht gefunden")
    from app.services.scheduler import poll_account
    await poll_account(account_id)
    return {"message": f"Polling für '{account.name}' durchgeführt"}