#include "DetectPresenter.h"

#include <algorithm>
#include <cmath>

bool ModelRecognitionResult::IsVerified(double minimumConfidence) const
{
    if (!std::isfinite(minimumConfidence)) {
        return false;
    }

    const QString normalizedModel = modelType.trimmed();
    const bool isUnknown = normalizedModel == QStringLiteral("未知") ||
        normalizedModel.compare(QStringLiteral("unknown"), Qt::CaseInsensitive) == 0;
    const double threshold = (std::max)(0.0, minimumConfidence);
    return verified &&
           !normalizedModel.isEmpty() &&
           !isUnknown &&
           std::isfinite(confidence) &&
           confidence >= threshold;
}

QString DetectPresenter::GetAlgoVersion()
{
    return QStringLiteral("停车引导预留算法接口 版本0.1");
}

int DetectPresenter::DetectAirplanePresence(const RsCloudData& cloud,
                                            const VrAlgorithmParams& algorithmParams,
                                            AirplanePresenceResult& result)
{
    Q_UNUSED(algorithmParams);

    result = AirplanePresenceResult();
    if (cloud.empty()) {
        result.message = QStringLiteral("未检测到飞机");
        return 0;
    }

    result.state = AirplanePresenceState::Detected;
    result.message = QStringLiteral("检测到飞机");
    return 0;
}

int DetectPresenter::DetectParkingSpaceGuide(const RsCloudData& cloud,
                                             const VrAlgorithmParams& algorithmParams,
                                             const ParkingGuideAlgorithmState& previousState,
                                             DetectionResult& result,
                                             ParkingGuideAlgorithmControl& control)
{
    result = DetectionResult();
    control = ParkingGuideAlgorithmControl();
    control.nextState = previousState;
    result.cameraIndex = 1;
    result.errorCode = 0;

    const VrParkingSpaceGuideParam& p = algorithmParams.guideParam;
    const double cloudScale = cloud.empty() ? 1.0 : std::min<double>(2.0, 1.0 + cloud.size() / 1000.0);

    ParkingSpaceGuidePosition position;
    position.x = 0.0;
    position.y = p.targetStopOffset;
    position.z = 0.0;
    position.roll = 0.0;
    position.pitch = 0.0;
    position.yaw = 0.0;
    result.positions.push_back(position);

    ParkingSpaceGuideInfo info;
    info.modelType = previousState.modelVerified
        ? previousState.modelType
        : QStringLiteral("未知");
    info.hasException = false;
    info.distance = p.targetStopOffset * cloudScale;
    info.lateralOffset = 0.0;
    info.angle = 0.0;
    info.aircraftSpeed = 0.0;
    info.confidence = previousState.modelVerified
        ? previousState.modelConfidence
        : p.confidenceThreshold;
    info.guideStateCode = 0;
    info.guideText = QStringLiteral("预留算法接口");
    result.parkingSpaceInfoList.push_back(info);
    result.message = QStringLiteral("停车引导预留算法接口");

    const double modelVerifyDistance = algorithmParams.calibrationParam.modelVerifyDistance;
    const bool isInModelVerifyRange = modelVerifyDistance >= 0.0 &&
        info.distance >= 0.0 &&
        info.distance <= modelVerifyDistance;
    if (isInModelVerifyRange &&
        !previousState.modelVerified &&
        previousState.modelRecognitionAttempts < 2) {
        control.needModelRecognition = true;
        control.recognitionContext = QByteArrayLiteral("target-index=0");
        control.nextState.modelRecognitionAttempts =
            (std::max)(0, previousState.modelRecognitionAttempts) + 1;
    } else if (isInModelVerifyRange && !previousState.modelVerified) {
        ParkingSpaceGuideInfo& failedInfo = result.parkingSpaceInfoList.back();
        failedInfo.hasException = true;
        failedInfo.guideStateCode =
            static_cast<int>(ParkingGuideState::AircraftVerificationFailed);
        failedInfo.guideText = QStringLiteral("STOP+IDFAIL");
        result.message = QStringLiteral("机型二次验证失败");
    }

    return 0;
}

int DetectPresenter::RecognizeModel2D(const QImage& frame,
                                      const QByteArray& recognitionContext,
                                      ModelRecognitionResult& result)
{
    Q_UNUSED(frame);
    Q_UNUSED(recognitionContext);

    result = ModelRecognitionResult();
    result.message = QStringLiteral("机型识别算法接口未实现");
    return -1;
}