#include "HxTaskDispatch.h"
#include "HxVideoDevice.h"

#include <QJsonArray>
#include <QJsonObject>
#include <QJsonDocument>

/* 视频设备 */
VideoDevice adas_video_device, bsd_video_device[6], dsm_video_device;

TaskDispatch *dispatcher = new TaskDispatch();

/* 车辆状态: 1 直行; 2 左转弯; 3 右转弯; 4 倒车 */
static int vehicle_status = 0;

static int detect_channel = 0;

void TaskDispatch::initialization(void)
{
    /* 算法模块初始化 */
#if USE_ALGORITHM
    /* adas检测配置 */
    strcpy(dispatcher->event_detect_config.szAdasDetectConfigPathName, "/opt/algmode/adas_detect.bin");
    /* adas跟踪配置 */
    strcpy(dispatcher->event_detect_config.szAdasTrackConfigPathName, "/opt/algmode/adas_track.bin");
    /* bsd检测配置 */
    strcpy(dispatcher->event_detect_config.szBsdDetectConfigPathName, "/opt/algmode/bsd_detect.bin");
    // strcpy(dispatcher->event_detect_config.szRightBsdFrontDetectConfigPathName, "/opt/algmode/bsd_detect.bin");
    /* dsm人脸检测配置 */
    strcpy(dispatcher->event_detect_config.szDsmFaceDetectConfigPathName, "/opt/algmode/dsm_face_detect.bin");
    /* dsm人脸特征点检测配置 */
    strcpy(dispatcher->event_detect_config.szDsmFaceLandMarksDetectConfigPathName, "/opt/algmode/dsm_face_landmarks_detect.bin");
    /* dsm人脸认证检测配置 */
    strcpy(dispatcher->event_detect_config.szDsmFaceVerificationDetectConfigPathName, "/opt/algmode/dsm_face_verification_detect.bin");
    /* dsm人眼认证检测配置 */
    strcpy(dispatcher->event_detect_config.szDsmEyeLandMarksDetectConfigPathName, "/opt/algmode/dsm_eye_landmarks_detect.bin");
    /* dsm人脸认证检测配置 */
    strcpy(dispatcher->event_detect_config.szDsmSmokeConfPathName, "/opt/algmode/dsm_smoke_detect.bin");
    strcpy(dispatcher->event_detect_config.szDsmCallConfPathName, "/opt/algmode/dsm_call_detect.bin");
    strcpy(dispatcher->event_detect_config.szDsmFaceFeaturePathName, "/opt/algmode/dsm_face_feature.bin");
    strcpy(dispatcher->event_detect_config.szDsmHeadPoseConfPathName, "/opt/algmode/data_68kp");

    /* 输出调试信息 */
    MvSetPrintf(false);

    /* 目标跟踪事件检测初始化 */
    auto result = MvObjectEventDetectInit(&dispatcher->event_detect_config, RIGHT_BSD_FRONT_DETECT_CHANNEL |
                                                                                RIGHT_BSD_REAR_DETECT_CHANNEL |
                                                                                LEFT_BSD_FRONT_DETECT_CHANNEL |
                                                                                LEFT_BSD_REAR_DETECT_CHANNEL |
                                                                                FRONT_BSD_DETECT_CHANNEL |
                                                                                REAR_BSD_DETECT_CHANNEL |
                                                                                DMS_DETECT_CHANNEL |
                                                                                ADAS_DETECT_CHANNEL);

    if (result != 0)
        return;
#endif

    /* ADAS 通道初始化 */
    if ((DataBase::algorithm_type & 0x1) == 1)
    {
        adas_video_device.set(0, DataBase::adas_video_input_source);
    }

    /* BSD 通道初始化 */
    if (((DataBase::algorithm_type >> 1) & 0x1) == 1)
    {
        /* BSD-前 */
        bsd_video_device[0].set(6, DataBase::bsd_video_input_source[0], DataBase::get_bsd_warn_region(0));

        /* BSD-后 */
        bsd_video_device[1].set(7, DataBase::bsd_video_input_source[1], DataBase::get_bsd_warn_region(1));

        /* BSD-左前 */
        bsd_video_device[2].set(4, DataBase::bsd_video_input_source[2], DataBase::get_bsd_warn_region(2));

        /* BSD-右前 */
        bsd_video_device[3].set(1, DataBase::bsd_video_input_source[3], DataBase::get_bsd_warn_region(3));

        /* BSD-左后 */
        bsd_video_device[4].set(5, DataBase::bsd_video_input_source[4], DataBase::get_bsd_warn_region(4));

        /* BSD-右后 */
        bsd_video_device[5].set(3, DataBase::bsd_video_input_source[5], DataBase::get_bsd_warn_region(5));
    }

    /* DSM 通道初始化 */
    if (((DataBase::algorithm_type >> 2) & 0x1) == 1)
    {
        dsm_video_device.set(2, DataBase::dsm_video_input_source);
    }

    dispatcher->start();
}

void TaskDispatch::listern(uint16_t port)
{
    dispatcher->debug_tool = new HxSocketUtils(port);

    connect(dispatcher->debug_tool, &HxSocketUtils::data_receive_event, dispatcher, &TaskDispatch::data_receive_event);
    connect(dispatcher, &TaskDispatch::data_write_event, dispatcher->debug_tool, &HxSocketUtils::write);
}

void TaskDispatch::connect_to_host(QString address, int port)
{
    dispatcher->platform = new HxSocketUtils(address, port);

    connect(dispatcher->platform, &HxSocketUtils::data_receive_event, dispatcher, &TaskDispatch::data_receive_event);
    connect(dispatcher, &TaskDispatch::data_write_event, dispatcher->platform, &HxSocketUtils::write);
}

void TaskDispatch::algorithm_alarm_event(int channel, int level, int event_type, int detect_type, int left, int top, int right, int bottom, int distance, int speed, QString base64_string, QString filepath)
{
    QJsonObject root({{"type", 4}});

    QJsonObject msgInfo({{"channel", channel},
                         {"level", level},
                         {"event_type", event_type},
                         {"detect_type", detect_type},
                         {"left", left},
                         {"top", top},
                         {"right", right},
                         {"bottom", bottom},
                         {"distance", distance},
                         {"speed", speed},
                         {"image", base64_string},
                         {"filepath", filepath}});

    root.insert("msgInfo", msgInfo);

    emit dispatcher->data_write_event(QJsonDocument(root).toJson(QJsonDocument::Compact));

    // dispatcher->send_can_data(channel, pObjectTrackEventResult->nDangerLevel, pObjectTrackEventResult->objInfo[i].nDetectType);
}

CarInfoInput *TaskDispatch::get_car_info(void) { return &dispatcher->car_info; }

QString TaskDispatch::get_video_frame_data(int type, int channel, int id)
{
    Q_UNUSED(channel);

    switch(type)
    {
    case 0:
        return adas_video_device.build_image(id);
    case 1:
        return bsd_video_device[channel].build_image(id);
    case 2:
        return dsm_video_device.build_image(id);
    }

    return "";
}

QString TaskDispatch::build_alarm_image(int type, int channel, int frame_id)
{
    switch(type)
    {
    case 0:
        return adas_video_device.build_image(frame_id);
    case 1:
        return bsd_video_device[channel].build_image(frame_id);
    case 2:
        return dsm_video_device.build_image(frame_id);
    }

    return "";
}

QString TaskDispatch::build_alarm_video(int type, int channel, int frame_id)
{
    switch(type)
    {
    case 0:
        return adas_video_device.build_video(frame_id);
    case 1:
        return bsd_video_device[channel].build_video(frame_id);
    case 2:
        return dsm_video_device.build_video(frame_id);
    }

    return "";
}

void TaskDispatch::update_heartbeat()
{
    if (QDateTime::currentDateTime() > heartbeat_timestamp.addSecs(30))
    {
        heartbeat_timestamp = QDateTime::currentDateTime();

        emit data_write_event(QJsonDocument(QJsonObject({{"type", 0}})).toJson(QJsonDocument::Compact));
    }
}

void TaskDispatch::updata_vehiclue_status(QJsonObject object)
{
    vehicle_status_update_time = QDateTime::currentDateTime();

    car_info.fVelocity = object.value("speed").toDouble();
    car_info.fAcceleration = object.value("acceleration").toDouble();
    car_info.fDeceleration = object.value("deceleration").toDouble();
    car_info.nBrake = object.value("brake").toInt();
    car_info.nLLight = object.value("left_light").toInt();
    car_info.nRLight = object.value("right_light").toInt();
    car_info.fAlpha = object.value("steering_angle").toDouble();
    car_info.fSteeingWheelAngle = object.value("seeing_wheel_angle").toDouble();

    reversing_light = object.value("reversing_light").toInt();
}

void TaskDispatch::parsing_vehiclue_status(void)
{
    if (dispatcher->vehicle_status_update_time.secsTo(QDateTime::currentDateTime()) >= 10)
        car_info.fVelocity = 0;

    if (car_info.fVelocity > 0)
    {
        auto _detect_channel = 0;

        /* ADAS 通道初始化 */
        if ((DataBase::algorithm_type & 0x1) == 1)
        {
            _detect_channel |= ADAS_DETECT_CHANNEL;
        }

        /* DSM 通道初始化 */
        if (((DataBase::algorithm_type >> 2) & 0x1) == 1)
        {
            _detect_channel |= DMS_DETECT_CHANNEL;
        }

        /* BSD 类型 */
        else if (((DataBase::algorithm_type >> 1) & 0x1) == 1)
        {
            auto status = 0;

            /* 倒车 */
            if (reversing_light == 1)
                status = 4;

            /* 左转弯 */
            else if (car_info.nLLight == 1)
                status = 2;

            /* 右转弯 */
            else if (car_info.nRLight == 1)
                status = 3;

            /* 无左右转弯，车辆直行 */
            else
                status = 1;


            /* 车辆状态发生改变 */
            if (status != 0 && vehicle_status != status)
            {
                qDebug() << "车辆状态发生改变 " << vehicle_status << " => " << status;

                vehicle_status = status;

                /* 禁止送帧 */
                for (int i = 0; i < BSD_MAX_CHANNEL; i++)
                    bsd_video_device[i].set(false);

                switch (status)
                {
                /* 直线行驶, 检测通道: A C D */
                case 1:
                    /* 允许送帧 */
                    bsd_video_device[0].set(true);
                    bsd_video_device[2].set(true);
                    bsd_video_device[3].set(true);

                    /* 前侧, 左前, 右前 */
                    _detect_channel |= (FRONT_BSD_DETECT_CHANNEL | LEFT_BSD_FRONT_DETECT_CHANNEL | RIGHT_BSD_FRONT_DETECT_CHANNEL);
                    break;

                /* 左转弯, 检测通道: C D E */
                case 2:
                    /* 允许送帧 */
                    bsd_video_device[2].set(true);
                    bsd_video_device[3].set(true);
                    bsd_video_device[4].set(true);

                    /* 左前, 右前, 左后 */
                    _detect_channel |= (LEFT_BSD_FRONT_DETECT_CHANNEL | RIGHT_BSD_FRONT_DETECT_CHANNEL | LEFT_BSD_REAR_DETECT_CHANNEL);
                    break;

                /* 右转弯, 检测通道: C D F */
                case 3:
                    /* 允许送帧 */
                    bsd_video_device[2].set(true);
                    bsd_video_device[3].set(true);
                    bsd_video_device[5].set(true);

                    /* 左前, 右前, 右后 */
                    _detect_channel |= (LEFT_BSD_FRONT_DETECT_CHANNEL | RIGHT_BSD_FRONT_DETECT_CHANNEL | RIGHT_BSD_REAR_DETECT_CHANNEL);
                    break;

                /* 倒车, 检测通道: B C D */
                case 4:
                    /* 允许送帧 */
                    bsd_video_device[1].set(true);
                    bsd_video_device[2].set(true);
                    bsd_video_device[3].set(true);

                    /* 后侧, 左前, 左后 */
                    _detect_channel |=(REAR_BSD_DETECT_CHANNEL | LEFT_BSD_FRONT_DETECT_CHANNEL | RIGHT_BSD_FRONT_DETECT_CHANNEL);
                    break;
                }
            }
        }

        /* 确保状态改变后才调用该函数 */
        if(detect_channel != _detect_channel)
        {
            detect_channel = _detect_channel;

#if USE_ALGORITHM
            MvSetDetectChannel(detect_channel);
#endif
        }
    }
}

void TaskDispatch::run()
{
    while (true)
    {
        QCoreApplication::processEvents();

        /* 发送心跳数据 */
        update_heartbeat();

        /* 分析车辆行驶状态 */
        parsing_vehiclue_status();

        QThread::msleep(10);
    }
}

void TaskDispatch::debug_tool_response_event(int type, std::initializer_list<QPair<QString, QJsonValue>> args)
{
    QJsonObject root, msginfo;

    for (std::initializer_list<QPair<QString, QJsonValue>>::const_iterator i = args.begin(); i != args.end(); ++i)
        msginfo.insert(i->first, i->second);

    root.insert("type", type);
    root.insert("msgInfo", msginfo);

    emit data_write_event(QJsonDocument(root).toJson(QJsonDocument::Compact));
}

void TaskDispatch::data_receive_event(QByteArray data)
{
    int type = -1;

    auto document = QJsonDocument::fromJson(data);
    auto root = document.object();
    if (root.contains("type"))
    {
        type = root.value("type").toInt();
    }

    auto msginfo = root.value("msgInfo").toObject();

    switch (type)
    {
    /* heart */
    case 0:
        break;

    /* 车辆状态 */
    case 3:
        updata_vehiclue_status(msginfo);
        break;

    /* 获取算法类型 */
    case 0xF0:
        debug_tool_response_event(type, {{"mode", DataBase::algorithm_type}});
        break;

    /* 设置算法类型 */
    case 0xF1:
        DataBase::algorithm_type = msginfo.value("mode").toInt();
        debug_tool_response_event(type, {{"status", DataBase::save_setting()}});
        break;

    /* 获取ADAS视频输入源 */
    case 0xF2:
        debug_tool_response_event(type, {{"source", DataBase::adas_video_input_source}});
        break;

    /* 设置ADAS视频输入源 */
    case 0xF3:
        DataBase::adas_video_input_source = msginfo.value("source").toString();
        debug_tool_response_event(type, {{"status", DataBase::save_setting()}});
        break;

    /* 抓拍 */
    case 0xF4:
        debug_tool_response_event(type, {{"data", adas_video_device.snap()}});
        break;

    /* 获取BSD视频输入源 */
    case 0xF5:
        debug_tool_response_event(type, {{"source", DataBase::bsd_video_input_source[msginfo.value("channel").toInt()]}});
        break;

    /* 设置BSD视频输入源 */
    case 0xF6:
        DataBase::bsd_video_input_source[msginfo.value("channel").toInt()] = msginfo.value("source").toString();
        debug_tool_response_event(type, {{"status", DataBase::save_setting()}});
        break;

    /* 抓拍 */
    case 0xF7:
        debug_tool_response_event(type, {{"data", bsd_video_device[msginfo.value("channel").toInt()].snap()}});
        break;

    /* 获取Dsm视频输入源 */
    case 0xF8:
        debug_tool_response_event(type, {{"source", DataBase::dsm_video_input_source}});
        break;

    /* 设置Dsm视频输入源 */
    case 0xF9:
        DataBase::dsm_video_input_source = msginfo.value("source").toString();
        debug_tool_response_event(type, {{"status", DataBase::save_setting()}});
        break;

    /* 抓拍 */
    case 0xFA:
        debug_tool_response_event(type, {{"data", dsm_video_device.snap()}});
        break;

    /* 获取BSD报警区域 */
    case 0xFB:
        debug_tool_response_event(type, {{"data", DataBase::bsd_warn_regions[msginfo.value("channel").toInt()]}});
        break;

    /* 设置BSD报警区域 */
    case 0xFC:
        DataBase::bsd_warn_regions[msginfo.value("channel").toInt()] = msginfo.value("data").toString();
        debug_tool_response_event(type, {{"status", DataBase::save_setting()}});
        break;

    /* 获取设备编号及FTP信息 */
    case 0xFD:
        debug_tool_response_event(type, {{"device_id", DataBase::device_id},
                                         {"ftp_address", DataBase::ftp_address},
                                         {"ftp_username", DataBase::ftp_username},
                                         {"ftp_password", DataBase::ftp_password}});
        break;

    /* 设置设备编号及FTP信息 */
    case 0xFE:
        DataBase::device_id = msginfo.value("device_id").toString();
        DataBase::ftp_address = msginfo.value("ftp_address").toString();
        DataBase::ftp_username = msginfo.value("ftp_username").toString();
        DataBase::ftp_password = msginfo.value("ftp_password").toString();
        debug_tool_response_event(type, {{"status", DataBase::save_setting()}});
        break;


    case 0xFFFF:
        adas_video_device.test();
        break;
    }
}