/*
 * Copyright (C) 2023 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "key_utils.h"
#include <securec.h>
#include "config.h"
#include "params_parser.h"
#include "log.h"
#include "memory.h"
#include "utils.h"

HcfResult CopyAsyKeyParamsSpec(const HcfAsyKeyParamsSpec *srcSpec, HcfAsyKeyParamsSpec *destSpec)
{
    if (srcSpec == NULL || srcSpec->algName == NULL || destSpec == NULL) {
        LOGE("Invalid input parameter.");
        return HCF_INVALID_PARAMS;
    }
    size_t srcAlgNameLen = HcfStrlen(srcSpec->algName);
    if (!srcAlgNameLen) {
        LOGE("algName is empty!");
        return HCF_INVALID_PARAMS;
    }
    destSpec->algName = (char *)HcfMalloc(srcAlgNameLen + 1, 0);
    if (destSpec->algName == NULL) {
        LOGE("Failed to allocate alg name memory");
        return HCF_ERR_MALLOC;
    }
    (void)memcpy_s(destSpec->algName, srcAlgNameLen, srcSpec->algName, srcAlgNameLen);
    destSpec->specType = srcSpec->specType;
    return HCF_SUCCESS;
}

HcfResult CopyPoint(const HcfPoint *src, HcfPoint *dest)
{
    if (src == NULL || src->x.data == NULL || src->x.len == 0 ||
        src->y.data == NULL || src->y.len == 0 || dest == NULL) {
        LOGE("Invalid input parameter.");
        return HCF_INVALID_PARAMS;
    }
    dest->x.data = (unsigned char *)HcfMalloc(src->x.len, 0);
    if (dest->x.data == NULL) {
        LOGE("Failed to allocate x data memory");
        return HCF_ERR_MALLOC;
    }
    dest->y.data = (unsigned char *)HcfMalloc(src->y.len, 0);
    if (dest->y.data == NULL) {
        LOGE("Failed to allocate y data memory");
        HcfFree(dest->x.data);
        dest->x.data = NULL;
        return HCF_ERR_MALLOC;
    }
    (void)memcpy_s(dest->x.data, src->x.len, src->x.data, src->x.len);
    (void)memcpy_s(dest->y.data, src->y.len, src->y.data, src->y.len);
    dest->x.len = src->x.len;
    dest->y.len = src->y.len;
    return HCF_SUCCESS;
}

static HcfResult CopyEcField(const HcfECField *src, HcfECField **dest)
{
    if (src == NULL || src->fieldType == NULL || dest == NULL) {
        LOGE("Invalid input parameter.");
        return HCF_INVALID_PARAMS;
    }
    HcfECField *tmpField = (HcfECField *)HcfMalloc(sizeof(HcfECFieldFp), 0);
    if (tmpField == NULL) {
        LOGE("Alloc memory failed.");
        return HCF_ERR_MALLOC;
    }
    size_t srcFieldTypeLen = HcfStrlen(src->fieldType);
    if (!srcFieldTypeLen) {
        LOGE("fieldType is empty!");
        HcfFree(tmpField);
        return HCF_INVALID_PARAMS;
    }
    tmpField->fieldType = (char *)HcfMalloc(srcFieldTypeLen + 1, 0);
    if (tmpField->fieldType == NULL) {
        LOGE("Failed to allocate field memory.");
        HcfFree(tmpField);
        return HCF_ERR_MALLOC;
    }
    HcfECFieldFp *tmpDest = (HcfECFieldFp *)(tmpField);
    HcfECFieldFp *tmpSrc = (HcfECFieldFp *)(src);
    tmpDest->p.data = (unsigned char *)HcfMalloc(tmpSrc->p.len, 0);
    if (tmpDest->p.data == NULL) {
        LOGE("Failed to allocate b data memory");
        HcfFree(tmpField->fieldType);
        HcfFree(tmpField);
        return HCF_ERR_MALLOC;
    }
    (void)memcpy_s(tmpField->fieldType, srcFieldTypeLen, src->fieldType, srcFieldTypeLen);
    (void)memcpy_s(tmpDest->p.data, tmpSrc->p.len, tmpSrc->p.data, tmpSrc->p.len);
    tmpDest->p.len = tmpSrc->p.len;
    *dest = tmpField;
    return HCF_SUCCESS;
}

HcfResult CopyEccCommonSpec(const HcfEccCommParamsSpec *srcSpec, HcfEccCommParamsSpec *destSpec)
{
    if (srcSpec == NULL || srcSpec->a.data == NULL || srcSpec->a.len == 0 || srcSpec->b.data == NULL ||
        srcSpec->b.len == 0 || srcSpec->n.data == NULL || srcSpec->n.len == 0 || destSpec == NULL) {
        LOGE("Invalid input parameter.");
        return HCF_INVALID_PARAMS;
    }
    if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(destSpec->base)) != HCF_SUCCESS) {
        LOGE("Failed to copy src common spec");
        return HCF_INVALID_PARAMS;
    }
    destSpec->a.data = (unsigned char *)HcfMalloc(srcSpec->a.len, 0);
    if (destSpec->a.data == NULL) {
        LOGE("Failed to allocate a data memory");
        FreeEccCommParamsSpec(destSpec);
        return HCF_ERR_MALLOC;
    }
    destSpec->b.data = (unsigned char *)HcfMalloc(srcSpec->b.len, 0);
    if (destSpec->b.data == NULL) {
        LOGE("Failed to allocate b data memory");
        FreeEccCommParamsSpec(destSpec);
        return HCF_ERR_MALLOC;
    }
    destSpec->n.data = (unsigned char *)HcfMalloc(srcSpec->n.len, 0);
    if (destSpec->n.data == NULL) {
        LOGE("Failed to allocate n data memory");
        FreeEccCommParamsSpec(destSpec);
        return HCF_ERR_MALLOC;
    }
    HcfResult res = CopyEcField(srcSpec->field, &(destSpec->field));
    if (res != HCF_SUCCESS) {
        LOGE("Failed to allocate field data memory");
        FreeEccCommParamsSpec(destSpec);
        return HCF_ERR_MALLOC;
    }
    res = CopyPoint(&(srcSpec->g), &(destSpec->g));
    if (res != HCF_SUCCESS) {
        LOGE("Failed to allocate field data memory");
        FreeEccCommParamsSpec(destSpec);
        return HCF_ERR_MALLOC;
    }
    destSpec->h = srcSpec->h;
    (void)memcpy_s(destSpec->a.data, srcSpec->a.len, srcSpec->a.data, srcSpec->a.len);
    (void)memcpy_s(destSpec->b.data, srcSpec->b.len, srcSpec->b.data, srcSpec->b.len);
    (void)memcpy_s(destSpec->n.data, srcSpec->n.len, srcSpec->n.data, srcSpec->n.len);
    destSpec->a.len = srcSpec->a.len;
    destSpec->b.len = srcSpec->b.len;
    destSpec->n.len = srcSpec->n.len;
    return HCF_SUCCESS;
}

HcfResult CreateEccCommonSpecImpl(const HcfEccCommParamsSpec *srcSpec, HcfEccCommParamsSpec **destSpec)
{
    if (srcSpec == NULL || destSpec == NULL) {
        LOGE("Invalid input parameter.");
        return HCF_INVALID_PARAMS;
    }
    HcfEccCommParamsSpec *tmpSpec = (HcfEccCommParamsSpec *)HcfMalloc(sizeof(HcfEccCommParamsSpec), 0);
    if (tmpSpec == NULL) {
        LOGE("Failed to allocate dest spec memory");
        return HCF_ERR_MALLOC;
    }
    if (CopyEccCommonSpec(srcSpec, tmpSpec) != HCF_SUCCESS) {
        LOGE("CreateEccCommonSpecImpl error!");
        HcfFree(tmpSpec);
        return HCF_INVALID_PARAMS;
    }
    *destSpec = tmpSpec;
    return HCF_SUCCESS;
}

HcfResult CopyDhCommonSpec(const HcfDhCommParamsSpec *srcSpec, HcfDhCommParamsSpec *destSpec)
{
    if (CopyAsyKeyParamsSpec(&(srcSpec->base), &(destSpec->base)) != HCF_SUCCESS) {
        LOGE("Failed to copy src common spec");
        return HCF_INVALID_PARAMS;
    }
    destSpec->p.data = (unsigned char *)HcfMalloc(srcSpec->p.len, 0);
    if (destSpec->p.data == NULL) {
        LOGE("Failed to allocate p data memory");
        FreeDhCommParamsSpec(destSpec);
        return HCF_ERR_MALLOC;
    }

    destSpec->g.data = (unsigned char *)HcfMalloc(srcSpec->g.len, 0);
    if (destSpec->g.data == NULL) {
        LOGE("Failed to allocate g data memory");
        FreeDhCommParamsSpec(destSpec);
        return HCF_ERR_MALLOC;
    }
    destSpec->length = srcSpec->length;
    (void)memcpy_s(destSpec->p.data, srcSpec->p.len, srcSpec->p.data, srcSpec->p.len);
    (void)memcpy_s(destSpec->g.data, srcSpec->g.len, srcSpec->g.data, srcSpec->g.len);
    destSpec->p.len = srcSpec->p.len;
    destSpec->g.len = srcSpec->g.len;
    return HCF_SUCCESS;
}

HcfResult CreateDhCommonSpecImpl(const HcfDhCommParamsSpec *srcSpec, HcfDhCommParamsSpec **destSpec)
{
    HcfDhCommParamsSpec *spec = (HcfDhCommParamsSpec *)HcfMalloc(sizeof(HcfDhCommParamsSpec), 0);
    if (spec == NULL) {
        LOGE("Failed to allocate dest spec memory");
        return HCF_ERR_MALLOC;
    }

    if (CopyDhCommonSpec(srcSpec, spec) != HCF_SUCCESS) {
        LOGE("Failed to copy src spec");
        HcfFree(spec);
        return HCF_INVALID_PARAMS;
    }

    *destSpec = spec;
    return HCF_SUCCESS;
}