/*
 * Copyright (C) 2024 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 "bridge.h"
#include "log.h"
#include "sys_para.h"
#include "base.h"

#include <unistd.h>
#include <fcntl.h>
namespace Hdc {
static uint8_t *g_bridgeReadBuf = nullptr;
static constexpr char BRIDGE_FILE_PATH[20] = "/dev/express_bridge";

HdcBridge::HdcBridge()
{
    string strBridgePort;
    GetDevItem("persist.hdc.port", strBridgePort);
    WRITE_LOG(LOG_INFO, "strBridgePort:%s", strBridgePort.c_str());
    bridgeListenPort = atoi(strBridgePort.c_str());
    if (bridgeListenPort <= 0) {
        bridgeListenPort = 0;
    }
    WRITE_LOG(LOG_INFO, "bridgeListenPort:%d", bridgeListenPort);
}

HdcBridge::~HdcBridge()
{
}

int HdcBridge::StartListen()
{
    bridgeFd = open(BRIDGE_FILE_PATH, O_RDWR);
    WRITE_LOG(LOG_INFO, "StartListen bridgeFd:%d", bridgeFd);
    if (bridgeFd <= 0) {
        WRITE_LOG(LOG_FATAL, "SetBridgeListen open failed");
        return -1;
    }
    int ret = ioctl(bridgeFd, IOC_BIND, static_cast<unsigned long>(bridgeListenPort));
    WRITE_LOG(LOG_INFO, "StartListen ioctl ret:%d", ret);
    if (ret < 0) {
        WRITE_LOG(LOG_FATAL, "SetBridgeListen IOC_BIND failed");
        return -1;
    }
    return bridgeFd;
}

int HdcBridge::HandleClient(int socketFd)
{
    int newClientFd = open(BRIDGE_FILE_PATH, O_RDWR);
    WRITE_LOG(LOG_INFO, "HandleClient newClientFd:%d", newClientFd);
    if (newClientFd < 0) {
        WRITE_LOG(LOG_FATAL, "Unable to open new bridge connection err %d", errno);
        return -1;
    }
    errno = 0;
    int ret = ioctl(newClientFd, IOC_CONNECT, static_cast<unsigned long>(socketFd));
    if (ret < 0) {
        WRITE_LOG(LOG_FATAL, "Unable to ioctl new bridge err %d", errno);
        close(newClientFd);
        return -1;
    }
    return newClientFd;
}

int HdcBridge::ReadPipeFd(int fd, char* buf, int size)
{
    WRITE_LOG(LOG_INFO, "ReadPipeFd start");
    return read(fd, buf, size);
}

PersistBuffer HdcBridge::ReadClient(int fd, int size)
{
    if (g_bridgeReadBuf == nullptr) {
        WRITE_LOG(LOG_DEBUG, "remalloc g_bridgeReadBuf");
        g_bridgeReadBuf = new uint8_t[MAX_SIZE_IOBUF];
    }
    int readSize = read(fd, g_bridgeReadBuf, size);
    return PersistBuffer{reinterpret_cast<char *>(g_bridgeReadBuf), static_cast<uint64_t>(readSize)};
}

int HdcBridge::WriteClient(int fd, SerializedBuffer buf)
{
    uint8_t* ptr = reinterpret_cast<uint8_t *>(buf.ptr);
    size_t size = static_cast<size_t>(buf.size);
    int cnt = static_cast<int>(size);
    constexpr int intrmax = 1000;
    int intrcnt = 0;
    while (cnt > 0) {
        int rc = write(fd, ptr, cnt);
        if (rc < 0) {
            int err = errno;
            if (err != EINTR && err != EAGAIN) {
                WRITE_LOG(LOG_FATAL, "WriteClient fd:%d send rc:%d err:%d", fd, rc, err);
                cnt = -1;
                break;
            }
            if (++intrcnt > intrmax) {
                WRITE_LOG(LOG_WARN, "WriteClient fd:%d send interrupt err:%d", fd, err);
                intrcnt = 0;
            }
            continue;
        }
        ptr += rc;
        cnt -= rc;
    }
    return cnt == 0 ? static_cast<int>(size) : cnt;
}

void HdcBridge::Stop()
{
    if (bridgeFd > 0) {
        close(bridgeFd);
        bridgeFd = -1;
    }

    if (g_bridgeReadBuf != nullptr) {
        delete[] g_bridgeReadBuf;
        g_bridgeReadBuf = nullptr;
    }
}

extern "C" void* InitBridge()
{
    HdcBridge* instance = new HdcBridge();
    return instance;
}

extern "C" int StartListen(void* ptr)
{
    HdcBridge* bridge = (HdcBridge*)ptr;
    if (bridge == nullptr) {
        return -1;
    }
    return bridge->StartListen();
}

extern "C" int AcceptServerSocketFd(void* ptr, int pipeFd)
{
    WRITE_LOG(LOG_INFO, "AcceptServerSocketFd start, pipeFd:%d", pipeFd);
    HdcBridge* bridge = (HdcBridge*)ptr;
    if (bridge == nullptr) {
        return -1;
    }
    char socketFdBuf[4] = { 0 };
    int ret = bridge->ReadPipeFd(pipeFd, socketFdBuf, 4);
    WRITE_LOG(LOG_INFO, "AcceptServerSocketFd get socketfd buf size:%d", ret);
    if (ret < 0) {
        WRITE_LOG(LOG_INFO, "AcceptServerSocketFd get socket fd fail");
        return -1;
    }
    int socketFd = *reinterpret_cast<int*>(socketFdBuf);
    WRITE_LOG(LOG_INFO, "AcceptServerSocketFd get socketfd:%d", socketFd);
    return socketFd;
}

extern "C" int InitClientFd(void* ptr, int socketFd)
{
    HdcBridge* bridge = (HdcBridge*)ptr;
    if (bridge == nullptr) {
        return -1;
    }
    return bridge->HandleClient(socketFd);
}

extern "C" PersistBuffer ReadClient(void* ptr, int fd, int size)
{
    HdcBridge* bridge = (HdcBridge*)ptr;
    if (bridge == nullptr) {
        return PersistBuffer{reinterpret_cast<char *>(0), static_cast<uint64_t>(0)};
    }
    return bridge->ReadClient(fd, size);
}

extern "C" int WriteClient(void* ptr, int fd, SerializedBuffer buf)
{
    HdcBridge* bridge = (HdcBridge*)ptr;
    if (bridge == nullptr) {
        return -1;
    }
    return bridge->WriteClient(fd, buf);
}

extern "C" int Stop(void* ptr)
{
    HdcBridge* bridge = (HdcBridge*)ptr;
    if (bridge == nullptr) {
        return -1;
    }
    bridge->Stop();
    return 0;
}
}