response.h

/*
 * SPDX-FileCopyrightText: (C) 2013-2022 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#ifndef CUTELYST_RESPONSE_H
#define CUTELYST_RESPONSE_H

#include <QtCore/QIODevice>

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

class QNetworkCookie;

namespace Cutelyst {

class Context;
class Engine;
class EngineRequest;
class ResponsePrivate;
class CUTELYST_LIBRARY 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;

    Q_REQUIRED_RESULT QByteArray &body();

    QIODevice *bodyDevice() const;

    void setBody(QIODevice *body);

    void setBody(const QByteArray &body);

    inline void setBody(const QString &body);

    void setJsonBody(const QJsonDocument &documment);

    void setJsonBody(const QString &json);

    void setJsonBody(const QByteArray &json);

    void setJsonObjectBody(const QJsonObject &object);

    void setJsonArrayBody(const QJsonArray &array);

    QString contentEncoding() const;

    void setContentEncoding(const QString &encoding);

    qint64 contentLength() const;

    void setContentLength(qint64 length);

    QString contentType() const;

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

    QString 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;

    QString header(const QString &field) const;

    void setHeader(const QString &field, const QString &value);

    Headers &headers() noexcept;

    bool isFinalizedHeaders() const noexcept;

    virtual bool isSequential() const noexcept override;

    virtual qint64 size() const noexcept override;

    bool webSocketHandshake(const QString &key = {}, const QString &origin = {}, const QString &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());
}

}

#endif // CUTELYST_RESPONSE_H