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

    File: HMAC.cpp
    Date: 2022-9-18
    Author: Reece
***/
#include <Source/RuntimeInternal.hpp>
#include <Source/Crypto/Crypto.hpp>
#include "HMAC.hpp"

namespace Aurora::Crypto::HMAC
{
    HMACContext::HMACContext(AuHashing::EHashType type) :
        type_(type)
    {
    }
    
    void HMACContext::Ingest(const Memory::MemoryViewRead &input)
    {
        SysAssert(::hmac_process(&this->state_, (const unsigned char *)input.ptr, input.length) != CRYPT_OK);
    }
    
    Memory::MemoryViewRead HMACContext::Finalize()
    {
        unsigned long outLength {};
        if (::hmac_done(&this->state_, this->buffer_, &outLength) != CRYPT_OK)
        {
            SysPushErrorCrypt();
            return {};
        }

        this->bFinished_ = true;

        return { this->buffer_, outLength };
    }
    
    void HMACContext::Reset()
    {
        AuMemcpy(&this->state_, &this->referenceState_, sizeof(this->state_));
        this->bFinished_ = false;
    }

    bool HMACContext::Init(const Memory::MemoryViewRead &input)
    {
        int iRet {};

        int hash = ::Crypto::HashMethodToId(this->type_);
        if (hash == 0xFF)
        {
            SysPushErrorCrypt("invalid hash {}", AuUInt(this->type_));
            return false;
        }

        iRet = ::hmac_init(&this->referenceState_, hash, (const unsigned char *)input.ptr, input.length);
        if (iRet != CRYPT_OK)
        {
            SysPushErrorCrypt("error {}", iRet);
            return false;
        }

        Reset();
        return true;
    }

    AUKN_SYM IHMACContext *HMACNew(AuHashing::EHashType algorithm,
                                   const Memory::MemoryViewRead &sharedSecret)
    {
        auto pContext = _new HMACContext(algorithm);
        if (!pContext)
        {
            SysPushErrorMemory();
            return {};
        }

        if (!pContext->Init(sharedSecret))
        {
            return {};
        }

        return pContext;
    }

    AUKN_SYM void HMACRelease(IHMACContext *pContext)
    {
        AuSafeDelete<HMACContext *>(pContext);
    }
}