//-------------------------------------------------------//
//        Project Code : V2H6K01-23-ENEMAN
//           File Name : RoutineTsamp.cpp
//          Created on : 2023. 8. 8.
//         Description :
//              Author : KimJeongWoo
//  Last modified Date :
//-------------------------------------------------------//
#include "Cpu1DeviceDefine.h"
#include <numeric>              // std::accumulate와 std::inner_product를 위해 필요
#include <vector>
#include <cmath>                // For sqrt() and std::abs()

int Testpcs4 = 0;
int Adc_BUTTON = 0;

int Chk_Botton = 0;
int Chk_Botton_pre = 0;

// 순환 버퍼
#define BUFFER_SIZE 10
#include <cmath> // For sqrt() and std::abs()           // 10 이상 커지면 순간적인 변화를 계산하지 못함?
int currentIndex = 0;

int UV_buffer[BUFFER_SIZE];
int VIS_buffer[BUFFER_SIZE];
int IR_buffer[BUFFER_SIZE];

// 이전 센서 값 저장을 위한 변수 초기화
int CH4_UV_prev = 0, CH4_VIS_prev = 0, CH4_IR_prev = 0;

// 변화량을 저장할 배열
int UV_change[BUFFER_SIZE], VIS_change[BUFFER_SIZE], IR_change[BUFFER_SIZE];
int prev_avg = 0;

//////////////////////////////////////////////////////////
// 큐 구조체 정의
typedef struct {
    int items[BUFFER_SIZE];
    int front;
    int rear;
    int size;
    double total; // 총합을 저장하기 위한 변수
    int lastValue; // 마지막으로 추가된 값
} Queue;

// 큐 초기화 함수
void initQueue(Queue *q) {
    q->front = 0;
    q->rear = -1;
    q->size = 0;
    q->total = 0;
    q->lastValue = 0; // 초기화 시 마지막 값은 0으로 가정
    memset(q->items, 0, sizeof(q->items));
}

// 큐에 데이터 추가 및 누적 계산 수행 함수
void enqueueAndUpdateStats(Queue *q, int value) {
    // 이전 값 저장
    int prevValue = (q->size > 0) ? q->items[q->rear] : 0;

    // 큐에 데이터 추가
    if (q->size == BUFFER_SIZE) {
        // 큐가 꽉 찼을 때, 가장 오래된 데이터를 빼고 새 데이터 추가
        q->total -= q->items[q->front]; // 총합에서 가장 오래된 데이터 제거
        q->front = (q->front + 1) % BUFFER_SIZE;
    } else {
        q->size++;
    }
    q->rear = (q->rear + 1) % BUFFER_SIZE;
    q->items[q->rear] = value;
    q->total += value; // 새 값 추가로 총합 업데이트

    // 마지막 값 업데이트
    q->lastValue = value;

    // 평균 및 변화량 계산은 필요에 따라 진행
}

// 큐에서 데이터 제거 함수 (이 예제에서는 사용하지 않음)
int dequeue(Queue* q) {
    if (q->size == 0) {
        // printf("Queue is empty\n");
        return -1;
    }
    else {
        int item = q->items[q->front];
        q->front = (q->front + 1) % BUFFER_SIZE;
        q->size--;
        return item;
    }
}
////////////////////////////////////////////////////////

// 큐 내 데이터의 평균을 계산하는 함수
double calculateAverage(Queue* q) {
    int sum = 0;
    int i = 0;
    if (q->size > 0) {
        int idx = (q->front + i) % BUFFER_SIZE;
        sum += q->items[idx];
        i++;
    }
    return q->size > 0 ? (double)sum / q->size : 0;
}

// 큐 내 모든 데이터의 평균 변화량을 계산하는 함수
double calculateAverageChange(Queue* q) {
    if (q->size < 2) {
        // 큐에 데이터가 2개 미만일 때는 평균 변화량을 계산할 수 없음
        return 0.0;
    }

    int currentIdx = q->front;
    int nextIdx = (currentIdx + 1) % BUFFER_SIZE;

    int changeSum = q->items[nextIdx] - q->items[currentIdx];
    int count = 1;

    while (nextIdx != q->rear) {
        currentIdx = nextIdx;
        nextIdx = (nextIdx + 1) % BUFFER_SIZE;

        int currentChange = q->items[nextIdx] - q->items[currentIdx];
        changeSum += currentChange;
        count++;
    }

    // 평균 변화량 계산
    return (double)changeSum / count;
}

////////////////////////////////////////////////////////////////////////////
// 상관 계수를 계산하는 함수
double calculate_correlation(const int* x, const int* y, int n) {
    long long sum_x = std::accumulate(x, x + n, 0LL);
    long long sum_y = std::accumulate(y, y + n, 0LL);
    long long sum_x2 = std::inner_product(x, x + n, x, 0LL);
    long long sum_y2 = std::inner_product(y, y + n, y, 0LL);
    long long sum_xy = std::inner_product(x, x + n, y, 0LL);

    double numerator = (double)n * sum_xy - sum_x * sum_y;
    double denominator = sqrt(((double)n * sum_x2 - sum_x * sum_x) * ((double)n * sum_y2 - sum_y * sum_y));

    if (denominator == 0)
        return 0; // 분모가 0이면, 상관관계를 계산할 수 없음

    return numerator / denominator;
}

double calculateCorrelationFromQueues(Queue* q1, Queue* q2) {
    if (q1->size != q2->size || q1->size < 2) {
        // 큐의 크기가 다르거나 데이터 포인트가 2개 미만이면 계산할 수 없음
        return 0;
    }

    int n = q1->size;
    long long sumX = 0, sumY = 0, sumX2 = 0, sumY2 = 0, sumXY = 0;

    for (int i = 0; i < n; ++i) {
        int idx1 = (q1->front + i) % BUFFER_SIZE;
        int idx2 = (q2->front + i) % BUFFER_SIZE;
        int x = q1->items[idx1];
        int y = q2->items[idx2];

        sumX += x;
        sumY += y;
        sumX2 += x * x;
        sumY2 += y * y;
        sumXY += x * y;
    }

    double numerator = n * sumXY - sumX * sumY;
    // 상관 계수를 계산하는 함수 내에서 sqrt 사용 시 타입 명확히 하기
    double denominator = sqrt(static_cast<double>((n * sumX2 - sumX * sumX) * (n * sumY2 - sumY * sumY)));

    if (denominator == 0) {
        // 분모가 0이면, 상관관계를 계산할 수 없음
        return 0;
    }

    return numerator / denominator;
}

// 변화량의 크기를 계산하는 함수
double calculate_change_magnitude(const int* change_array, int n) {
    double sum = 0.0;
    for (int i = 0; i < n; i++) {
        sum += std::abs(change_array[i]); // 변화량의 절대값을 더함
    }
    return sum / n; // 평균을 반환
}


double calculateChangeMagnitudeFromQueue(Queue* q) {
    if (q->size < 2) {
        // 큐에 데이터가 2개 미만일 때는 변화량을 계산할 수 없음
        return 0.0;
    }

    double changeSum = 0;
    int prev = q->items[q->front]; // 시작 요소를 이전 요소로 설정

    for (int i = 1; i < q->size; ++i) {
        int idx = (q->front + i) % BUFFER_SIZE; // 순환 인덱싱
        int current = q->items[idx]; // 현재 요소
        changeSum += std::abs(current - prev); // 이전 요소와의 차이(변화량)의 절대값 더하기
        prev = current; // 현재 요소를 다음 루프의 이전 요소로 설정
    }

    return changeSum / (q->size - 1); // 변화량의 평균 반환
}

void calculateAverageStddevAndAdaptiveThresholdFromQueue(Queue* q, double& avg, double& stddev, double& adaptive_threshold) {
    if (q->size == 0) {
        // 큐가 비어있으면 계산 불가
        avg = 0;
        stddev = 0;
        adaptive_threshold = 0;
        return;
    }

    // 평균 계산
    double sum = 0;
    for (int i = 0; i < q->size; ++i) {
        int idx = (q->front + i) % BUFFER_SIZE;
        sum += q->items[idx];
    }
    avg = sum / q->size;

    // 표준 편차 계산
    double sum_sq_diff = 0;
    for (int i = 0; i < q->size; ++i) {
        int idx = (q->front + i) % BUFFER_SIZE;
        double diff = q->items[idx] - avg;
        sum_sq_diff += diff * diff;
    }
    stddev = sqrt(sum_sq_diff / q->size);

    // 적응형 임계값 설정
    adaptive_threshold = avg + 2 * stddev;
}

/////////////////////////////////////////////////////////////////////////////////////
void RoutineTsamp() {
    static Queue uvQueue;
    static Queue visQueue;
    static Queue irQueue;
    static int initialized = 0;

    if (!initialized) {
        initQueue(&uvQueue);
        initQueue(&visQueue);
        initQueue(&irQueue);
        initialized = 1;
    }

    Lpf1stRun();

    // if (Testpcs4 == 1)
    // {
    //     EepromWriteAdcScale();
    //     Testpcs4 = 0;
    // }
    // if (Testpcs4 == 2)
    // {
    //     EepromReadAdcScale();
    //     Testpcs4 = 0;
//    }


    ModbusACheckBuffer();

    // 새 센서 값 추가
    enqueueAndUpdateStats(&uvQueue, CH4_UV_Flt);
    enqueueAndUpdateStats(&visQueue, CH4_VIS_Flt);
    enqueueAndUpdateStats(&irQueue, CH4_IR_Flt);

//    /////////////////////////////////////////////
//    UV_buffer[currentIndex] = CH4_UV_Flt; // 배열에 센싱값 저장
//    VIS_buffer[currentIndex] = CH4_VIS_Flt; // 배열에 센싱값 저장
//    IR_buffer[currentIndex] = CH4_IR_Flt; // 배열에 센싱값 저장
//
//    // 센서 값 갱신 및 변화량 계산
//    UV_change[currentIndex] = CH4_UV_Flt - CH4_UV_prev; // UV 변화량 계산
//    VIS_change[currentIndex] = CH4_VIS_Flt - CH4_VIS_prev; // VIS 변화량 계산
//    IR_change[currentIndex] = CH4_IR_Flt - CH4_IR_prev; // IR 변화량 계산
//
//    // 현재 값을 '이전 값'으로 저장
//    CH4_UV_prev = CH4_UV_Flt;
//    CH4_VIS_prev = CH4_VIS_Flt;
//    CH4_IR_prev = CH4_IR_Flt;
//
//    currentIndex = (currentIndex + 1) % BUFFER_SIZE; // 인덱스 갱신

    if (CH4_UV_Flt > CH4_UV_max)
        CH4_UV_max = CH4_UV_Flt; // 새로운 최대값 발견 시 갱신
    if (CH4_VIS_Flt > CH4_VIS_max)
        CH4_VIS_max = CH4_VIS_Flt; // 새로운 최대값 발견 시 갱신
    if (CH4_IR_Flt > CH4_IR_max)
        CH4_IR_max = CH4_IR_Flt; // 새로운 최대값 발견 시 갱신

    FaultChecker();

    Chk_Botton = Din.Data.bit.Button;

    if ((Chk_Botton_pre == 0) && (Chk_Botton == 1)) {
        FaultReset = 1;
    }
    else {
        FaultReset = 0;
    }
    Chk_Botton_pre = Chk_Botton;

//    // 임계값을 넘었을 때만 계산
//     if (SystemFault == 1) {
//         uv_vis_correlation = calculate_correlation(UV_buffer, VIS_buffer, BUFFER_SIZE);
//         uv_ir_correlation = calculate_correlation(UV_buffer, IR_buffer, BUFFER_SIZE);
//         vis_ir_correlation = calculate_correlation(VIS_buffer, IR_buffer, BUFFER_SIZE);
            uv_vis_correlation = calculateCorrelationFromQueues(&uvQueue, &visQueue);
            uv_ir_correlation = calculateCorrelationFromQueues(&uvQueue, &irQueue);
            vis_ir_correlation = calculateCorrelationFromQueues(&visQueue, &irQueue);

         // 변화량의 크기 계산
//         uv_change_magnitude = calculate_change_magnitude(UV_change, BUFFER_SIZE);
//         vis_change_magnitude = calculate_change_magnitude(VIS_change, BUFFER_SIZE);
//         ir_change_magnitude = calculate_change_magnitude(IR_change, BUFFER_SIZE);
            uv_change_magnitude = calculateChangeMagnitudeFromQueue(&uvQueue);
            vis_change_magnitude = calculateChangeMagnitudeFromQueue(&visQueue);
            ir_change_magnitude = calculateChangeMagnitudeFromQueue(&irQueue);

         // UV 평균과 표준 편차 계산
//         double sum = 0, sum_sq_diff = 0;
//         for (int i = 0; i < BUFFER_SIZE; ++i) {
//             sum += UV_buffer[i];
//             sum_sq_diff += (UV_buffer[i] - (sum / BUFFER_SIZE)) * (UV_buffer[i] - (sum / BUFFER_SIZE));
//         }
//         double avg = sum / BUFFER_SIZE;
//         stddev = sqrt(sum_sq_diff / BUFFER_SIZE);
//         adaptive_threshold = avg + 2 * stddev;

            calculateAverageStddevAndAdaptiveThresholdFromQueue(&uvQueue, avg, stddev, adaptive_threshold);

         // 최신 값과 바로 이전 값 사이의 변화율 계산을 위한 인덱스 계산
         // int latest_index = (currentIndex - 1 + BUFFER_SIZE) % BUFFER_SIZE;
         // int prev_index = (latest_index - 1 + BUFFER_SIZE) % BUFFER_SIZE;

         // latest_change = UV_buffer[latest_index] - UV_buffer[prev_index];
         // latest_change = avg - prev_avg;
         // prev_avg = avg;

         // if (abs(latest_change) > adaptive_threshold) {
         //     // 변화율이 적응형 임계값을 초과하는 경우 처리
         //     // 예: 알림 발송, 로깅, 경고 등
         //     SET_FT_UV_Level = adaptive_threshold;
         // }
//     }
}