AuroraRuntime/Include/Aurora/IO/TLS/ITLSContext.hpp

/***
    Copyright (C) 2022 J Reece Wilson (a/k/a "Reece"). All rights reserved.

    File: ITLSContext.hpp
    Date: 2022-8-24
    Author: Reece
***/
#pragma once

namespace Aurora::IO::Protocol
{
    struct IProtocolStack;
}

namespace Aurora::IO::Net
{
    struct ISocket;
}

#include <Aurora/IO/Net/ETransportProtocol.hpp>

namespace Aurora::IO::TLS
{
    struct TLSMeta
    {
        AuUInt uOutPageSize {};
        AuString sSNIServerName;
        bool bIsClient { true };
        AuNet::ETransportProtocol transportProtocol { AuNet::ETransportProtocol::eProtocolTCP };
        AuSPtr<IPinCertificate> pCertPin;
        TLSPrivateKey privateKey;
        AuList<AuUInt16> cipherSuites;
    };

    struct ITLSContext
    {
        /**
         * @brief Returns the protocol stack provided to NewTLSContextEx
         * @return 
        */
        virtual AuSPtr<Protocol::IProtocolStack> ToReadStack() = 0;

        /**
         * @brief Returns the protocol stack provided to NewTLSContextEx
         * @return 
        */
        virtual AuSPtr<Protocol::IProtocolStack> ToWriteStack() = 0;

        /**
         * @brief 
         * @return 
        */
        virtual AuSPtr<Protocol::IProtocolInterceptorEx> GetRecvInterceptor() = 0;

        /**
         * @brief 
         * @return 
        */
        virtual AuSPtr<Protocol::IProtocolInterceptorEx> GetSendInterceptor() = 0;

        /**
         * @brief Attaches the context to a socket such that
         *        1) the sockets inbound protocol is specified as this->ToReadStack()
         *        2) the sockets outbound protocol is specified as this->ToWriteStack()
         *        3) a weak reference is attached internally for internal shutdown/error triggers
         * 
         * This is optional. You could just use a buffered protocol stack
         * 
         * @param pSocket 
         * @warning reminder: Creating a tls context is to merely add interceptors to a new protocol stack.
         *                    This function is a hybrid utility that does one internal action and calls
         *                    ISocketChannel::SpecifyRecvProtocol, ISocketChannel::SpecifySendProtocol to
         *                    activate the protocol stack on the socket (if not already).
        */
        virtual void Attach(const AuSPtr<Net::ISocket> &pSocket) = 0;

        /**
         * @brief 
        */
        virtual void StartHandshake() = 0;

        /**
         * @brief 
        */
        virtual void StartClose() = 0;

        /**
         * @brief 
         * @return 
        */
        virtual bool HasCompletedHandshake() = 0;

        /**
         * @brief 
         * @return 
        */
        virtual bool HasFailed() = 0;

        /**
         * @brief 
         * @return 
        */
        virtual bool HasEnded() = 0;

        /**
         * @brief 
         * @return 
        */
        virtual int GetFatalErrorCode() = 0;

        /**
         * @brief
        */
        virtual void Destroy() = 0;
    };

    AUKN_SYM AuSPtr<ITLSContext> NewTLSContext(const TLSMeta &meta);
    
    /**
     * @brief 
     * @param pSendStack 
     *                   A buffered or socket protocol stack to add one extended TLS intercepter to
     * @param pRecvStack 
     *                   A buffered or socket protocol stack to add one extended TLS intercepter to
     * @param meta 
     * @return 
    */
    AUKN_SYM AuSPtr<ITLSContext> NewTLSContextEx(const AuSPtr<Protocol::IProtocolStack> &pSendStack,
                                                 const AuSPtr<Protocol::IProtocolStack> &pRecvStack,
                                                 const TLSMeta &meta);
}