#include <QDebug>

#include "pointcalculate.h"
#include "logger.h"
#include "global.h"
#include "confighandler.h"

QVector<Global::ExperimentData>PointCalculate:: _dataVtr;
QPointF PointCalculate::_peakPoint;
QPointF PointCalculate::_leftSelectedPoint,PointCalculate::_rightSelectedPoint;

void PointCalculate::setExperimentData(const QVector<Global::ExperimentData> &dataVtr)
{
    _dataVtr = dataVtr;

    if(_dataVtr.empty())    {
        return;
    }

    Global::ExperimentData startPoint = _dataVtr.at(0);
    Global::ExperimentData endPoint = _dataVtr.at(_dataVtr.size() - 1);

    _leftSelectedPoint = QPointF(startPoint.sampleTemp,startPoint.dsc);
    _rightSelectedPoint = QPointF(endPoint.sampleTemp,endPoint.dsc);
}

std::vector<float> PointCalculate::movingAverage(const std::vector<float>& data, int windowSize) {
    std::vector<float> smoothedData;
    for (size_t i = 0; i < data.size(); ++i) {
        if (i + windowSize <= data.size()) {
            float sum = std::accumulate(data.begin() + i, data.begin() + i + windowSize, 0.0);
            smoothedData.push_back(sum / windowSize);
        }
    }
    return smoothedData;
}

QPointF PointCalculate::getPeakPoint(){
    int n = _dataVtr.size();

    if (n < 3) {
        return QPointF(); // 至少需要三个点才能找到波峰
    }

    QPointF uniquePeak;
    float maxDiff = -std::numeric_limits<float>::infinity();

    for (int i = 0; i < n; ++i) {
        const float currentX = _dataVtr.at(i).sampleTemp;
        const float currentY = _dataVtr.at(i).dsc;

        if (currentX < _leftSelectedPoint.x()) {
            continue;
        }
        if (currentX > _rightSelectedPoint.x()) {
            break;
        }

        // 计算当前点与左选择点 y 值的差值
        float diffLeft = std::abs(currentY - _leftSelectedPoint.y());
        // 计算当前点与右选择点 y 值的差值
        float diffRight = std::abs(currentY - _rightSelectedPoint.y());
        // 取两个差值中的较大值
        float currentDiff = std::max(diffLeft, diffRight);

        if (currentDiff > maxDiff) {
            maxDiff = currentDiff;
            uniquePeak = QPointF(currentX, currentY);
        }
    }

    _peakPoint = uniquePeak;

    logde<<"peakPoint:"<<_peakPoint.x()<<","<<_peakPoint.y();

    return uniquePeak;
}

QPair<QPointF, QPointF> PointCalculate::calculateMaxDiffPointDetail(
        const PointCalculate::MaxDiffPointDetailType type)
{
#if 1
    float maxDiff = std::numeric_limits<float>::min();
    QPointF currentPoint,lastPoint;

    for (int i = 0; i < _dataVtr.size() - 1; ++i) {
        const float currentX = _dataVtr.at(i).sampleTemp;
        const float currentY = _dataVtr.at(i).dsc;

        if(type == MaxDiffPointDetailType::Left){
            if(currentX <= _leftSelectedPoint.x()){
                continue;
            }
            if(currentX >= _peakPoint.x()){
                break;
            }
        }else{
            if(currentX <= _peakPoint.x()){
                continue;
            }
            if(currentX >= _rightSelectedPoint.x()){
                break;
            }
        }
        //
        const float lastX = _dataVtr.at(i + 1).sampleTemp;
        const float lastY = _dataVtr.at(i + 1).dsc;
        float diff = std::abs(currentY - lastY);
        if(diff > maxDiff){
            maxDiff = diff;

            currentPoint.setX(currentX);
            currentPoint.setY(currentY);
            lastPoint.setX(lastX);
            lastPoint.setY(lastY);
        }
    }
#endif

    return qMakePair(currentPoint,lastPoint);
}


QPair<QPointF, QPointF> PointCalculate::calculateMaxDiffPointLeft()
{
    return calculateMaxDiffPointDetail(MaxDiffPointDetailType::Left);
}

QPair<QPointF, QPointF> PointCalculate::calculateMaxDiffPointRight()
{
    return calculateMaxDiffPointDetail(MaxDiffPointDetailType::Right);
}

#if 0
QPointF PointCalculate::findClosestY(float targetX)
{
    float minDiff = std::numeric_limits<float>::max();
    QPointF resultPointF;

    for(FileManager::ExperimentData &ed:_dataVtr){
        float diff = std::abs(ed.sampleTemp - targetX);
        if (diff < minDiff) {
            minDiff = diff;
            resultPointF = QPointF(ed.sampleTemp,ed.dsc);
        }
    }

    return resultPointF;
}
#endif

#if 0
QPointF PointCalculate::findClosestPointByX(float x) {
    int left = 0;
    int right = _dataVtr.size() - 1;

    QPointF targetPoint;
    targetPoint.setX(_dataVtr.value(0).sampleTemp);
    targetPoint.setY(_dataVtr.value(0).dsc);

    while (left <= right) {
        int mid = left + (right - left) / 2;
        FileManager::ExperimentData& ed = _dataVtr[mid];

        if (std::abs(ed.sampleTemp - x) < std::abs(targetPoint.x() - x)) {
            targetPoint.setX(ed.sampleTemp);
            targetPoint.setY(ed.dsc);
        }

        if(ed.sampleTemp < x){
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }

    return targetPoint;
}
#endif

void PointCalculate::setRegionPointX(const float left, const float right)
{
    logde<<"dataVtr size:"<<_dataVtr.size();
    logde<<"select point param left,right:"<<left<<","<<right;

    _leftSelectedPoint = getClosestPointByX(left);
    _rightSelectedPoint = getClosestPointByX(right);

    _peakPoint = getPeakPoint();

    logde<<"peak point:"<<_peakPoint.x()<<","<<_peakPoint.y();

    //根据峰谷重置选择点。
    updateStartEndPoint();

    logde<<"select point left:"<<_leftSelectedPoint.x()<<","<<_leftSelectedPoint.y();
    logde<<"select point right:"<<_rightSelectedPoint.x()<<","<<_rightSelectedPoint.y();
}

QVector<QPointF> PointCalculate::getPeakPointGroup()
{
    QVector<QPointF> pointVtr;
    for(Global::ExperimentData& ed:_dataVtr)   {
        if(ed.sampleTemp >= _leftSelectedPoint.x() &&
                ed.sampleTemp <= _rightSelectedPoint.x()){
            pointVtr.push_back(QPointF(ed.sampleTemp,ed.dsc));
        }
    }

    return pointVtr;
}

float PointCalculate::calculateArea() {
    //getPoint group
    QVector<QPointF> points = getPeakPointGroup();

    //calculate Area
    float integral = 0.0;
    size_t n = points.size();

    if (n < 2) {
        return integral; // 至少需要两个点才能计算积分
    }

    //find a line.
    float k = (_leftSelectedPoint.y() - _rightSelectedPoint.y()) /
            (_leftSelectedPoint.x() - _rightSelectedPoint.x());
    float b = _leftSelectedPoint.y() - k * _leftSelectedPoint.x();

    for (size_t i = 0; i < n - 1; ++i) {
#if 1
        float x1 = points[i].x();
        float y1 = points[i].y();

        float x2 = points[i + 1].x();
        float y2 = points[i + 1].y();
#endif
        float yLine1 = k * x1 + b;
        float yLine2  = k * x2 + b;

        float diff1 = y1 - yLine1;
        float diff2 = y2 - yLine2;

        float dx = x2 - x1;

        float cellArea = (diff1 + diff2) * dx /2.0;

        integral += std::abs(cellArea);
    }

    /*
     * H = K * S / w;
     */
    float coefficient = ConfigHandler::_configMap.value(ConInstrumentCoefficientStr).toFloat();
    logde<<"coefficient:"<<coefficient;

    if(Global::_enthalpyCoefficientEnableFlag){
        logde<<"_enthalpyCoefficientEnableFlag...";

        float startTemp = _leftSelectedPoint.x();

        float value1 = Global::_enthalpyCoefficientVtr.at(0);
        float value2 = Global::_enthalpyCoefficientVtr.at(0);
        float value3 = Global::_enthalpyCoefficientVtr.at(0);

        coefficient = value1 * startTemp * startTemp +
                value2 * startTemp +
                value3;
    }


    float area = integral * coefficient ;

    return area;
}

QPair<QPointF, QPointF> PointCalculate::calculateStartAndEndPoint()
{
    QPair<QPointF,QPointF> leftMaxDiffPointPair =  PointCalculate::calculateMaxDiffPointLeft();
    QPair<QPointF,QPointF> rightMaxDiffPointPair =  PointCalculate::calculateMaxDiffPointRight();
#if 0
    logde<<"b1:"<<leftMaxDiffPointPair.first.x()<<","<<leftMaxDiffPointPair.first.y();
    logde<<"b2:"<<leftMaxDiffPointPair.second.x()<<","<<leftMaxDiffPointPair.second.y();

    logde<<"b3:"<<rightMaxDiffPointPair.first.x()<<","<<rightMaxDiffPointPair.first.y();
    logde<<"b4:"<<rightMaxDiffPointPair.second.x()<<","<<rightMaxDiffPointPair.second.y();
#endif
    QPointF startPoint = calculateIntersection(_leftSelectedPoint,_rightSelectedPoint,
                                               leftMaxDiffPointPair.first,
                                               leftMaxDiffPointPair.second);

    QPointF endPoint = calculateIntersection(_leftSelectedPoint,_rightSelectedPoint,
                                             rightMaxDiffPointPair.first,
                                             rightMaxDiffPointPair.second);

    return qMakePair(startPoint,endPoint);
}
void PointCalculate::updateStartEndPoint()
{
    //需要在a1和a2之间查询是否有高于a1和a2之间的点，若存在，则重新给a1、a2赋值

    for(Global::ExperimentData& ed:_dataVtr){
        if(ed.sampleTemp > _leftSelectedPoint.x() && ed.sampleTemp < _peakPoint.x()){
            if(ed.dsc > _leftSelectedPoint.y()){
                _leftSelectedPoint.setX(ed.sampleTemp);
                _leftSelectedPoint.setY(ed.dsc);
            }
        }

        if(ed.sampleTemp < _rightSelectedPoint.x() && ed.sampleTemp > _peakPoint.x()){
            if(ed.dsc > _rightSelectedPoint.y()){
                _rightSelectedPoint.setX(ed.sampleTemp);
                _rightSelectedPoint.setY(ed.dsc);
            }
        }
    }
}
QString PointCalculate::textFormatPeakPoint(const float enthalpyValue,
                                            const float peakValue,
                                            const float startPoint,
                                            const float endPoint)
{
    return QString("峰的综合信息：\n"
                   "焓值：%1 J/g \n"
                   "峰值：%2℃ \n"
                   "起始点：%3℃ \n"
                   "终止点：%4℃"
                   ).arg(QString::number(enthalpyValue, 'f', 3))
            .arg(QString::number(peakValue, 'f', 3))
            .arg(QString::number(startPoint, 'f', 3))
            .arg(QString::number(endPoint, 'f', 3));
}

// 计算两条直线的交点
QPointF PointCalculate::calculateIntersection(const QPointF p1,const QPointF p2,
                                              const QPointF p3, const QPointF p4){
    // 直线的一般式: A1x + B1y + C1 = 0 和 A2x + B2y + C2 = 0
    float A1 = p2.y() - p1.y();
    float B1 = p1.x() - p2.x();
    float C1 = A1 * p1.x() + B1 * p1.y();

    float A2 = p4.y() - p3.y();
    float B2 = p3.x() - p4.x();
    float C2 = A2 * p3.x() + B2 * p3.y();

    float determinant = A1 * B2 - A2 * B1;

    if (determinant == 0) {
        // 两条直线平行或重合，无交点或无限交点
        return {0, 0};
    } else {
        float x = (B2 * C1 - B1 * C2) / determinant;
        float y = (A1 * C2 - A2 * C1) / determinant;
        return {x, y};
    }
}

QPair<float,float> PointCalculate::getCurveInflectionPointTangent(const float x1,const float x2)
{
    std::vector<float> dataVtr;
    for(Global::ExperimentData& ed:_dataVtr){
        if(x1 < ed.sampleTemp && ed.sampleTemp < x2){
            dataVtr.push_back(ed.sampleTemp);
        }
    }
    // 5
    std::vector<float> processedVtr = movingAverage(dataVtr,5);

    // find max slope.
    float maxSlope = 0.0;
    float targetX = 0.0;
    for (size_t i = 1; i < processedVtr.size(); ++i) {
        float slope = processedVtr[i] - processedVtr[i - 1];
        if(std::abs(slope) > maxSlope){
            maxSlope = slope;
            targetX = processedVtr[i];
        }
    }

    // calculate line slope and axis Y space number b.
    QPointF point = getClosestPointByX(targetX);

    // 使用点斜式方程求y轴截距
    // y = m * x + b
    //      double b = y - m * x;
    float b = point.y() - maxSlope * point.x();

    return qMakePair<float,float>(maxSlope,b);
}
QPointF PointCalculate::getIntersection(const Line& line1, const Line& line2) {
    float x = (line2.intercept - line1.intercept) / (line1.slope - line2.slope);
    float y = line1.slope * x + line1.intercept;
    //    return {x, y};
    return QPointF(x,y);
}
QPointF PointCalculate::getClosestPointByX(const float targetX)
{
    QPointF resultPointF;

    if(targetX < _dataVtr.first().sampleTemp ||
            targetX > _dataVtr.last().sampleTemp){
        return resultPointF;
    }

    float minDiff = std::numeric_limits<float>::max();

    for(Global::ExperimentData &ed:_dataVtr){
        float diff = std::abs(ed.sampleTemp - targetX);
        if (diff < minDiff) {
            minDiff = diff;
            resultPointF = QPointF(ed.sampleTemp,ed.dsc);
        }
    }

    return resultPointF;
}

QString PointCalculate::textFormatNumbericalLabel(const QPointF point)
{
    return QString("数值：\n"
                   "%1℃,%2"
                   ).arg(QString::number(point.x(), 'f', 3))
            .arg(QString::number(point.y(), 'f', 3));
}

QPair<QPointF, QPointF> PointCalculate::getStartAndEndPoint()
{
    if(_dataVtr.empty()){
        return qMakePair(QPointF(), QPointF());
    }

    Global::ExperimentData startPoint  = _dataVtr.at(0);
    Global::ExperimentData endPoint    = _dataVtr.at(_dataVtr.size() - 1);

    return qMakePair<QPointF,QPointF>(
                QPointF(startPoint.sampleTemp,startPoint.dsc),
                QPointF(endPoint.sampleTemp,endPoint.dsc));
}

QString PointCalculate::textFormatStartPoint(const QPointF point)
{
    return QString("外推起始点：\n"
                   "%1℃"
                   ).arg(QString::number(point.x(), 'f', 3));
}

QString PointCalculate::textFormatEndPoint(const QPointF point)
{
    return QString("外推终止点：\n"
                   "%1℃"
                   ).arg(QString::number(point.x(), 'f', 3));
}

QPointF PointCalculate::getClosestPointByY(const double left,const double right,const double valueY)
{
    double minValue = std::numeric_limits<double>::infinity(); // 初始化为正无穷
    QPointF closestPoint;

    for (const Global::ExperimentData& ed : _dataVtr) {
        if (left < ed.sampleTemp && ed.sampleTemp < right) {
            double diff = std::abs(ed.dsc - valueY);
            if (diff < minValue) {
                minValue = diff;
                closestPoint = QPointF(ed.sampleTemp, ed.dsc);
            }
        }
    }

    return closestPoint;
}

QString PointCalculate::textFormatGlassTranstion(const float t1,const float tg,const float t2)
{
    return QString("T1：%1℃\n"
                   "Tg：%2℃\n"
                   "T2：%3℃"
                   ).arg(QString::number(t1, 'f', 3))
            .arg(QString::number(tg, 'f', 3))
            .arg(QString::number(t2, 'f', 3));
}


QPair<float, float> PointCalculate::getMaxMinValue()
{
    if (_dataVtr.isEmpty()) {
        return QPair<float, float>(0.0f, 0.0f);
    }

    float maxDsc = std::numeric_limits<float>::lowest(); // 初始化为最小浮点数
    float minDsc = std::numeric_limits<float>::max();    // 初始化为最大浮点数

    for(const Global::ExperimentData &ed : _dataVtr) {
        if (ed.dsc > maxDsc) {
            maxDsc = ed.dsc;
        }
        if (ed.dsc < minDsc) {
            minDsc = ed.dsc;
        }
    }

    return QPair<float, float>(minDsc, maxDsc);
}

QVector<Global::ExperimentData> PointCalculate::getDataInXRange(const float x1, const float x2)
{
    QVector<Global::ExperimentData> targetVtr;
    for(const Global::ExperimentData &ed : _dataVtr) {
        if(x1 < ed.sampleTemp && ed.sampleTemp < x2){
            targetVtr.push_back(ed);
        }else if (ed.sampleTemp > x2){
            break;
        }

    }

    return targetVtr;
}
QVector<QPointF> PointCalculate::movingAveragePoint(const QVector<QPointF> &points, int windowSize)
{
#if 0
    QVector<QPointF> result;
    int n = points.size();
    for (int i = 0; i < n; ++i) {
        double sumY = 0.0;
        double sumX = 0.0;
        int count = 0;
        for (int j = std::max(0, i - windowSize / 2); j <= std::min(n - 1, i + windowSize / 2); ++j) {
            sumY += points[j].y();
            sumX += points[j].x();
            count++;
        }
        if (count > 0) {
            double avgY = sumY / count;
            double avgX = sumX / count;
            result.append(QPointF(avgX, avgY));
        }
    }
    return result;
#endif
    QVector<QPointF> result;
    int n = points.size();
    for (int i = 0; i < n; ++i) {
        double sumY = 0.0;
        int count = 0;
        for (int j = std::max(0, i - windowSize / 2); j <= std::min(n - 1, i + windowSize / 2); ++j) {
            sumY += points[j].y();
            count++;
        }
        if (count > 0) {
            double avgY = sumY / count;
            result.append(QPointF(points[i].x(), avgY)); // 使用原始的 x 值
        }
    }
    return result;
}
QVector<QPointF> PointCalculate::getNearbyPointGroupByX(const float targetX)
{
    const int conCount = 10;
    QVector<QPointF> tmpPointVtr,targetPointVtr;
    float minDiff = std::numeric_limits<float>::max();

    for(Global::ExperimentData &ed:_dataVtr){
        float diff = std::abs(ed.sampleTemp - targetX);
        if(diff > 10){
            continue;
        }

        tmpPointVtr.push_back({ed.sampleTemp,ed.dsc});

        if (diff < minDiff) {
            minDiff = diff;

            targetPointVtr = QVector<QPointF>(tmpPointVtr.end() - conCount, tmpPointVtr.end());
        }
    }


    return targetPointVtr;
}

// 计算两点之间的斜率
double PointCalculate::calculateSlope(double x1, double y1, double x2, double y2) {
    return (y2 - y1) / (x2 - x1);
}

// 寻找拐点
QVector<double> PointCalculate::findInflectionPoints(
        const QVector<double>& x, const QVector<double>& y) {
    QVector<double> inflectionPointsX;
    for (int i = 2; i < x.size() - 2; ++i) {
        double d1 = calculateSlope(x[i - 2], y[i - 2], x[i - 1], y[i - 1]);
        double d2 = calculateSlope(x[i - 1], y[i - 1], x[i], y[i]);
        double d3 = calculateSlope(x[i], y[i], x[i + 1], y[i + 1]);
        double d4 = calculateSlope(x[i + 1], y[i + 1], x[i + 2], y[i + 2]);

        // 检查二阶导数的符号变化
        if (((d2 - d1) * (d3 - d2) < 0) && ((d3 - d2) * (d4 - d3) < 0)) {
            inflectionPointsX.append(x[i]);
        }
    }
    return inflectionPointsX;
}

// 计算切线方程
QMap<double, PointCalculate::Line>  PointCalculate::calculateTangentLine(
        const QVector<double>& x, const QVector<double>& y) {
    QMap<double, Line> tangentLines;
    QVector<double> inflectionPointsX = findInflectionPoints(x, y);

    for (double xInflection : inflectionPointsX) {
        int i = std::distance(x.begin(), std::find(x.begin(), x.end(), xInflection));
        double slope = calculateSlope(x[i - 1], y[i - 1], x[i + 1], y[i + 1]);
        double yInflection = y[i];
        double intercept = yInflection - slope * xInflection;
        tangentLines[xInflection] = {slope, intercept};
    }

    return tangentLines;
}
QVector<QPointF> PointCalculate::getPointVtrInXRange(const float x1, const float x2)
{
    QVector<QPointF> targetVtr;
    for(const Global::ExperimentData &ed : _dataVtr) {
        if(x1 < ed.sampleTemp && ed.sampleTemp < x2){
            targetVtr.push_back({ed.sampleTemp,ed.dsc});
        }else if (ed.sampleTemp > x2){
            break;
        }
    }

    return targetVtr;
}