#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define BAUD_RATE           9600
// Sensor pin
#define TEMPERATURE_PIN     A11
// Task delay
#define TASK_REC     3000
// Max length of array
#define MAX                 10
// Constant for formulas
#define KELVIN_CONST        273.15
#define CELSIUS_CONST       298.15
#define ANALOG_CONST_L      1024.
#define ANALOG_CONST_T      1023.
#define RESIS_CONST         2000
#define FAHRENHEIT_CONST1   1.8
#define FAHRENHEIT_CONST2   32
#define VOLT_CONST          5
#define TEMPLATE            100.0
// Array Size
#define MAX_ARRAY           3
#define MAX_MEDIAN          3
// Array
float temperatureArray[MAX_ARRAY] ={};
float LuxArray[MAX_ARRAY] ={};
// Indexes
int temperatureIndex = 0;
int LuxIndex = 0;
// Median Array Temp
float medianArray[MAX_MEDIAN]= {}; 
int medianIndex = 0;

// should match the Beta Coefficient of the thermistor
const double BETA = 3950;
// LDR Characteristics
const float GAMMA = 0.7;
const float RL10 = 50;

void io_init_function(void);
char read_function(FILE *stream);
char write_function(char ch, FILE *stream);

void setup()
{
    io_init_function();
    printf("System is on!\n");
}

void loop()
{

  static uint32_t task_prev_time = 0;

  if (millis() >= task_prev_time)
  {
    // Temperature analog value
    int analogTempValue = analogRead(TEMPERATURE_PIN);
    
    float temperature = calcTemp(analogTempValue);

    // Raw Data
    char buff[MAX] = "";
    dtostrf(temperature, 7, 2, buff);
    printf("Raw Celsius Value: %s ℃\n", buff);

    // Save temperature data in the array
    temperatureArray[temperatureIndex] = temperature;
    temperatureIndex = (temperatureIndex + 1) % MAX_ARRAY;

    // Check if the array is full
    if (temperatureIndex == 0)
    {
      // Apply median filter to the temperature array
      float filteredTemperature = medianFilter(temperatureArray, MAX_ARRAY);

      char tempstr[MAX] = "";
      dtostrf(filteredTemperature, 7, 2, tempstr);
      printf("Median Temperature: %s ℃ \n", tempstr);

      // Save the median value in the array
      medianArray[medianIndex] = filteredTemperature;
      medianIndex = (medianIndex + 1) % MAX_MEDIAN;

      // Check if we have collected three median values
      if (medianIndex == 0)
      {
        // Apply sliding average filter to the median array
        float Average = AverageFilter(medianArray, MAX_MEDIAN);
        float fahrenheit = ((Average * FAHRENHEIT_CONST1) + FAHRENHEIT_CONST2) ;
        float kelvin = Average +  KELVIN_CONST; 

        // Output filtered temperature
        char tempstr[MAX] = "";
        dtostrf(Average, 7, 2, tempstr);
        printf("Average Temperature: %s ℃ \n", tempstr);
        dtostrf(fahrenheit, 7, 2, tempstr);
        printf("Fahrenheit Value: %s F\n", tempstr);
        dtostrf(kelvin, 7, 2, tempstr);
        printf("Kelvin Value: %s K\n", tempstr);
      }
    }
    printf("\n");

    task_prev_time = millis() + TASK_REC;
  }

}

void io_init_function(void)
{
  Serial.begin(BAUD_RATE);

  static FILE stream = {};

  fdev_setup_stream(&stream, write_function, read_function, _FDEV_SETUP_RW);

  stdin = &stream;
  stdout = &stream;
}

char read_function(FILE *stream)
{
  while (!(Serial.available() > 0));
  
  return Serial.read();
}

char write_function(char ch, FILE *stream)
{
  Serial.write(ch);

  return 0;
}

float calcTemp(int analogTempValue)
{
      // Steinhart–Hart equation
    float celsius = 1 /(log(1 / (ANALOG_CONST_T / analogTempValue - 1)) / BETA + 1.0 / CELSIUS_CONST) - KELVIN_CONST;
    float temp = round((celsius * TEMPLATE))/ TEMPLATE; // template 00.00

    return celsius;
}

// Function to calculate median of an array
float medianFilter(float arr[], int size)
{
  // Sort the array
  for (int i = 0; i < size - 1; i++)
  {
    for (int j = 0; j < size - i - 1; j++)
    {
      if (arr[j] > arr[j + 1])
      {
        float temp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = temp;
      }
    }
  }

  // Calculate median
  if (size % 2 == 0)
  {
    return (arr[size / 2 - 1] + arr[size / 2]) / 2.0;
  }
  else
  {
    return arr[size / 2];
  }
}

// Function to calculate average of an array
float AverageFilter(float arr[], int size)
{
  float sum = 0;
  for (int i = 0; i < size; i++)
  {
    sum += arr[i];
  }
  return sum / size;
}