/*
 * Copyright (c) 2025 Amlogic, Inc. All rights reserved.
 *
 * This source code is subject to the terms and conditions defined in the
 * file 'LICENSE' which is part of this source code package.
 *
 * Description:
 */
#include <binder/IPCThreadState.h>
#include <binder/ProcessState.h>
#include <binder/IServiceManager.h>
#include "vsc_fuse.h"

#include "info.h"
#include "binderInfo.h"
#include "BinderClient.h"
#include "binder_api.h"
#include "v4l2-controls-ext_func.h"

BinderClient::BinderClient(video_scaler_file_t *info)
{
    sp<ProcessState> proc(ProcessState::self());
    proc->startThreadPool();
    Parcel send, reply;
    sp<IBinder> binder = sp<IBinder>(this);

    sp<IServiceManager> serviceManager = defaultServiceManager();
    do {
        mServicebinder = serviceManager->getService(String16("compositor-service"));
        printf("%s mServicebinder is %p\n", __FUNCTION__, mServicebinder.get());
        if (mServicebinder != 0) break;
        printf("BinderClient: Waiting mesonvideo-service published.\n");
        usleep(500000);
    } while (true);

    mInfo = info;

    send.writeInt32(info ? info->index : 0);
    send.writeInt32(info ? info->scaler_id : VT_SCALER_MAX);
    send.writeStrongBinder(binder);
    int ret = mServicebinder->transact(CMD_SEND_CLIENT, send, &reply);
    if (ret < 0)
        printf("transact binder fail\n");
}

int BinderClient::connectScaler(int displayId, int scalerId, int index)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(scalerId);
        send.writeInt32(index);
        ret = mServicebinder->transact(CMD_CONNECT_VIDEO_SCALER, send, &reply);
    }
    return ret;
}

int BinderClient::disconnectScaler(int displayId, int scalerId, int index)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(scalerId);
        send.writeInt32(index);
        ret = mServicebinder->transact(CMD_DISCONNECT_VIDEO_SCALER, send, &reply);
    }
    return ret;
}

int BinderClient::getHdrType(int displayId, enum v4l2_ext_vsc_hdr_type *type)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        ret = mServicebinder->transact(CMD_GET_HDR_TYPE, send, &reply);
        if (!ret)
            *type = (enum v4l2_ext_vsc_hdr_type)reply.readInt32();
    }

    return ret;
}

int BinderClient::setHdrType(int displayId, enum v4l2_ext_vsc_hdr_type type)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(type);
        ret = mServicebinder->transact(CMD_SET_HDR_TYPE, send, &reply);
    }
    return ret;
}

int BinderClient::getFreeze(int displayId, int sNum, int *freeze)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);
        ret = mServicebinder->transact(CMD_GET_FREEZE, send, &reply);
        if (!ret)
            *freeze = reply.readInt32();
    }
    return ret;
}

int BinderClient::setFreeze(int displayId, int sNum, int freeze)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);
        send.writeInt32(freeze);
        ret = mServicebinder->transact(CMD_SET_FREEZE, send, &reply);
    }
    return ret;
}

int BinderClient::getFreezeFrameBuffer(int displayId, int sNum, int *freeze)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);
        ret = mServicebinder->transact(CMD_GET_FREEZE_FRAMEBUFFER, send, &reply);
        if (!ret)
            *freeze = reply.readInt32();
    }
    return ret;
}

int BinderClient::setFreezeFrameBuffer(int displayId, int sNum, int freeze)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);
        send.writeInt32(freeze);
        ret = mServicebinder->transact(CMD_SET_FREEZE_FRAMEBUFFER, send, &reply);
    }
    return ret;
}

int BinderClient::getBgColor(int displayId, enum v4l2_ext_vsc_win_color *color)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        ret = mServicebinder->transact(CMD_GET_BG_COLOR, send, &reply);
        if (!ret)
            *color = (enum v4l2_ext_vsc_win_color)reply.readInt32();
    }
    return ret;
}

int BinderClient::setBgColor(int displayId, int scalerId, enum v4l2_ext_vsc_win_color color)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(scalerId);
        send.writeInt32(color);
        ret = mServicebinder->transact(CMD_SET_BG_COLOR, send, &reply);
    }
    return ret;
}

int BinderClient::getHdmitxConnection(int displayId, int *value)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        ret = mServicebinder->transact(CMD_GET_HDMI_CONNECTION, send, &reply);
        if (!ret)
            *value = reply.readInt32();
    }
    return ret;
}

int BinderClient::getHdmitxHdrType(int displayId, int *value)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        ret = mServicebinder->transact(CMD_GET_HDMITX_HDR, send, &reply);
        if (!ret)
            *value = reply.readInt32();
    }
    return ret;
}

int BinderClient::getHdmitxHdcpVersion(int displayId, int *value)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        ret = mServicebinder->transact(CMD_GET_HDMITX_HDCP_VERSION, send, &reply);
        if (!ret)
            *value = reply.readInt32();
    }
    return ret;
}

int BinderClient::getHdmitxHdrPolicy(int displayId, int *value)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        ret = mServicebinder->transact(CMD_GET_HDMITX_HDR_POLICY, send, &reply);
        if (!ret)
            *value = reply.readInt32();
    }
    return ret;
}

int BinderClient::setHdmitxHdrPolicy(int displayId, int value)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(value);
        ret = mServicebinder->transact(CMD_SET_HDMITX_HDR_POLICY, send, &reply);
    }
    return ret;
}

int BinderClient::setHdmitxAvMute(int displayId, int value)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(value);
        ret = mServicebinder->transact(CMD_SET_HDMITX_AV_MUTE, send, &reply);
    }
    return ret;
}

int BinderClient::setHdmitxHdcpAuth(int displayId, int value)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(value);
        ret = mServicebinder->transact(CMD_SET_HDMITX_HDCP_AUTH, send, &reply);
    }
    return ret;
}

int BinderClient::getHdmitxHdcpStatus(int displayId, int *value)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        ret = mServicebinder->transact(CMD_GET_HDMITX_HDCP_STATUS, send, &reply);
        if (!ret)
            *value = reply.readInt32();
    }
    return ret;
}

int BinderClient::getWinRegion(int displayId, int sNum,
            struct v4l2_ext_vsc_win_region *win)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);
        ret = mServicebinder->transact(CMD_GET_WIN_REGION, send, &reply);
        if (!ret) {
            win->in.crop.x = reply.readInt32();
            win->in.crop.y = reply.readInt32();
            win->in.crop.w = reply.readInt32();
            win->in.crop.h = reply.readInt32();
            win->in.res.x = reply.readInt32();
            win->in.res.y = reply.readInt32();
            win->in.res.w = reply.readInt32();
            win->in.res.h = reply.readInt32();
            win->out.x = reply.readInt32();
            win->out.y = reply.readInt32();
            win->out.w = reply.readInt32();
            win->out.h = reply.readInt32();
            win->punch.x = reply.readInt32();
            win->punch.y = reply.readInt32();
            win->punch.w = reply.readInt32();
            win->punch.h = reply.readInt32();
            win->rotation = (enum v4l2_ext_vsc_rotation)reply.readInt32();
        }
    }
    return ret;
}

int BinderClient::setOriginalResolution(int displayId, int sNum,
            struct v4l2_ext_vsc_win_region *win)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);

        send.writeInt32(win->in.res.x);
        send.writeInt32(win->in.res.y);
        send.writeInt32(win->in.res.x + win->in.res.w);
        send.writeInt32(win->in.res.y + win->in.res.h);

        send.writeInt32(win->in.crop.x);
        send.writeInt32(win->in.crop.y);
        send.writeInt32(win->in.crop.x + win->in.crop.w);
        send.writeInt32(win->in.crop.y + win->in.crop.h);

        send.writeInt32(win->out.x);
        send.writeInt32(win->out.y);
        send.writeInt32(win->out.x + win->out.w);
        send.writeInt32(win->out.y + win->out.h);

        send.writeInt32(win->punch.x);
        send.writeInt32(win->punch.y);
        send.writeInt32(win->punch.x + win->punch.w);
        send.writeInt32(win->punch.y + win->punch.h);

        send.writeInt32(win->rotation);
        ret = mServicebinder->transact(CMD_SET_WIN_REGION, send, &reply);
    }
    return ret;
}

int BinderClient::getZorder(int displayId, int sNum, struct v4l2_ext_vsc_zorder *z)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);
        ret = mServicebinder->transact(CMD_GET_ZORDER, send, &reply);
        if (!ret) {
            z->zorder = reply.readInt32();
            z->alpha = reply.readInt32();
        }
    }
    return ret;
}

int BinderClient::setZorder(int displayId, int sNum, struct v4l2_ext_vsc_zorder *z)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);
        send.writeInt32(z->zorder);
        send.writeInt32(z->alpha);
        ret = mServicebinder->transact(CMD_SET_ZORDER, send, &reply);
    }
    return ret;
}

int BinderClient::getWinProp(int displayId, int sNum,
            struct v4l2_ext_vsc_win_prop *prop)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);
        ret = mServicebinder->transact(CMD_GET_WIN_PROP, send, &reply);
        if (!ret) {
            prop->win_mode = (enum v4l2_ext_vsc_win_mode)reply.readInt32();
            prop->mirror_mode = (enum v4l2_ext_vsc_mirror_mode)reply.readInt32();
            prop->mem_type = (enum v4l2_ext_vsc_memory_type)reply.readInt32();
        }
    }
    return ret;
}

int BinderClient::setWinProp(int displayId, int sNum,
            struct v4l2_ext_vsc_win_prop *prop)
{
    Parcel send, reply;
    int ret = -1;
    int data = displayId | (sNum << 4);

    data |= (prop->mem_type << 8);
    data |= (prop->mirror_mode << 12);
    data |= (prop->win_mode << 16);

    if (mServicebinder != NULL) {
        send.writeInt32(data);
        ret = mServicebinder->transact(CMD_SET_WIN_PROP, send, &reply);
    }
    return ret;
}

int BinderClient::getConnectInfo(int displayId, int sNum,
            struct v4l2_ext_vsc_connect_info *info)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);
        ret = mServicebinder->transact(CMD_GET_CONNECT_INFO, send, &reply);
        if (!ret) {
            info->in.src = (enum v4l2_ext_vsc_input_src)reply.readInt32();
            info->in.index = (unsigned char)reply.readInt32();
            info->in.attr = (unsigned char)reply.readInt32();
            info->out = (enum v4l2_ext_vsc_dest)reply.readInt32();
        }
    }
    return ret;
}

int BinderClient::setConnectInfo(int displayId, int sNum,
            int index, struct v4l2_ext_vsc_connect_info *info)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(sNum);
        send.writeInt32(index);
        send.writeInt32(info->in.src);
        send.writeInt32(info->in.index);
        send.writeInt32(info->in.attr);
        send.writeInt32(info->out);
        ret = mServicebinder->transact(CMD_SET_CONNECT_INFO, send, &reply);
    }
    return ret;
}

int BinderClient::setAspectratio(int displayId, int scalerId,
            struct v4l2_ext_vsc_aspectratio_policy *policy)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(scalerId);
        send.writeInt32(policy->out.x);
        send.writeInt32(policy->out.y);
        send.writeInt32(policy->out.w);
        send.writeInt32(policy->out.h);

        send.writeInt32(policy->system_policy.panel.x);
        send.writeInt32(policy->system_policy.panel.y);
        send.writeInt32(policy->system_policy.panel.w);
        send.writeInt32(policy->system_policy.panel.h);

        send.writeInt32(policy->system_policy.country_grp);
        send.writeInt32(policy->system_policy.content_type);
        send.writeInt32(policy->system_policy.source_index);

        send.writeInt32(policy->setting_policy.zoom_data.h_ratio);
        send.writeInt32(policy->setting_policy.zoom_data.v_ratio);
        send.writeInt32(policy->setting_policy.zoom_data.h_position);
        send.writeInt32(policy->setting_policy.zoom_data.v_position);

        send.writeInt32(policy->setting_policy.just_scan);
        send.writeInt32(policy->setting_policy.aspect_ratio);
        send.writeInt32(policy->setting_policy.rotate);
        send.writeInt32(policy->setting_policy.orbit_over_scan);
        send.writeInt32(policy->setting_policy.screen_position);
        send.writeInt32(policy->setting_policy.media_afd_property);
        send.writeInt32(policy->setting_policy.overscan_appropriate_flag);
        send.writeInt32(policy->setting_policy.scan_type);
        ret = mServicebinder->transact(CMD_SET_ASPECTRATIO, send, &reply);
    }
    return ret;
}

int BinderClient::getHdmitxTiming(int displayId,
            struct v4l2_ext_hdmitx_timing_info *info)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        ret = mServicebinder->transact(CMD_GET_HDMI_TIMING, send, &reply);
        if (!ret) {
            info->width = reply.readInt32();
            info->height = reply.readInt32();
            info->framerate = reply.readInt32();
            info->scan_type = reply.readInt32();
        }
    }
    return ret;
}

int BinderClient::setHdmitxTiming(int displayId,
            struct v4l2_ext_hdmitx_timing_info *info)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder != NULL) {
        send.writeInt32(displayId);
        send.writeInt32(info->width);
        send.writeInt32(info->height);
        send.writeInt32(info->framerate);
        send.writeInt32(info->scan_type);
        ret = mServicebinder->transact(CMD_SET_HDMI_TIMING, send, &reply);
    }
    return ret;
}

int BinderClient::getHdmitxColor(int displayId,
            struct v4l2_ext_hdmitx_color_attr *attr)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder == NULL)
        return ret;

    send.writeInt32(displayId);

    ret = mServicebinder->transact(CMD_GET_HDMI_COLOR, send, &reply);
    attr->pixel_encoding = (enum v4l2_ext_hdmitx_avi_csc)reply.readInt32();
    attr->color_depth = (enum v4l2_ext_hdmitx_color_depth)reply.readInt32();
    return ret;
}

int BinderClient::setHdmitxColor(int displayId,
            struct v4l2_ext_hdmitx_color_attr *attr)
{
    Parcel send, reply;

    if (mServicebinder == NULL)
        return -1;

    send.writeInt32(displayId);
    send.writeInt32(attr->pixel_encoding);
    send.writeInt32(attr->color_depth);

    return mServicebinder->transact(CMD_SET_HDMI_COLOR, send, &reply);
}

int BinderClient::getHdmitxRawEdid(int displayId, unsigned char *dat)
{
    Parcel send, reply;
    int ret = -1;
    int count;

    if (mServicebinder == NULL)
        return ret;

    send.writeInt32(displayId);

    ret = mServicebinder->transact(CMD_GET_HDMI_EDID, send, &reply);
    count = reply.readInt32();
    reply.read((void *)dat, count);

    return ret;
}

int BinderClient::setOrbitWindow(int displayId, int sNum,
            struct v4l2_ext_vsc_orbit_window *orbitWindow)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder == NULL)
        return ret;

    send.writeInt32(displayId);
    send.writeInt32(sNum);

    send.writeInt32(orbitWindow->osd_input.x);
    send.writeInt32(orbitWindow->osd_input.y);
    send.writeInt32(orbitWindow->osd_input.w);
    send.writeInt32(orbitWindow->osd_input.h);

    send.writeInt32(orbitWindow->video_input.x);
    send.writeInt32(orbitWindow->video_input.y);
    send.writeInt32(orbitWindow->video_input.w);
    send.writeInt32(orbitWindow->video_input.h);

    send.writeInt32(orbitWindow->osd_output.x);
    send.writeInt32(orbitWindow->osd_output.y);
    send.writeInt32(orbitWindow->osd_output.w);
    send.writeInt32(orbitWindow->osd_output.h);

    send.writeInt32(orbitWindow->video_output.x);
    send.writeInt32(orbitWindow->video_output.y);
    send.writeInt32(orbitWindow->video_output.w);
    send.writeInt32(orbitWindow->video_output.h);

    return mServicebinder->transact(CMD_SET_ORBIT_WINDOW, send, &reply);
}

int BinderClient::setOrbitMove(int displayId, int sNum,
            struct v4l2_ext_vsc_orbit_move *orbitMove)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder == NULL)
        return ret;

    send.writeInt32(displayId);
    send.writeInt32(sNum);

    send.writeInt32(orbitMove->osd_input.x);
    send.writeInt32(orbitMove->osd_input.y);
    send.writeInt32(orbitMove->osd_input.w);
    send.writeInt32(orbitMove->osd_input.h);

    send.writeInt32(orbitMove->video_input.x);
    send.writeInt32(orbitMove->video_input.y);
    send.writeInt32(orbitMove->video_input.w);
    send.writeInt32(orbitMove->video_input.h);

    send.writeInt32(orbitMove->osd_output.x);
    send.writeInt32(orbitMove->osd_output.y);
    send.writeInt32(orbitMove->osd_output.w);
    send.writeInt32(orbitMove->osd_output.h);

    send.writeInt32(orbitMove->video_output.x);
    send.writeInt32(orbitMove->video_output.y);
    send.writeInt32(orbitMove->video_output.w);
    send.writeInt32(orbitMove->video_output.h);

    return mServicebinder->transact(CMD_SET_ORBIT_MOVE, send, &reply);
}

VSC_BINDER_CLIENT_FUNC_LIST

int BinderClient::setDrmLeaseFd(int displayId, int fd)
{
    Parcel send, reply;
    int ret = -1;

    if (mServicebinder == NULL)
        return ret;

    send.writeInt32(displayId);
    send.writeFileDescriptor(fd);
    return mServicebinder->transact(CMD_TRANSFER_LEASE_FD, send, &reply);
}

void BinderClient::setEventToScaler(video_scaler_file_t *info,
    VscEventType event)
{
    struct v4l2_event vEvent = { 0 };
    vEvent.id = event.eventId;
    for (size_t i = 0; i < sizeof(event.data); i++)
        vEvent.u.data[i] = event.data[i];
    if (event.scalerId < VT_SCALER_MAX)
       vEvent.u.data[0] =  event.scalerId;
    v4l2_ext_set_event(info, &vEvent);
}

status_t BinderClient::onTransact(uint32_t code,
            const Parcel& data, Parcel* reply,
            uint32_t flags) {
    VscEventType event;

    switch (code) {
        case CMD_EVENT:
            event.displayId = data.readUint64();
            event.scalerId = data.readInt32();
            event.eventId = data.readUint32();
            data.read((void *)event.data, sizeof(event.data));
            setEventToScaler(mInfo, event);
            break;
        default:
            return BBinder::onTransact(code, data, reply, flags);
    }
    return 0;
}