from fastapi import APIRouter, Depends, HTTPException, status
from sqlalchemy.orm import Session
from starlette.requests import Request

from app.core.rbac import require_permission
from app.db.database import get_db
from app.models.repair import Repair
from app.models.repair_estimate import RepairEstimate
from app.models.user import User
from app.repositories.repair_estimate_repository import RepairEstimateRepository
from app.repositories.repair_repository import RepairRepository
from app.schemas.lexware import LexwareInvoicePreparationResponse, LexwareSettingsResponse, LexwareSettingsUpdate, LexwareTestConnectionResponse
from app.services.lexware_service import LexwareService

router = APIRouter(tags=["Lexware"])


def get_repair_or_404(db: Session, repair_id: int) -> Repair:
    repair = RepairRepository.get_by_id(db, repair_id)
    if repair is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Reparatur nicht gefunden")
    return repair


def get_estimate_or_404(db: Session, repair_id: int, estimate_id: int) -> RepairEstimate:
    estimate = RepairEstimateRepository.get(db, repair_id=repair_id, estimate_id=estimate_id)
    if estimate is None:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Kostenvoranschlag nicht gefunden")
    return estimate


@router.get("/lexware/settings", response_model=LexwareSettingsResponse)
def get_lexware_settings(
    db: Session = Depends(get_db),
    current_user: User = Depends(require_permission("lexware.read")),
):
    return LexwareService.get_settings(db)


@router.put("/lexware/settings", response_model=LexwareSettingsResponse)
def update_lexware_settings(
    payload: LexwareSettingsUpdate,
    request: Request,
    db: Session = Depends(get_db),
    current_user: User = Depends(require_permission("lexware.manage")),
):
    return LexwareService.update_settings(db, payload, actor=current_user, request=request)


@router.post("/lexware/test-connection", response_model=LexwareTestConnectionResponse)
def test_lexware_connection(
    request: Request,
    db: Session = Depends(get_db),
    current_user: User = Depends(require_permission("lexware.manage")),
):
    return LexwareService.test_connection(db, actor=current_user, request=request)


@router.post("/repairs/{repair_id}/estimates/{estimate_id}/lexware/prepare-invoice", response_model=LexwareInvoicePreparationResponse)
def prepare_lexware_invoice(
    repair_id: int,
    estimate_id: int,
    request: Request,
    db: Session = Depends(get_db),
    current_user: User = Depends(require_permission("lexware.export")),
):
    repair = get_repair_or_404(db, repair_id)
    estimate = get_estimate_or_404(db, repair_id, estimate_id)
    return LexwareService.prepare_invoice(db, repair, estimate, actor=current_user, request=request)