// 1. Add the error middleware
await server.use(PrismErrorMiddleware())

// 2. Throw errors from handlers — they become JSON responses
await server.get("/users/:id") { request in
    let id = request.parameters["id"]!
    guard let user = try db.queryFirst("SELECT * FROM users WHERE id = ?", parameters: [.text(id)]) else {
        throw PrismAppError.notFound("User \(id) not found")
    }
    return .json(user.columns)
}

throw PrismAppError.badRequest("Email is required")       // 400
throw PrismAppError.unauthorized()                        // 401
throw PrismAppError.forbidden("Admin access required")    // 403
throw PrismAppError.notFound("Resource not found")        // 404
throw PrismAppError.conflict("Email already registered")  // 409
throw PrismAppError.internalError()                       // 500

throw PrismAppError(
    status: .badRequest,
    code: "INVALID_EMAIL_DOMAIN",
    message: "Only company emails allowed",
    details: ["allowedDomains": "company.com, corp.com"]
)

await server.use(PrismErrorMiddleware(
    includeStackTrace: false,
    customHandler: { error, request in
        if let dbError = error as? PrismDatabaseError {
            return .json(
                ["error": "DATABASE_ERROR", "message": "A database error occurred"],
                status: .internalServerError
            )
        }
        return nil // Fall through to default handling
    }
))

enum PaymentError: PrismHTTPErrorResponse {
    case insufficientFunds(balance: Double, required: Double)
    case cardDeclined(reason: String)
    case invalidCurrency(String)

    var statusCode: PrismHTTPStatus {
        switch self {
        case .insufficientFunds: .badRequest
        case .cardDeclined: .badRequest
        case .invalidCurrency: .unprocessableEntity
        }
    }

    var errorCode: String {
        switch self {
        case .insufficientFunds: "INSUFFICIENT_FUNDS"
        case .cardDeclined: "CARD_DECLINED"
        case .invalidCurrency: "INVALID_CURRENCY"
        }
    }

    var message: String {
        switch self {
        case .insufficientFunds(let balance, let required):
            "Insufficient funds. Balance: \(balance), required: \(required)"
        case .cardDeclined(let reason):
            "Card declined: \(reason)"
        case .invalidCurrency(let currency):
            "Currency '\(currency)' is not supported"
        }
    }
}

// Usage
await server.post("/pay") { request in
    let balance = 10.0
    let amount = 50.0

    guard balance >= amount else {
        throw PaymentError.insufficientFunds(balance: balance, required: amount)
    }

    return .json(["paid": amount])
}

await server.get("/resource") { request in
    let problem = PrismProblemDetails(
        type: "https://api.example.com/errors/rate-limited",
        title: "Rate Limit Exceeded",
        status: 429,
        detail: "You have exceeded 100 requests per minute",
        instance: request.path
    )
    return problem.toResponse()
}

await server.post("/users") { request in
    // Validation errors return 422 automatically
    let validation = request.validate { v in
        v.field("email", .required, .email)
        v.field("name", .required, .minLength(2))
    }

    if let errorResponse = validation.errorResponse() {
        return errorResponse
    }

    // Business logic errors
    let email = request.formData["email"]!
    let exists = try db.queryFirst(
        "SELECT id FROM users WHERE email = ?",
        parameters: [.text(email)]
    )

    if exists != nil {
        throw PrismAppError.conflict("Email already registered")
    }

    try db.execute(
        "INSERT INTO users (name, email) VALUES (?, ?)",
        parameters: [.text(request.formData["name"]!), .text(email)]
    )

    return .json(["email": email], status: .created)
}