#include <Arduino.h>



#include "wifi_functions.h"

bool debug=false; //print Serial information
bool mqtt=false;
bool eccalibrationoutput=true; //serial output for ec calibration
/* Write to file with:
sudo stty -F /dev/ttyUSB0 115200
cat /dev/ttyUSB0 | tee received.txt
*/




#include "helpfunctions.h"
#include "ADS1X15.h"

ADS1115 ADS(0x48);


// ######## Temperature
#include "temperature.h"




// ######## EC
#include "ec.h"



// ######## Water Level
#include "waterlevel.h"


// ######## Flow Rate
#include "flow.h"

// ######## Soilmoisture
#include "soilmoisture.h"




unsigned long last_check=0;





bool valueError=false;

#define PIN_BUTTON 12
#define PIN_LED 13


void setup() {
  pinMode(PIN_BUTTON,INPUT_PULLUP);
  pinMode(PIN_LED,OUTPUT);
  digitalWrite(PIN_LED,LOW);
  Serial.begin(115200);
  if (mqtt) {
    WiFi.begin(ssid, pass);
    client.begin(mqtt_host, net);
    client.onMessage(messageReceived);
    connect();
  }

  //init ADS1115
  if (!ADS.begin()) {
    Serial.println("Error:"); delay(2000); Serial.println("ADS1115 Init Error!");
  }
  ADS.setGain(0);


  Serial.println("Setup EC");
  ec_setup();

  //Serial.println("Setup Waterlevel");
  //waterlevel_setup(); //temporarily disabled

  Serial.println("Setup Temperature");
  temperature_setup();
  
  Serial.println("Setup Flow");
  flow_setup();

  Serial.println("Setup Soilmoisture");
  sm_setup();

  Serial.println("Finished Setup");
  delay(200);

  //Test adc to ec function output
  /*
  Serial.println();
  for (int i=750;i<14183;i+=100) {
    float _ec=ec_getECfromADC(i);
    Serial.print(i); Serial.print(","); Serial.print(_ec); Serial.println();
  }

  delay(100000);
  */


  //Serial.println("time,tempReservoir,ECadcCalib,ECadc,ECadcAdjusted,EC,EC25");
  //Serial.println("time,tempReservoir,ECadcCalib,ECadc,ECadcAdjusted");

}

void loop() {
  unsigned long loopmillis=millis();
  enableTiming=true; //reactivate
  
  
  ec_loop(loopmillis);

  temperature_loop(loopmillis);
  
  //waterlevel_loop(loopmillis);

  flow_loop(loopmillis);

  sm_loop(loopmillis);
 

  static bool getReading=false;

  if (!eccalibrationoutput && !digitalRead(PIN_BUTTON)) {
    valueError=false;
    Serial.println("Reset ValueError flag by user");
    digitalWrite(PIN_LED,valueError);
    delay(100);
  }


  

  if (eccalibrationoutput && !digitalRead(PIN_BUTTON) && !getReading) {
    if (!isValueArrayOK(ec_calib_array,EC_CALIB_ARRAY_SIZE,EC_ADC_UNAVAILABLE)) {
      for (uint8_t blink=0;blink<5;blink++) {
        digitalWrite(PIN_LED,HIGH);
        delay(100);
        digitalWrite(PIN_LED,LOW);
        delay(100);
      }
    }else{
      getReading=true;
      force_ec_measurement=true;
      ec_flag_measurement_available=false;
      digitalWrite(PIN_LED,HIGH);
    }
  }

  
  if (eccalibrationoutput && ec_flag_measurement_available && getReading) {
    
    ec_flag_measurement_available=false;
    getReading=false;
    digitalWrite(PIN_LED,LOW);
    Serial.print(loopmillis); Serial.print(",");
    Serial.print(tempCmean_reservoir); Serial.print(",");
    Serial.print(ec_calib_adc); Serial.print(",");
    Serial.print(ec_adc_A); Serial.print(",");
    Serial.print(ec_adc_adjusted_A); Serial.print(",");
    Serial.print(ec_adc_B); Serial.print(",");
    Serial.print(ec_adc_adjusted_B);
    Serial.println();
  }
  
  if (loopmillis>last_check+2000) {  //check values
  
    last_check=loopmillis;
    
    if (tempCmean_air==DEVICE_DISCONNECTED_C || tempCmean_reservoir==DEVICE_DISCONNECTED_C || tempCmean_case==DEVICE_DISCONNECTED_C) {
      valueError=true;
    }
    
    if (sm_mean1==SM_DISCONNECTED || sm_mean2==SM_DISCONNECTED) {
      valueError=true;
    }
    if (ec_A==EC_UNAVAILABLE || ec_B==EC_UNAVAILABLE){
      valueError=true;
    }
    

    if (!eccalibrationoutput) {
      digitalWrite(PIN_LED,valueError);
    }

   

    if (debug) {
      Serial.println("_______________________");
      Serial.print(millis()/1000.0,2); Serial.println(":");

      Serial.print("temperature reservoir,air = ");
      Serial.print(tempCmean_reservoir); Serial.print(","); Serial.print(tempCmean_air);
      Serial.println();



      Serial.print("sm_mean 1,2,3 = ");
      Serial.print(sm_mean1); Serial.print(",");
      Serial.print(sm_mean2); Serial.print(",");
      Serial.print(sm_mean3);
      Serial.println();

      /*
      Serial.print("sm_mean 1,2,3 = ");
      Serial.print(getMean(sm_mean1array,SM_SIZE)); Serial.print(",");
      Serial.print(getMean(sm_mean2array,SM_SIZE)); Serial.print(",");
      Serial.print(getMean(sm_mean3array,SM_SIZE));
      Serial.println();
      Serial.print("sm_max 1,2,3 = ");
      Serial.print(getMax(sm_mean1array,SM_SIZE)); Serial.print(",");
      Serial.print(getMax(sm_mean2array,SM_SIZE)); Serial.print(",");
      Serial.print(getMax(sm_mean3array,SM_SIZE));
      Serial.println();
      Serial.print("sm_min 1,2,3 = ");
      Serial.print(getMin(sm_mean1array,SM_SIZE)); Serial.print(",");
      Serial.print(getMin(sm_mean2array,SM_SIZE)); Serial.print(",");
      Serial.print(getMin(sm_mean3array,SM_SIZE));
      Serial.println();
      //Serial.print(getMax(sm_mean3array,SM_SIZE)); Serial.println();
      */

      Serial.print("Flow = "); Serial.print(flow);
      Serial.println();

      Serial.print("EC ec_calib_adc,ec_adc_A,ec_adc_adjusted_A = ");
      Serial.print(ec_calib_adc); Serial.print(",");
      Serial.print(ec_adc_A); Serial.print(",");
      Serial.print(ec_adc_adjusted_A);
      Serial.println();
      Serial.print("EC ec_A,ec25_A = ");
      Serial.print(ec_A); Serial.print(",");
      Serial.print(ec25_A); 
      Serial.println();


      Serial.print("EC ec_calib_adc,ec_adc_B,ec_adc_adjusted_B = ");
      Serial.print(ec_calib_adc); Serial.print(",");
      Serial.print(ec_adc_B); Serial.print(",");
      Serial.print(ec_adc_adjusted_B);
      Serial.println();
      Serial.print("EC ec_B,ec25_B = ");
      Serial.print(ec_B); Serial.print(",");
      Serial.print(ec25_B); 
      Serial.println();

      Serial.print("Waterlevel,Volume = ");
      Serial.print(waterlevel); Serial.print(",");
      Serial.print(watervolume);

      Serial.println();    



      

    }


    if (mqtt && mqtt_loop(loopmillis)) {
      if (sendallnext_flag) {
        sendallnext_flag=false;
        enableTiming=false;
      }

      if (tempCmean_reservoir!=DEVICE_DISCONNECTED_C) {
        publishValueTimed("temperature/reservoir",tempCmean_reservoir,2,timing_temperature_reservoir,loopmillis); 
      }
      if (tempCmean_air!=DEVICE_DISCONNECTED_C) {
        publishValueTimed("temperature/air",tempCmean_air,2,timing_temperature_air,loopmillis); 
      }
      if (tempCmean_case!=DEVICE_DISCONNECTED_C) {
        publishValueTimed("temperature/case",tempCmean_case,2,timing_temperature_case,loopmillis); 
      }
      if (sm_mean1!=SM_DISCONNECTED) {
        publishValueTimed("soilmoisture/sm1",sm_mean1,3,timing_soilmoisture_sm1,loopmillis); 
      }
      if (sm_mean2!=SM_DISCONNECTED) {
        publishValueTimed("soilmoisture/sm2",sm_mean2,3,timing_soilmoisture_sm2,loopmillis); 
      }
      if (sm_mean3!=SM_DISCONNECTED) {
        publishValueTimed("soilmoisture/sm3",sm_mean3,3,timing_soilmoisture_sm3,loopmillis); 
      }
      
      publishValueTimed("flow/flow",flow,2,timing_flow,loopmillis); 

      if (waterlevel!=WATERLEVEL_UNAVAILABLE) {
        bool _published=publishValueTimed("waterlevel/height",waterlevel,2,timing_waterlevel,loopmillis); 
        if (_published) { //use height for timing. send calculated volume with it
          publishValue("waterlevel/volume",watervolume,2);
        }
      }
      

      if (ec_flag_measurement_available){
        ec_flag_measurement_available=false;

        if (ec_calib_adc!=0) {
          publishValue("ec/eccalibadc",ec_calib_adc,0); 
        }

        //Probe A
        if (ec_adc_A!=0) {
          publishValue("ecA/adc",ec_adc_A,0); 
        }
        
        if (ec_adc_adjusted_A!=0) {
          publishValue("ecA/adcadjusted",ec_adc_adjusted_A,0); 
        }
        if (ec_A!=EC_UNAVAILABLE){
          publishValue("ecA/ec",ec_A,0); 
          publishValue("ecA/sc",ec25_A,0); 
        }

        //Probe B
        if (ec_adc_B!=0) {
          publishValue("ecB/adc",ec_adc_B,0); 
        }
        
        if (ec_adc_adjusted_B!=0) {
          publishValue("ecB/adcadjusted",ec_adc_adjusted_B,0); 
        }
        if (ec_B!=EC_UNAVAILABLE){
          publishValue("ecB/ec",ec_B,0); 
          publishValue("ecB/sc",ec25_B,0); 
        }

      }

      /*
      if (ec_adc!=0) {
        publishValueTimed("ec/adc",ec_adc,0,timing_ec_adc,loopmillis); 
      }
      if (ec_calib_adc!=0) {
        publishValueTimed("ec/eccalibadc",ec_calib_adc,0,timing_ec_calibadc,loopmillis); 
      }
      if (ec_adc_adjusted!=0) {
        publishValueTimed("ec/adcadjusted",ec_adc_adjusted,0,timing_ec_adcadjusted,loopmillis); 
      }
      if (ec!=EC_UNAVAILABLE){
        publishValueTimed("ec/ec",ec,0,timing_ec_ec,loopmillis); 
        publishValueTimed("ec/sc",ec25,0,timing_ec_sc,loopmillis); 
      }*/
    }
    



    

      
    
  }
  
}