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

    File: TLSCertificateChain.cpp
    Date: 2022-8-27
    Author: Reece
***/
#include "TLS.hpp"
#include "TLSCertificateChain.hpp"

namespace Aurora::IO::TLS
{
    CertificateChain::CertificateChain()
    {

    }

    CertificateChain::~CertificateChain()
    {
        ::mbedtls_x509_crt_free(&this->ownCertificate);
    }

    AuUInt32 CertificateChain::GetCertificateCount()
    {
        return 0;
    }

    AuMemoryViewRead CertificateChain::GetCertificate(AuUInt32 idx)
    {
        return {};
    }

    bool CertificateChain::Init(const AuList<AuByteBuffer> &certs)
    {
        int iRet {};

        this->pCertificate = &this->ownCertificate;
        ::mbedtls_x509_crt_init(&this->ownCertificate);

        for (const auto &cert : certs)
        {
            iRet = ::mbedtls_x509_crt_parse(&this->ownCertificate,
                                            (const unsigned char *)cert.base,
                                            cert.length);
            if (iRet != 0)
            {
                SysPushErrorCrypto("Failed to parse certificate chain: {}", iRet);
                return false;
            }
        }

        return this->Precache();
    }

    bool CertificateChain::Init(const AuList<AuMemoryViewRead> &certs)
    {
        int iRet {};

        this->pCertificate = &this->ownCertificate;
        ::mbedtls_x509_crt_init(&this->ownCertificate);

        for (const auto &cert : certs)
        {
            iRet = ::mbedtls_x509_crt_parse(&this->ownCertificate,
                                            (const unsigned char *)cert.ToPointer(),
                                            cert.length);
            if (iRet != 0)
            {
                SysPushErrorCrypto("Failed to parse certificate chain: {}", iRet);
                return false;
            }
        }

        return this->Precache();
    }

    bool CertificateChain::Init(const AuMemoryViewRead &cert)
    {
        int iRet {};

        this->pCertificate = &this->ownCertificate;
        ::mbedtls_x509_crt_init(&this->ownCertificate);

        iRet = ::mbedtls_x509_crt_parse(&this->ownCertificate,
                                        (const unsigned char *)cert.ToPointer(),
                                        cert.length);
        if (iRet != 0)
        {
            SysPushErrorCrypto("Failed to parse certificate chain: {}", iRet);
            return false;
        }

        return this->Precache();
    }

    bool CertificateChain::Init(const mbedtls_x509_crt *pCert)
    {
        this->pCertificate = &this->ownCertificate;
        return this->Precache();
    }

    bool CertificateChain::Precache()
    {
        return true;
    }

    AUKN_SYM AuSPtr<ICertificateChain> ChainFromOne(const AuMemoryViewRead &read)
    {
        auto pCertificateChain = AuMakeShared<CertificateChain>();
        if (!pCertificateChain)
        {
            SysPushErrorMemory();
            return {};
        }

        if (!pCertificateChain->Init(read))
        {
            return {};
        }

        return pCertificateChain;
    }

    AUKN_SYM AuSPtr<ICertificateChain> ChainFromMany(const AuList<AuMemoryViewRead> &read)
    {
        auto pCertificateChain = AuMakeShared<CertificateChain>();
        if (!pCertificateChain)
        {
            SysPushErrorMemory();
            return {};
        }

        if (!pCertificateChain->Init(read))
        {
            return {};
        }

        return pCertificateChain;
    }
}