#ifndef PREDIKSI_H
#define PREDIKSI_H

// --- 1. Kelas untuk Mengelola Antrean Data (FIFO) ---
class LinkedList {
  public:
    LinkedList(int max_size){
      max_length = max_size;
      data = new float[max_size];
    }
    
    size_t size(){ return length; }

    // Mekanisme: Masukkan data baru, buang data paling lama jika penuh
    void update(float new_data){
      data[last_p] = new_data;
      last_p = (last_p + 1) % max_length; // Geser posisi data terakhir
      
      if(length < max_length) {
        length++; // Tambah jumlah data jika belum mencapai batas (5)
      } else {
        first_p = (first_p + 1) % max_length; // Buang/geser data paling lama
      }
    }

    float getIndex(int index){
      return data[(index + first_p) % max_length];
    }

  private:
    float* data;
    size_t length = 0;
    size_t max_length;
    int first_p = 0; // Menunjuk ke data paling lama
    int last_p = 0;  // Menunjuk ke data paling baru
};

// --- 2. Kelas untuk Perhitungan Matematika Regresi Linear ---
class LinearRegression {
  public:
    LinearRegression(int max_size){
      data = new LinkedList(max_size);
    }

    // Fungsi untuk memasukkan data ketinggian air terbaru
    void update(float new_data){
      data->update(new_data);
    }

    // Fungsi untuk menghitung prediksi n-menit ke depan
    float predict(int n_next = 1){
      int n = data->size();
      
      // Jika data kurang dari 2, belum bisa menghitung tren (kembalikan data terakhir)
      if(n < 2) return (n == 1) ? data->getIndex(0) : 0;

      float sumX = 0, sumY = 0, sumXY = 0, sumX2 = 0;
      
      // Hitung komponen rumus Regresi Linear (y = mx + c)
      for(int i=0; i<n; i++){
        sumX += i;
        sumY += data->getIndex(i);
        sumXY += i * data->getIndex(i);
        sumX2 += i * i;
      }

      float denominator = (n * sumX2 - sumX * sumX);
      if (denominator == 0) return data->getIndex(n - 1);

      // m = kemiringan (tren kenaikan/penukuran)
      float m = (n * sumXY - sumX * sumY) / denominator;
      // c = titik potong
      float c = (sumY - m * sumX) / n;
      
      // --- PERBAIKAN LOGIKA DI SINI ---
      // Hasil prediksi langsung merujuk pada nilai n_next sebagai variabel X
      return (m * n_next) + c;
    }

  private:
    LinkedList* data;
};

#endif