/*
 * 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 <iostream>
#include <cstring>
#include "ffi_utils.h"
#include "serial_struct.h"

namespace Hdc {

char *StringToHeapPtr(const std::string &input)
{
    size_t buf_size = input.length() + 1;
    char *bufRet = (char *)malloc(buf_size);
    if (bufRet == nullptr) {
        return bufRet;
    }
    (void)memset_s(bufRet, buf_size, 0, buf_size);
    (void)memcpy_s(bufRet, buf_size, input.c_str(), buf_size);
    return bufRet;
}

extern "C" SerializedBuffer SerializeSessionHandShake(const RustStruct::SessionHandShake &value)
{
    BaseStruct::SessionHandShake shs = {
        .banner = string(value.banner),
        .authType = value.authType,
        .sessionId = value.sessionId,
        .connectKey = string(value.connectKey),
        .buf = string(value.buf),
        .version = string(value.version)
    };
    string serialized = Hdc::SerialStruct::SerializeToString(shs);
    size_t len = serialized.length();
    char *ptr = StringToHeapPtr(serialized);
    return SerializedBuffer{ptr, len};
}

extern "C" SerializedBuffer SerializePayloadProtect(const RustStruct::PayloadProtect &value)
{
    BaseStruct::PayloadProtect pp = {
        .channelId = value.channelId,
        .commandFlag = value.commandFlag,
        .checkSum = value.checkSum,
        .vCode = value.vCode
    };
    string serialized = Hdc::SerialStruct::SerializeToString(pp);
    size_t len = serialized.length();
    char *ptr = StringToHeapPtr(serialized);
    return SerializedBuffer{ptr, len};
}

extern "C" SerializedBuffer SerializeTransferConfig(const RustStruct::TransferConfig &value)
{
    BaseStruct::TransferConfig tc = {
        .fileSize = value.fileSize,
        .atime = value.atime,
        .mtime = value.mtime,
        .options = string(value.options),
        .path = string(value.path),
        .optionalName = string(value.optionalName),
        .updateIfNew = static_cast<bool>(value.updateIfNew),
        .compressType = value.compressType,
        .holdTimestamp = static_cast<bool>(value.holdTimestamp),
        .functionName = string(value.functionName),
        .clientCwd = string(value.clientCwd),
        .reserve1 = string(value.reserve1),
        .reserve2 = string(value.reserve2)
    };
    string serialized = Hdc::SerialStruct::SerializeToString(tc);
    size_t len = serialized.length();
    char *ptr = StringToHeapPtr(serialized);
    return SerializedBuffer{ptr, len};
}

extern "C" SerializedBuffer SerializeFileMode(const RustStruct::FileMode &value)
{
    BaseStruct::FileMode fm = {
        .perm = value.perm,
        .u_id = value.u_id,
        .g_id = value.g_id,
        .context = string(value.context),
        .fullName = string(value.context)
    };
    string serialized = Hdc::SerialStruct::SerializeToString(fm);
    size_t len = serialized.length();
    char *ptr = StringToHeapPtr(serialized);
    return SerializedBuffer{ptr, len};
}

extern "C" SerializedBuffer SerializeTransferPayload(const RustStruct::TransferPayload &value)
{
    BaseStruct::TransferPayload tp = {
        .index = value.index,
        .compressType = value.compressType,
        .compressSize = value.compressSize,
        .uncompressSize = value.uncompressSize
    };
    string serialized = Hdc::SerialStruct::SerializeToString(tp);
    size_t len = serialized.length();
    char *ptr = StringToHeapPtr(serialized);
    return SerializedBuffer{ptr, len};
}

extern "C" SerializedBuffer SerializePayloadHead(RustStruct::PayloadHead &value)
{
    size_t len = sizeof(value);
    char *ptr = (char *)malloc(len);
    if (ptr == nullptr) {
        return SerializedBuffer{ptr, len};
    }
    (void)memcpy_s(ptr, len, reinterpret_cast<char *>(&value), len);
    return SerializedBuffer{ptr, len};
}

extern "C" SerializedBuffer SerializeUsbHead(RustStruct::USBHead &value)
{
    size_t len = sizeof(value);
    char *ptr = (char *)malloc(len);
    if (ptr == nullptr) {
        return SerializedBuffer{ptr, len};
    }
    (void)memcpy_s(ptr, len, reinterpret_cast<char *>(&value), len);
    return SerializedBuffer{ptr, len};
}

extern "C" SerializedBuffer SerializeUartHead(RustStruct::UartHead &value)
{
    size_t len = sizeof(value);
    char *ptr = (char *)malloc(len);
    if (ptr == nullptr) {
        return SerializedBuffer{ptr, len};
    }
    (void)memcpy_s(ptr, len, reinterpret_cast<char *>(&value), len);
    return SerializedBuffer{ptr, len};
}

extern "C" uint8_t ParseSessionHandShake(RustStruct::SessionHandShake &value, SerializedBuffer buf)
{
    BaseStruct::SessionHandShake shs = {};
    if (!SerialStruct::ParseFromString(shs, string(buf.ptr, buf.size))) {
        return 0;
    }
    value = {
        .banner = StringToHeapPtr(shs.banner),
        .authType = shs.authType,
        .sessionId = shs.sessionId,
        .connectKey = StringToHeapPtr(shs.connectKey),
        .buf = StringToHeapPtr(shs.buf),
        .version = StringToHeapPtr(shs.version)
    };
    return 1;
}

extern "C" uint8_t ParsePayloadProtect(RustStruct::PayloadProtect &value, SerializedBuffer buf)
{
    BaseStruct::PayloadProtect pp = {};
    if (!SerialStruct::ParseFromString(pp, string(buf.ptr, buf.size))) {
        return 0;
    }
    value = {
        .channelId = pp.channelId,
        .commandFlag = pp.commandFlag,
        .checkSum = pp.checkSum,
        .vCode = pp.vCode
    };
    return 1;
}

extern "C" uint8_t ParseTransferConfig(RustStruct::TransferConfig &value, SerializedBuffer buf)
{
    BaseStruct::TransferConfig tc = {};
    if (!SerialStruct::ParseFromString(tc, string(buf.ptr, buf.size))) {
        return 0;
    }
    value = {
        .fileSize = tc.fileSize,
        .atime = tc.atime,
        .mtime = tc.mtime,
        .options = StringToHeapPtr(tc.options),
        .path = StringToHeapPtr(tc.path),
        .optionalName = StringToHeapPtr(tc.optionalName),
        .updateIfNew = tc.updateIfNew > 0,
        .compressType = tc.compressType,
        .holdTimestamp = tc.holdTimestamp > 0,
        .functionName = StringToHeapPtr(tc.functionName), // must first index
        .clientCwd = StringToHeapPtr(tc.clientCwd),
        .reserve1 = StringToHeapPtr(tc.reserve1),
        .reserve2 = StringToHeapPtr(tc.reserve2)
    };
    return 1;
}

extern "C" uint8_t ParseFileMode(RustStruct::FileMode &value, SerializedBuffer buf)
{
    BaseStruct::FileMode fm = {};
    if (!SerialStruct::ParseFromString(fm, string(buf.ptr, buf.size))) {
        return 0;
    }
    value = {
        .perm = fm.perm,
        .u_id = fm.u_id,
        .g_id = fm.g_id,
        .context = StringToHeapPtr(fm.context),
        .fullName = StringToHeapPtr(fm.fullName)
    };
    return 1;
}

extern "C" uint8_t ParseTransferPayload(RustStruct::TransferPayload &value, SerializedBuffer buf)
{
    BaseStruct::TransferPayload tp = {};
    if (!SerialStruct::ParseFromString(tp, string(buf.ptr, buf.size))) {
        return 0;
    }
    value = {
        .index = tp.index,
        .compressType = tp.compressType,
        .compressSize = tp.compressSize,
        .uncompressSize = tp.uncompressSize
    };
    return 1;
}

extern "C" uint8_t ParsePayloadHead(RustStruct::PayloadHead &value, SerializedBuffer buf)
{
    if (memcpy_s(&value, buf.size, reinterpret_cast<struct PayloadHead *>(buf.ptr), buf.size) != EOK) {
        return 0;
    }
    return 1;
}

extern "C" uint8_t ParseUsbHead(RustStruct::USBHead &value, SerializedBuffer buf)
{
    if (memcpy_s(&value, sizeof(RustStruct::USBHead), reinterpret_cast<struct USBHead *>(buf.ptr), buf.size) != EOK) {
        return 0;
    }
    return 1;
}

extern "C" uint8_t ParseUartHead(RustStruct::UartHead &value, SerializedBuffer buf)
{
    if (memcpy_s(&value, sizeof(RustStruct::UartHead), reinterpret_cast<struct UartHead *>(buf.ptr), buf.size) != EOK) {
        return 0;
    }
    return 1;
}

}; // Hdc