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

    File: RSA.hpp
    Date: 2021-7-1
    Author: Reece
***/
#pragma once
#include <tomcrypt.h>
#include <Crypto.hpp>
#include <Extensions/LTC/LTCExtensions.hpp>

namespace Aurora::Crypto::RSA
{
    static bool ExportRSAKey(const rsa_key &key, EKeyType side, ERSAKeyType type, AuList<AuUInt8> &out)
    {
        int flags = 0;

        if (type == ERSAKeyType::eRsaKey)
        {
            flags |= kRsaFlagPKCS1;
        }

        if (side == EKeyType::eKeyPublic)
        {
            flags |= kRsaFlagPublic;
        }

        if (!TryResize(out, 4096))
        {
            return false;
        }

        unsigned long actualSize = out.size();
        auto ret = rsa_pkcs8_export(out.data(), &actualSize, &key, flags);

        if (ret != CRYPT_OK)
        {
            SysPushErrorCrypt("{}", ret);
            return false;
        }

        out.resize(actualSize);
        return true;
    }
    
    static bool ImportRSAKey(rsa_key &in, const RSAKey &rsakey)
    {
        int flags{};
    
        if (rsakey.meta.type == ERSAKeyType::eCert)
        {
            if (rsakey.meta.side == EKeyType::eKeyPrivate)
            {
                SysPushErrorArg("Attempted to import a certificate as a private key.");
                return false;
            }

            auto ret = rsa_import_x509(rsakey.blob.data(), rsakey.blob.size(), &in);
            if (ret != CRYPT_OK)
            {
                SysPushErrorCrypt("{}", ret);
                return false;
            }

            return true;
        }

        if (rsakey.meta.type == ERSAKeyType::eRsaKey)
        {
            flags |= kRsaFlagPKCS1;
        }

        if (rsakey.meta.side == EKeyType::eKeyPublic)
        {
            flags |= kRsaFlagPublic;
        }

        auto ret = rsa_import_ex(rsakey.blob.data(), rsakey.blob.size(), &in, flags);
        if (ret != CRYPT_OK)
        {
            SysPushErrorCrypt("{}", ret);
            return false;
        }

        return true;
    }

    static int PaddingToType(EPaddingType type)
    {
        switch (type)
        {
        case EPaddingType::ePaddingNone:
            return 0;
        case EPaddingType::ePKCS_1_5:
            return LTC_PKCS_1_V1_5;
        case EPaddingType::ePKCS_1_5_NA1:
            return LTC_PKCS_1_V1_5_NA1;
        case EPaddingType::ePKCS_OAEP:
            return LTC_PKCS_1_OAEP;
        case EPaddingType::ePKCS_1_PSS:
            return LTC_PKCS_1_PSS;
        default:
            return 0xFF;
        }
    }

    static int HashMethodToId(EHashType type)
    {
        switch (type)
        {
        case EHashType::eTiger_24_192:
            return ::Crypto::gHashTiger;
        case EHashType::eSHA1_20_160:
            return ::Crypto::gHashSha1;
        case EHashType::eSHA2_32_256:
            return ::Crypto::gHashSha256;
        case EHashType::eSHA2_64_512:
            return ::Crypto::gHashSha512;
        default:
            return 0xFF;
        }
    }
}