response.h

/*
 * SPDX-FileCopyrightText: (C) 2013-2023 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#pragma once

#include <Cutelyst/cutelyst_export.h>
#include <Cutelyst/headers.h>

#include <QtCore/QIODevice>

class QNetworkCookie;

namespace Cutelyst {

class Context;
class Engine;
class EngineRequest;
class ResponsePrivate;
class CUTELYST_EXPORT Response final : public QIODevice
{
    Q_OBJECT
    Q_DECLARE_PRIVATE(Response)
public:
    enum HttpStatus {
        Continue                     = 100,
        SwitchingProtocols           = 101,
        OK                           = 200,
        Created                      = 201,
        Accepted                     = 202,
        NonAuthoritativeInformation  = 203,
        NoContent                    = 204,
        ResetContent                 = 205,
        PartialContent               = 206,
        MultiStatus                  = 207,
        MultipleChoices              = 300,
        MovedPermanently             = 301,
        Found                        = 302,
        SeeOther                     = 303, // Since HTTP/1.1
        NotModified                  = 304,
        UseProxy                     = 305, // Since HTTP/1.1
        TemporaryRedirect            = 307, // Since HTTP/1.1
        PermanentRedirect            = 308, // Since HTTP/1.1
        BadRequest                   = 400,
        Unauthorized                 = 401,
        PaymentRequired              = 402,
        Forbidden                    = 403,
        NotFound                     = 404,
        MethodNotAllowed             = 405,
        NotAcceptable                = 406,
        ProxyAuthenticationRequired  = 407,
        RequestTimeout               = 408,
        Conflict                     = 409,
        Gone                         = 410,
        LengthRequired               = 411,
        PreconditionFailed           = 412,
        RequestEntityTooLarge        = 413,
        RequestURITooLong            = 414,
        UnsupportedMediaType         = 415,
        RequestedRangeNotSatisfiable = 416,
        ExpectationFailed            = 417,
        InternalServerError          = 500,
        NotImplemented               = 501,
        BadGateway                   = 502,
        ServiceUnavailable           = 503,
        GatewayTimeout               = 504,
        HTTPVersionNotSupported      = 505,
        BandwidthLimitExceeded       = 509
    };
    Q_ENUM(HttpStatus)

    
    enum CloseCode {
        CloseCodeNormal                = 1000,
        CloseCodeGoingAway             = 1001,
        CloseCodeProtocolError         = 1002,
        CloseCodeDatatypeNotSupported  = 1003,
        CloseCodeReserved1004          = 1004,
        CloseCodeMissingStatusCode     = 1005,
        CloseCodeAbnormalDisconnection = 1006,
        CloseCodeWrongDatatype         = 1007,
        CloseCodePolicyViolated        = 1008,
        CloseCodeTooMuchData           = 1009,
        CloseCodeMissingExtension      = 1010,
        CloseCodeBadOperation          = 1011,
        CloseCodeTlsHandshakeFailed    = 1015
    };
    Q_ENUM(CloseCode)

    
    virtual ~Response() override;

    quint16 status() const noexcept;

    void setStatus(quint16 status) noexcept;

    bool hasBody() const noexcept;

    [[nodiscard]] QByteArray &body();

    QIODevice *bodyDevice() const noexcept;

    void setBody(QIODevice *body);

    void setBody(const QByteArray &body);

    inline void setBody(const QString &body);

    inline void setBody(QStringView body);

    void setCborBody(const QByteArray &cbor);

    void setCborValueBody(const QCborValue &value);

    inline void setJsonBody(QStringView json);

    void setJsonBody(const QByteArray &json);

    void setJsonObjectBody(const QJsonObject &obj);

    void setJsonArrayBody(const QJsonArray &array);

    QByteArray contentEncoding() const noexcept;

    void setContentEncoding(const QByteArray &encoding);

    qint64 contentLength() const;

    QByteArray contentType() const;

    void setContentType(const QByteArray &type) { headers().setContentType(type); }

    QByteArray contentTypeCharset() const;

    QVariant cookie(const QByteArray &name) const;

    QList<QNetworkCookie> cookies() const;

    void setCookie(const QNetworkCookie &cookie);

    void setCookies(const QList<QNetworkCookie> &cookies);

    int removeCookies(const QByteArray &name);

    void redirect(const QUrl &url, quint16 status = Found);

    void redirect(const QString &url, quint16 status = Found);

    void redirectSafe(const QUrl &url, const QUrl &fallback);

    QUrl location() const noexcept;

    QByteArray header(const QByteArray &field) const noexcept;

    void setHeader(const QByteArray &key, const QByteArray &value);

    Headers &headers() noexcept;

    bool isFinalized() const noexcept;

    bool isFinalizedHeaders() const noexcept;

    bool isSequential() const noexcept override;

    qint64 size() const noexcept override;

    bool webSocketHandshake(const QByteArray &key      = {},
                            const QByteArray &origin   = {},
                            const QByteArray &protocol = {});

    bool webSocketTextMessage(const QString &message);

    bool webSocketBinaryMessage(const QByteArray &message);

    bool webSocketPing(const QByteArray &payload = {});

    bool webSocketClose(quint16 code = Response::CloseCodeNormal, const QString &reason = {});

protected:
    explicit Response(const Headers &defaultHeaders, EngineRequest *conn = nullptr);

    virtual qint64 writeData(const char *data, qint64 len) override;

    virtual qint64 readData(char *data, qint64 maxlen) override;

    ResponsePrivate *d_ptr;
    friend class Application;
    friend class Engine;
    friend class EngineConnection;
    friend class Context;
    friend class ContextPrivate;
};

inline void Response::setBody(const QString &_body)
{
    setBody(_body.toUtf8());
}

inline void Response::setBody(QStringView _body)
{
    setBody(_body.toUtf8());
}

inline void Response::setJsonBody(QStringView _body)
{
    setJsonBody(_body.toUtf8());
}

} // namespace Cutelyst