#ifndef DHT22_H
#define DHT22_H

#include "Arduino.h"
#include "SimpleDHT.h"

// Represents a DHT22 sensor module
class DHT22 {
    private:
        byte pin;
        SimpleDHT22 dht;
        float temperature;
        float humidity;
    
    public:

        DHT22(byte pin);

        void updateValues();
        float getTemperature();
        float getHumidity();
};

#endif

#include "Arduino.h"
#include "DHT22.h"

DHT22::DHT22(byte pin) : pin(pin), dht(pin) { };

// Read sensor and update stored values
void DHT22::updateValues() {
    int err = SimpleDHTErrSuccess;

    //update values
    err = dht.read2(&temperature, &humidity, NULL);

    //print any errors
    if(err != SimpleDHTErrSuccess) {
        Serial.print("Error reading DHT22 on pin:");
        Serial.println(pin);

        Serial.print(SimpleDHTErrCode(err));
        Serial.print(", ");
        Serial.println(SimpleDHTErrDuration(err));
    }
};

// Return the last read temperature in degrees F
float DHT22::getTemperature() {
    return temperature;
};

// Return the last read humidity as a percentage between 0-100
float DHT22::getHumidity() {
    return humidity;
}

#ifndef ATOMIZER_CONTROLLER_H
#define ATOMIZER_CONTROLLER_H

#include "Arduino.h"

class AtomizerController {
    private:
        byte controlPin;
        bool enabled;

    public:
        AtomizerController(byte pin);

        bool isEnabled();
        void enable();
        void disable();
};

#endif

#include "Arduino.h"
#include "AtomizerController.h"

// Create new atomizer controller with specified control pin
AtomizerController::AtomizerController(byte pin) : controlPin(pin) {
    pinMode(controlPin, OUTPUT);
    enabled = false;
};

// Return true if the atomizer is enabled
bool AtomizerController::isEnabled() {
    return enabled;
};

// Enable the atomizer
void AtomizerController::enable() {
    digitalWrite(controlPin, HIGH);
    enabled = true;
};

// Disable the atomizer
void AtomizerController::disable() {
    digitalWrite(controlPin, LOW);
    enabled = false;
};

#ifndef FAN_CONTROLLER_H
#define FAN_CONTROLLER_H

#include "Arduino.h"

// Represents a DC fan controller
class FanController {
    private:
        byte controlPin;
        bool enabled;
        
    public:
        FanController(byte pin);

        bool isEnabled();
        void enable();
        void disable();
};

#endif

#include "Arduino.h"
#include "FanController.h"

// Create a new FanController with specified control pin
FanController::FanController(byte pin) : controlPin(pin) {
    pinMode(controlPin, OUTPUT);
    enabled = false;
};

// Return true if the fan controller is currently enabled
bool FanController::isEnabled() {
    return enabled;
};

// Enable the fan controller
void FanController::enable() {
    digitalWrite(controlPin, HIGH);
    enabled = true;
};

// Disable the fan controller
void FanController::disable() {
    digitalWrite(controlPin, LOW);
    enabled = false;
}

#ifndef HUMIDITY_CONTROLLER_H
#define HUMIDITY_CONTROLLER_H

#include "Arduino.h"
#include "Time.h"
#include "TimeAlarms.h"
#include "DHT22.h"
#include "DateTime.h"
#include "AtomizerController.h"
#include "FanController.h"

// Encapsulates settings for the HumidityController
struct HumidityControllerSettings {
    float targetHumidity;
    float kickOnHumidity;
    int fanStopDelay;
    int updateInterval;

    HumidityControllerSettings(float target, float kickOn, int fanStop, int update);
};

// HumidityController class provides methods for controlling the sensors, atomizer, and fan system.
class HumidityController {
    private:
        static DHT22 sensorOne;
        static DHT22 sensorTwo;
        static AtomizerController atomizer;
        static FanController fans;
        static HumidityControllerSettings* settings;
        static bool running;

        static float average(float, float);
        static void runHumidifier();
        static void stopAtomizer();
        static void stopFans();

    public:
        static void init(byte sensorOnePin, byte sensorTwoPin, byte atomizerPin,
                         byte fansPin, HumidityControllerSettings* s);
        static void update();

        static void controlStatus(bool&, bool&);
        static void humidity(float&, float&, float&);
        static void temperature(float&, float&, float&);
};

#endif

#include "Arduino.h"
#include "Time.h"
#include "TimeAlarms.h"
#include "DHT22.h"
#include "DateTime.h"
#include "AtomizerController.h"
#include "FanController.h"
#include "HumidityController.h"

// Create a new HumidityControllerSettings object with specified
// target humidity, kick on humidity, fan stop delay (s), and update interval (s)
HumidityControllerSettings::HumidityControllerSettings(float target, float kickOn, int fanStop, int update){
    targetHumidity = target;
    kickOnHumidity = kickOn;
    fanStopDelay = fanStop;
    updateInterval = update;
};

// static member initializers

DHT22 HumidityController::sensorOne = NULL;
DHT22 HumidityController::sensorTwo = NULL;
AtomizerController HumidityController::atomizer = NULL;
FanController HumidityController::fans = NULL;
HumidityControllerSettings* HumidityController::settings;
bool HumidityController::running = false;


// Initialize the humidity controller with provided sensor, atomizer and fan pins, and settings.
void HumidityController::init(byte sensorOnePin, byte sensorTwoPin, byte atomizerPin,
                                  byte fansPin, HumidityControllerSettings* s) {
    //init sensors
    sensorOne = DHT22(sensorOnePin);
    sensorTwo = DHT22(sensorTwoPin);
    atomizer = AtomizerController(atomizerPin);
    fans = FanController(fansPin);

    //init settings and tracking vars
    settings = s;

    Serial.print("setting update interval: "); Serial.println(settings->updateInterval);
    //set up update interval
    Alarm.timerRepeat(settings->updateInterval, update);
};

// Update the humidity system status, called once per update interval
void HumidityController::update() {
    // update sensor readings
    sensorOne.updateValues();
    sensorTwo.updateValues();

    //check values against threshold
    //float avgHumidity = average(sensorOne.getHumidity(), sensorTwo.getHumidity());
    float avgHumidity, hum1, hum2;
    humidity(avgHumidity, hum1, hum2);

    if(avgHumidity < settings->kickOnHumidity) {
        // start humidifier when kick-on humidity reached.
        if(!running) {
            runHumidifier();
            running = true;
        }
    } else if(avgHumidity >= settings->targetHumidity) {
        if(running) {
            // stop atomizer when target humidity reached.
            stopAtomizer();

            //set up delayed fan stop timer
            Alarm.timerOnce(settings->fanStopDelay, stopFans);
        }
    }
};

// Enable the humidifier and fans
void HumidityController::runHumidifier() {
    Serial.println("Turning ON humidifier");
    atomizer.enable();
    fans.enable();
};

// Stop the atomizer system
void HumidityController::stopAtomizer() {
    Serial.println("Turning OFF atomizer");
    atomizer.disable();
};

// Stop the fan system
void HumidityController::stopFans() {
    Serial.println("Turning OFF fans");
    fans.disable();
    running = false; // set running false so humidity check knows to start up again.
};

// Return the average humidity of the two DHT22 sensors
float HumidityController::average(float a, float b) {
    // if one sensor is down, exclude it from the average
    if(a == 0) {
        a = b;
    } else if(b == 0) {
        b = a;
    }
    
    float avg = (a + b) / 2;

    //print details about averages for debugging
    Serial.print("avg: ");
    Serial.print(avg);
    Serial.print(" ( "); Serial.print(a);
    Serial.print(" , ");  Serial.print(b); Serial.println(" )");

    return avg;
};

// Update the provided variables with the humidity system status
void HumidityController::controlStatus(bool& aEnabled, bool& fEnabled) {
    aEnabled = atomizer.isEnabled();
    fEnabled = fans.isEnabled();
};

void HumidityController::humidity(float &avg, float &one, float &two) {
    Serial.print("Humidity - ");
    one = sensorOne.getHumidity();
    two = sensorTwo.getHumidity();
    avg = average(one, two);
}

void HumidityController::temperature(float &avg, float &one, float &two) {
    Serial.print("Temperature - ");
    one = sensorOne.getTemperature();
    two = sensorTwo.getTemperature();
    avg = average(one, two);
}

#ifndef LIGHT_CONTROLLER_H
#define LIGHT_CONTROLLER_H

#include "Arduino.h"
#include "Scheduling.h"
#include "DateTime.h"
#include "Time.h"
#include "TimeAlarms.h"

// Represents the LightControllerSettings status
struct LightControllerSettings {
    int updateInterval;
    Schedule* schedule;

    LightControllerSettings(Schedule*, int);
};

// Represents the LightController class, provides methods for controlling the light system.
class LightController {
    private:
        static byte dayControlPin, nightControlPin;
        static LightStatus status;
        static LightControllerSettings* settings;
        
    public:
        static void init(byte dayControlPin, byte nightControlPin, LightControllerSettings*);
        static void update();
        static void enableLights(LightStatus);
        static LightStatus getStatus();
        static const char* getStatusString();
};

#endif

#include "Arduino.h"
#include "Scheduling.h"
#include "DateTime.h"
#include "Time.h"
#include "TimeAlarms.h"
#include "LightController.h"

// Create new LightControllerSettings class with specified schedule and update interval
LightControllerSettings::LightControllerSettings(Schedule* s, int interval) : updateInterval(interval) {
    schedule = s;
};

// static member initializers
byte LightController::dayControlPin;
byte LightController::nightControlPin;
LightStatus LightController::status;
LightControllerSettings* LightController::settings;

// Initialize LightController class with provided day and night pins, and settings
void LightController::init(byte dayPin, byte nightPin, LightControllerSettings* s) {
    // init pins
    dayControlPin = dayPin;
    nightControlPin = nightPin;

    // init settings
    settings = s;

    // configure pin modes
    pinMode(dayControlPin, OUTPUT);
    pinMode(nightControlPin, OUTPUT);

    // set up update interval
    Alarm.timerRepeat(settings->updateInterval, update);
};

// Update the light control system, called once per update interval
void LightController::update() {
    Date today = Date(year(), (byte)month(), (byte)day());
    Time now = Time((byte)hour(), (byte)minute(), (byte)second());

    ScheduleEntry* sched = settings->schedule->getEntry(today);
    LightStatus newStatus = sched->getLightStatus(now);

    // if the status has changed, switch lights
    if(status != newStatus) {
        //print notification message
        Serial.print("Switching lights from ");
        Serial.print(status == DAY ? "day" : "night");
        Serial.print(" to ");
        Serial.println(newStatus == DAY ? "day." : "night.");

        Serial.print("Date: ");
        today.printSerial();
        
        Serial.print("Time: ");
        now.printSerial();

        //enable appropriate lights
        enableLights(newStatus);
    }
};

// Return the day/night status of the light controller
LightStatus LightController::getStatus() {
    return status;
};

// Return string representing the day/night status of the system
const char* LightController::getStatusString() {
    return status == DAY ? "day" : "night";
};

// Enable the lights specified by 'newStatus'
void LightController::enableLights(LightStatus newStatus) {
    //update light control pins
    if(newStatus == DAY) {
        digitalWrite(dayControlPin, HIGH);
        digitalWrite(nightControlPin, LOW);
    } else {
        digitalWrite(dayControlPin, LOW);
        digitalWrite(nightControlPin, HIGH);
    }

    //update saved status
    status = newStatus;
}

#ifndef NTPCLIENT_H
#define NTPCLIENT_H

#include "WiFiUdp.h"

//defaults
const u_int NTP_DEFAULT_PORT    = 8888;
const char NTP_DEFAULT_SERVER[] = "us.pool.ntp.org";
const int NTP_DEFAULT_TIMEZONE  = -6; // Central Standard Time = UTC-6:00

// constants
const int NTP_PACKET_BUFFER_SIZE  = 48;   // packet buffer size = 48 bytes
const byte NTP_REQUEST_PORT       = 123;  // NTP requests go to port 123
const byte NTP_RESPONSE_WAIT_TIME = 1500; // wait up to 1500ms for a response from the NTP server
const u_long NTP_UNIX_TIME_OFFSET = 2208988800UL; // number of seconds between 1/1/1900 and 1/1/1970

// Represents an NTPClient object
class NTPClient {
    private:
        WiFiUDP _udp;
        u_int _udpPort;
        String _server;
        int _timeZone;
        byte packetBuffer[NTP_PACKET_BUFFER_SIZE];
    public:
        //NTPClient(); // empty constructor to allow declaration before initialization
        NTPClient(WiFiUDP); //udp only
        NTPClient(WiFiUDP, int); //udp, timezone
        NTPClient(WiFiUDP, String, int); //udp, server, timezone
        NTPClient(WiFiUDP, String, u_int, int); //udp, server, port, timezone

        void initUdp();
        time_t getNTPTime();
        void sendNTPRequestPacket(IPAddress&);
        time_t receiveNTPResponsePacket();
};

#endif

#include "Arduino.h"
#include "NTPClient.h"
#include "WiFi.h"
#include "WiFiUdp.h"
#include "IPAddress.h"
#include "TimeLib.h"

// Create NTPCLient with specified udp instance and default port, server, and time zone
NTPClient::NTPClient(WiFiUDP udp)
        : _udp(udp) {
    _udpPort = NTP_DEFAULT_PORT;
    _server = NTP_DEFAULT_SERVER;
    _timeZone = NTP_DEFAULT_TIMEZONE;
};

// Create NTPCLient with specified udp instance and port, and default server and time zone
NTPClient::NTPClient(WiFiUDP udp, int timeZone)
        : _udp(udp), _timeZone(timeZone) {
    _udpPort = NTP_DEFAULT_PORT;
    _server = NTP_DEFAULT_SERVER;
};

// Create NTPCLient with specified udp instance, port and server, and default time zone
NTPClient::NTPClient(WiFiUDP udp, String server, int timeZone)
        : _udp(udp), _server(server), _timeZone(timeZone) {
    _udpPort = NTP_DEFAULT_PORT;
};

// Create NTPCLient with specified udp instance, port and server, and time zone
NTPClient::NTPClient(WiFiUDP udp, String server, u_int port, int timeZone)
        : _udp(udp), _server(server), _udpPort(port), _timeZone(timeZone) {
};

// Init NTPClient object
void NTPClient::initUdp() {
    Serial.println("Starting UDP for NTPClient...");
    _udp.begin(_udpPort);
};

// request the current time from an NTP server and return
time_t NTPClient::getNTPTime() {
    Serial.println("clearing packets");
    while(_udp.parsePacket() > 0) ; // clear previous incoming udp packets
    Serial.println("...clear");

    // get an IP address from the NTP server pool
    IPAddress ntpServerIP;
    WiFi.hostByName(_server.c_str(), ntpServerIP);

    Serial.print("NTP server IP: ");
    ntpServerIP.printTo(Serial); Serial.println();

    // send NTP request
    sendNTPRequestPacket(ntpServerIP);

    // await response
    return receiveNTPResponsePacket();
};

const byte NTP_LEAP_INDICATOR_BITS = 0b11000000; // LI: first 2 bits (3 = unsynchronized)
const byte NTP_VERSION_BITS        = 0b00100000; // Version: next 3 bits(4 = current version)
const byte NTP_MODE_BITS           = 0b00000011; // Mode: last 3 bits (3 = client)

// Send an NTP request packet to the specified IP address
// Packet format details: https://labs.apnic.net/?p=462
void NTPClient::sendNTPRequestPacket(IPAddress &addr) {
    //fill packet buffer with 0's
    memset(packetBuffer, 0, NTP_PACKET_BUFFER_SIZE);

    // Initialize values needed to form NTP request
    packetBuffer[0] = NTP_LEAP_INDICATOR_BITS | NTP_VERSION_BITS | NTP_MODE_BITS; // first byte: LI, Version, Mode
    packetBuffer[1] = 0;     // second byte: Stratum, or type of clock (0 = Unspecified)
    packetBuffer[2] = 6;     // third byte:  Polling Interval (6 seconds)
    packetBuffer[3] = 0xE7;  // fourth byte: Peer Clock Precision (0xE7 = uint 231 = 11100111 = sint -25 = log_2(1/48,000,000) )

    // 4 bytes of 0 for Root Delay - packetBuffer[4] ... packetBuffer[7]

    // 4 bytes of 0 for Root Dispersion - packetBuffer[8] ... packetBuffer[11]

    // 4 bytes of ASCII codes for Reference Identifier
    // WHY THE FUCK is it "1N14" when that isn't a valid source according to the NTP protocol source list?
    // https://forum.arduino.cc/t/udp-ntp-clients/95868
    // doesn't seem to matter though, soo.... oh well, don't fix it if it ain't broke
    packetBuffer[12] = 49;   // 1
    packetBuffer[13] = 0x4E; // N
    packetBuffer[14] = 49;   // 1
    packetBuffer[15] = 52;   // 4

    //packet initialized, time to send it to the time-server.
    _udp.beginPacket(addr, NTP_REQUEST_PORT);
    _udp.write(packetBuffer, NTP_PACKET_BUFFER_SIZE);
    _udp.endPacket();
    Serial.println("NTP packet sent!");
};

// Receive an incoming NTP response packet
time_t NTPClient::receiveNTPResponsePacket() {
    //set begin wait time
    u_long beginWait = millis();

    //continuously check for response until timed out
    while(millis() - beginWait < NTP_RESPONSE_WAIT_TIME) {
        //get response size
        int size = _udp.parsePacket();

        //check response size
        if(size >= NTP_PACKET_BUFFER_SIZE) {
            Serial.println("NTP Response packet received");

            // read response into packet buffer
            _udp.read(packetBuffer, NTP_PACKET_BUFFER_SIZE);

            // parse 4 bytes from the response into a 32 bit unsigned integer (long)
            // response time is a 64 bit value, with 32 bits each for the integer and decimal portions
            // we don't need to be super accurate, and our time is stored as a non-decimal value
            // so we only need to get the first 32 bits of the time in the response.
            u_long secSince1900;
            secSince1900 = (u_long)packetBuffer[40] << 24; // first byte, shifted 24 bits left, leaving room for 3 more
            secSince1900 |= (u_long)packetBuffer[41] << 16; // second byte, shifted 16 bits left, leaving room for 2 more
            secSince1900 |= (u_long)packetBuffer[42] << 8; // third byte, shifted 8 bits left, leaving room for 1 more
            secSince1900 |= (u_long)packetBuffer[43]; // fourth and final byte, not shifted, since it's the last one.

            //convert from UTC to unix time (seconds since 1970)
            u_long unixTime = secSince1900 - NTP_UNIX_TIME_OFFSET;

            //account for timezone
            unixTime += _timeZone * SECS_PER_HOUR;

            //return time to calling function
            return unixTime;
        }
    }
    
    // return 0 if no response received
    Serial.println("No response received from NTP server");
    return 0;
};

#ifndef WEB_SERVER_H
#define WEB_SERVER_H

#include "WiFiNINA.h"

// Server constants

const byte WS_DEFAULT_PORT     = 80;      // default to port 80
const int WS_LINE_BUFFER_SIZE = 512; // line buffer can hold up to 512 chars.
const char WS_LINE_TERMINATOR  = '\n'; // line terminator character

// line mode status constants, determine how to process current line when parsing requests.

const byte LINE_MODE_REQUEST = 0; //Current line is a request
const byte LINE_MODE_HEADER  = 1; //Current line is a header
const byte LINE_MODE_BODY    = 2; //Current line is a body

// parser status constants

const byte PARSE_SUCCESS = 0; // Parsing succeeded
const byte PARSE_FAIL    = 1; // Parsing failed

// data size constants - since I need to use char[] for these, I must define a fixed max size for each char[]

const byte REQ_METHOD_SIZE       = 10;  // Max size of request method string
const byte REQ_PATH_SIZE         = 255; // Max size of request path string
const byte REQ_PARAMS_STR_SIZE   = 255; // Max size of query params string
const byte REQ_VERSION_SIZE      = 10;  // Max size of request version
const byte REQ_HEADER_COUNT      = 20;  // Max number of headers a request can hold
const byte REQ_HEADER_NAME_SIZE  = 50;  // Max size of header name
const byte REQ_HEADER_VALUE_SIZE = 255; // Max size of header value
const byte REQ_QUERY_PARAMS_SIZE = 10;  // Max number of query param objects in a single request
const int REQ_BODY_SIZE          = 2048;// Max size of body value

// HTTP Status codes - https://developer.mozilla.org/en-US/docs/Web/HTTP/Status

const char HTTP_OK[]                = "200 OK"; // Request succeeded
const char HTTP_BAD_REQUEST[]       = "400 Bad Request"; // The server could not understand the request due to invalid syntax.
const char HTTP_NOT_FOUND[]         = "404 Not Found"; // The server can not find the requested resource.
const char HTTP_LENGTH_REQUIRED[]   = "411 Length Required"; // Server rejected the request because the Content-Length header field is not defined and the server requires it.
const char HTTP_PAYLOAD_TOO_LARGE[] = "413 Payload Too Large"; // Request entity is larger than limits defined by server
const char HTTP_URI_TOO_LONG[]      = "414 URI Too Long"; // The URI requested by the client is longer than the server is willing to interpret.
const char HTTP_HEADER_TOO_LARGE[]  = "431 Request Header Fields Too Large"; // The server is unwilling to process the request because its header fields are too large.
const char HTTP_SERVER_ERROR[]      = "500 Internal Server Error"; // The server has encountered a situation it doesn't know how to handle.


// struct to hold HTTP Header key/value pairs
class HttpHeader {
    public:
        String key;
        String value;
};

// represents a request query parameter
struct QueryParam {
    String key; // param key
    String value; // param value
};

// Represents a response to an incoming HTTP request
class WebResponse {
    private:
        int _currentHeaderIndex = 0;
    public:
        WiFiClient client;
        String status;
        String httpVersion;
        String body;
        HttpHeader headers[REQ_HEADER_COUNT];

        int addHeader(HttpHeader); // add new header to header list
        int addHeader(const char*, const char*); // add new header to header list with basic strings (key, value)
        int addHeader(const char*, const long); // add numerical header, automatically parsing number to string
        int addHeader(const char*, const float); // add floating point numerical header, auto parsing to string

        int send(); // send the response to the client

};

// Represents an incoming HTTP request
class WebRequest {
    public:
        WiFiClient client;
        String method;
        String path;
        QueryParam params[REQ_QUERY_PARAMS_SIZE];
        String httpVersion;
        String body;
        HttpHeader headers[REQ_HEADER_COUNT];

        WebResponse getResponse();
        bool getHeader(String, HttpHeader&);
};

// Web Server class, provides methods for processing and replying to incoming requests.
class WebServer {
    private:
        WiFiServer _server; // WiFi server instance
        byte _lineMode;
        char _lineBuffer[WS_LINE_BUFFER_SIZE];
    public:
        WebServer();
        WebServer(byte);

        void listen(); // begin listening for incoming requests

        int processIncomingRequest(WebRequest&); // process the next incoming request, return 1 when request found, -1 otherwise

        void readLine(WiFiClient); // read the next line into the internal _lineBuffer
        
        byte parseLineRequest(char*, char*, char*, char*); // parse buffered line as a request (src, method, path, params)
        byte parseLineHeader(char*, char*); // parse buffered line as a header (key, value)
        void parseQueryParams(char*, QueryParam*); // parse query params into provided array
};

#endif

#include "Arduino.h"
#include "WebServer.h"
#include "Regexp.h"
#include "WiFiNINA.h"

// ==== WebServer ====

//create WebServer with default port
WebServer::WebServer() : _server(WS_DEFAULT_PORT) { };

//create WebServer with custom port
WebServer::WebServer(byte port) : _server(port) { };

// begin listening to requests
void WebServer::listen() {
    _server.begin();
};

// process next incoming request, updating provided WebRequest object.
int WebServer::processIncomingRequest(WebRequest& req) {
    // get incoming client requests
    WiFiClient client = _server.available();

    // reset _lineMode
    _lineMode = LINE_MODE_REQUEST;

    if(client) { // ensure a client is connected
        Serial.println("WebServer - processing new request: ");
        int i = 0;
        int headerIndex = 0;
        int contentLength = 0;

        while(client.connected() && i < 50) { // ensure connection still open
            if(client.available()) { // ensure client stream is available
                // parse request line
                if(_lineMode == LINE_MODE_REQUEST) {
                    //read a new line into the buffer
                    readLine(client);

                    Serial.println("Processing request line...");
                    char method[REQ_METHOD_SIZE];
                    char path[REQ_PATH_SIZE];
                    char httpVersion[REQ_VERSION_SIZE];
                    char params[REQ_PARAMS_STR_SIZE];

                    // process request line
                    byte res = parseLineRequest(method, path, params, httpVersion);

                    if(res == PARSE_SUCCESS) {
                        //print results
                        Serial.println("Success!!!");
                        Serial.print("Method: "); Serial.println(method);
                        Serial.print("Path: "); Serial.println(path);
                        Serial.print("Params string: "); Serial.println(params);
                        Serial.print("Version: "); Serial.println(httpVersion);

                        //assign values on request
                        req.method = method;
                        req.path = path;
                        req.httpVersion = httpVersion;
                        parseQueryParams(params, req.params);
                    } else {
                        Serial.println("FAILED");
                    }
                    
                    //set line mode to headers for next iteration
                    _lineMode = LINE_MODE_HEADER;

                // parse header line
                } else if (_lineMode == LINE_MODE_HEADER) {
                    //read a new line into the buffer
                    readLine(client);

                    Serial.println("Processing header line...");
                    char headerKey[REQ_HEADER_NAME_SIZE];
                    char headerValue[REQ_HEADER_VALUE_SIZE];

                    // if blank line, switch to body mode and continue loop
                    if(_lineBuffer[0] == '\r') {
                        Serial.println("Empty line, switching to body mode");
                        _lineMode = LINE_MODE_BODY;
                        continue;
                    }

                    //parse line
                    parseLineHeader(headerKey, headerValue);
                    
                    //add header to request
                    HttpHeader h;
                    h.key = headerKey;
                    h.value = headerValue;
                    req.headers[headerIndex] = h;
                    headerIndex++;

                    // check for content length header and update local var
                    if(strcmp(headerKey, "Content-Length") == 0) {
                        contentLength = h.value.toInt();
                        Serial.print("Found Content-Length header: ");
                        Serial.println(contentLength);
                    }

                    //print parsed value
                    Serial.print("Added header - "); Serial.print(h.key); Serial.print(": "); Serial.println(h.value);

                //parse body line
                } else if (_lineMode == LINE_MODE_BODY) {
                    Serial.println("Processing body...");
                    char body[REQ_BODY_SIZE];
                    memset(body, 0, REQ_BODY_SIZE); // clear body buffer

                    client.readBytes(body, contentLength);

                    req.body = String(body);

                    Serial.println(req.body);

                    // return the parsed request object, for external handling, make sure to add client first
                    req.client = client;
                    return 1;
                } // end if (_lineMode == ...)

            } //end if (client.available())

            i++;
            Serial.print("End loop - i = "); Serial.println(i);

        } //end while(client.connected())
    } //end if (client)
    return -1; // return fail if no incoming requests
};

// clear line buffer and read next line
void WebServer::readLine(WiFiClient client) {
    memset(_lineBuffer, 0, WS_LINE_BUFFER_SIZE);
    client.readBytesUntil(WS_LINE_TERMINATOR, _lineBuffer, WS_LINE_BUFFER_SIZE);
}

// parse the HTTP method, path, and query param strings from the current line in _lineBuffer
byte WebServer::parseLineRequest(char* method, char* path, char* params, char* version) {
    // check matches
    MatchState ms;
    char* regexParams = "^(%u-) (%S-)%?(%S-) (HTTP.*)";
    char* regexNoParams = "^(%u-) (%S-) (HTTP.*)";
    int res;
    int expectedMatches;

    ms.Target(_lineBuffer);
    if(String(_lineBuffer).indexOf('?') > 0){
        res = ms.Match(regexParams);
        expectedMatches = 4;
    } else {
        res = ms.Match(regexNoParams);
        expectedMatches = 3;
    }
    

    // process results
    switch(res) {
        case REGEXP_MATCHED: //match
            { // enclosing scope for variables created in this branch of the switch
                int matchCount = ms.level;
                if(matchCount != expectedMatches) { // unexpected number of matches
                    Serial.print("Unexpected number of matches when parsing request line: expected = 4, actual = ");
                    Serial.println(matchCount);
                    break;
                }
                
                //get captured groups
                if(expectedMatches == 4) {
                    ms.GetCapture(method, 0);
                    ms.GetCapture(path, 1);
                    ms.GetCapture(params, 2);
                    ms.GetCapture(version, 3);
                } else {
                    ms.GetCapture(method, 0);
                    ms.GetCapture(path, 1);
                    ms.GetCapture(version, 2);
                }
                
                return PARSE_SUCCESS;
            }
            break;
        case REGEXP_NOMATCH: //no match
            Serial.print("No matches found...");
            break;
        default: //some sort of error
            Serial.print("Error trying to match...");
    }

    // if we exit the switch statement before returning, that means there was a problem parsing.
    return PARSE_FAIL;
};

// Parse query params from string 'paramStr' into the QueryParam array 'dest'
void WebServer::parseQueryParams(char* paramStr, QueryParam* dest) {
    bool inKey = true;
    char keyBuffer[REQ_PARAMS_STR_SIZE];
    char valueBuffer[REQ_PARAMS_STR_SIZE];
    QueryParam paramBuffer;
    int bufferIndex = 0;
    int paramIndex = 0;

    //make sure buffers are empty to start
    memset(keyBuffer, 0, REQ_PARAMS_STR_SIZE);
    memset(valueBuffer, 0, REQ_PARAMS_STR_SIZE);

    Serial.println("Parsing query params");

    for(int i = 0; i < REQ_PARAMS_STR_SIZE; i++) {
        char c = paramStr[i];
        Serial.print("Current char: "); Serial.print(c);

        //return if reached end of string
        if(c == 0x00) {
            Serial.println("..end");
            //add last from buffer and return
            dest[paramIndex] = QueryParam { String(keyBuffer), String(valueBuffer) };
            return;
        }

        if(inKey) { // processing a key
            Serial.print("..in key");
            if(c == '=') {
                Serial.println("..end of key");
                // end of key
                inKey = false;
                bufferIndex = 0;
            } else {
                Serial.println("..add to buffer");
                //add char to keyBuffer, and increment bufferIndex
                keyBuffer[bufferIndex] = c;
                bufferIndex++;
            }
        } else { // processing a value
            Serial.print("..in value");
            if(c == '&') {
                Serial.println("..end of value");
                // end of value
                inKey = true;
                //add QueryParam object
                dest[paramIndex] = QueryParam { String(keyBuffer), String(valueBuffer) };

                //clear buffers
                memset(keyBuffer, 0x00, REQ_PARAMS_STR_SIZE);
                memset(valueBuffer, 0x00, REQ_PARAMS_STR_SIZE);

                //update indices
                paramIndex++;
                bufferIndex = 0;
            } else {
                Serial.println("..add to buffer");
                //add char to valueBuffer and increment bufferIndex
                valueBuffer[bufferIndex] = c;
                bufferIndex++;
            }
        }

    }
};

// parse an HTTP header from the current line in _lineBuffer
byte WebServer::parseLineHeader(char* key, char* value) {
    MatchState ms;
    ms.Target(_lineBuffer);
    char res = ms.Match("^(.-): (.*)");
    
    switch(res) {
        case REGEXP_MATCHED:
            {
                int matchCount = ms.level;
                if(matchCount != 2) {
                    Serial.print("Unexpected number of matches when parsing header line: expected = 2, actual = ");
                    Serial.println(matchCount);
                    break;
                }

                //get captured groups
                ms.GetCapture(key, 0);
                ms.GetCapture(value, 1);
            }
            break;
        case REGEXP_NOMATCH:
            Serial.println("No matches found...");
            break;
        default: //some sort of error
            Serial.print("Error trying to match...");
    }

    // if we exit the switch statement before returning, that means there was a problem parsing.
    return PARSE_FAIL;
};


// ==== WebRequest ====

//return a WebResponse object that can be used to reply to the incoming request
WebResponse WebRequest::getResponse() {
    //create new response object
    WebResponse res;
    res.client = client;
    res.httpVersion="HTTP/1.1";

    //set up default status
    res.status = HTTP_OK;

    //set up default headers
    res.addHeader("Content-Type", "text/plain");
    res.addHeader("Server", "Arduino NANO 33 IoT - Snake Tank Controller");
    res.addHeader("Connection", "close");

    return res;
};

// Update 'dest' with header specified by 'name'
bool WebRequest::getHeader(String name, HttpHeader& dest) {
    for(int i = 0; i < REQ_HEADER_COUNT; i++) {
        HttpHeader curr = headers[i];
        if(curr.key == name) {
            dest = curr;
            return true;
        }
    }
    return false;
}


// ==== WebResponse ====

// Add new header with floating point value
int WebResponse::addHeader(const char* key, const float value) {
    HttpHeader h { key, String(value, 10) };
    return addHeader(h);
};

// Add new header with integer value
int WebResponse::addHeader(const char* key, const long value) {
    String(value, 10);
    char valueStr[32];
    itoa(value, valueStr, 10);
    HttpHeader h { key, valueStr };
    return addHeader(h);
};

// Add a new header to the header list. Returns 1 for success, returns -1 if error.
int WebResponse::addHeader(const char* key, const char* value) {
    HttpHeader h { key, value };
    return addHeader(h);
};

// Add a new header to the header list. Returns 1 for success, returns -1 if error.
int WebResponse::addHeader(HttpHeader h) {
    //make sure we have room
    if(_currentHeaderIndex >= REQ_HEADER_COUNT) {
        return -1; //return fail
    }

    //add header
    headers[_currentHeaderIndex] = h;
    _currentHeaderIndex += 1;
    return 1; // return success
};

// Attempt to send the response to the requesting client. Returns -1 for fail, 1 for success.
int WebResponse::send() {
    if(client.connected()) {
        //send version and status line.
        client.println(httpVersion + " " + status);

        // calculate content-length header and add
        int bodyLen = body.length();
        if(bodyLen > 0) {
            char bls[5];
            itoa(bodyLen, bls, 10);
            addHeader("Content-Length", bls);
        } else {
            addHeader("Content-Length", "0");
        }

        //send headers
        for (int i = 0; i < _currentHeaderIndex; i++) {
            HttpHeader h = headers[i];
            client.println(h.key + ": " + h.value);
        }

        client.println(); // empty line to signify end of headers

        client.print(body);// send body

        delay(20); // wait for client to receive all data

        // close connection and return success
        client.stop();
        return 1;
    }

    return -1; // client not connected.
}

#ifndef ROUTER_H
#define ROUTER_H

#include "WebServer.h"

typedef void(*rest_callback_t)(WebRequest&, WebResponse&); // typedef for rest route callback function

const byte ROUTER_MAX_ROUTES = 20; // max number of routes that can be held by the router

// represents a REST route in the router
struct Route {
    String method; // request method
    String path; // request path
    rest_callback_t callback;
};

// REST server router class
class Router {
    private:
        int _routeIndex; // current route index, used for adding new routes to the correct location.
    public:
        WebServer server; // the underlying WebServer instance
        Route routes[ROUTER_MAX_ROUTES]; // list of routes currently set up

        bool route(String, String, rest_callback_t); // add new route to the router (method, path, callback);
        bool get(String, rest_callback_t); // helper to add new GET route
        bool post(String, rest_callback_t); // helper to add new POST route

        void handle(WebRequest&);

};

#endif

#include "Router.h"

#include "WebServer.h"

//register a new route on the router
bool Router::route(String method, String path, rest_callback_t cb) {
    if(_routeIndex < ROUTER_MAX_ROUTES) {
        routes[_routeIndex] = Route { method, path, cb};
        _routeIndex++;
    }
    return false;
};

//Helper to register new GET route
bool Router::get(String path, rest_callback_t cb) {
    return route("GET", path, cb);
};

//Helper to register new POST route
bool Router::post(String path, rest_callback_t cb) {
    return route("POST", path, cb);
};

// Handle an incoming WebRequest by calling the correct handler for the path
void Router::handle(WebRequest& req) {
    // find matching route
    for(int i = 0; i < _routeIndex; i++) {
        Route r = routes[i];
        if(r.method == req.method && r.path == req.path) {
            WebResponse res = req.getResponse();
            r.callback(req, res);
            return;
        }
    }

    Serial.println("No matching routes for request");
    WebResponse res = req.getResponse();
    res.status = HTTP_NOT_FOUND;
    res.send();
};

#ifndef WIFI_CONTROLLER_H
#define WIFI_CONTROLLER_H

#include "Arduino.h"
#include "MacAddress.h"

// Represents settings for a WifiController object
struct WifiControllerSettings {
    String ssid;
    String password;
    bool requireLatestFirmware;
    int connectionCheckInterval;

    WifiControllerSettings(String, String, bool, int);
};

// Provides methods for managing wifi connections
class WifiController {
    private:
        static String firmwareVersion;
        static MacAddress macAddress;
        static WifiControllerSettings* settings;
    public:
        static void init(WifiControllerSettings*);
        static bool verifyModule();
        static bool verifyFirmware();
        static MacAddress getMacAddress();
        static void connect();
        static void checkConnectionStatus();

        static void printAvailableNetworks();
        static void printNetwork(byte);

        static String statusToString(byte);
};

#endif

#include "Arduino.h"
#include "WiFi.h"
#include "TimeAlarms.h"

#include "MacAddress.h"
#include "WifiController.h"

// Convert an encryption type enum to a string
String encryptionTypeToString(byte encryptionType) {
    switch(encryptionType) {
        case ENC_TYPE_TKIP:
            return "WPA";
            break;
        case ENC_TYPE_WEP:
            return "WEP";
            break;
        case ENC_TYPE_CCMP:
            return "WPA2";
            break;
        case ENC_TYPE_AUTO:
            return "Auto";
            break;
        case ENC_TYPE_NONE:
            return "Open";
            break;
        case ENC_TYPE_UNKNOWN:
            return "Unknown";
            break;
    }
};

// Create instance of WifiControllerSettings with specified
// ssid, pass, 'requireLatestFw' and connection check interval
WifiControllerSettings::WifiControllerSettings(String ssid, String pass, bool requireLatestFw, int connCheckInterval)
        : ssid(ssid), password(pass), requireLatestFirmware(requireLatestFw),
            connectionCheckInterval(connCheckInterval) { }


// static member initializers

String WifiController::firmwareVersion;
MacAddress WifiController::macAddress = NULL;
WifiControllerSettings* WifiController::settings;

// Init WifiController module with specified settings
void WifiController::init(WifiControllerSettings* s) {
    settings = s;

    //modules
    Serial.println("Checking module: ");
    if(!verifyModule()){
        Serial.println("Aborting WifiController.init()");
    }

    //firmware
    Serial.println("Checking firmware: ");
    bool fwCurrent = verifyFirmware();
    if(settings->requireLatestFirmware && !fwCurrent) {
        Serial.println("Aborting WifiController.init() - latest firmware required.");
    }

    //mac address
    Serial.println("Getting MAC Address:");
    macAddress = getMacAddress();
    Serial.println(macAddress.toString());

    //print network list
    //printAvailableNetworks();

    //connect to the network
    connect();

    //display network info
    IPAddress address = WiFi.localIP();
    address.printTo(Serial); Serial.println();

    //set up timer to check connection status and attempt to resolve disconnects
    Alarm.timerRepeat(settings->connectionCheckInterval, checkConnectionStatus);
};

// Convert wifi status enum value to string
String WifiController::statusToString(byte status) {
    switch(status) {
        case WL_NO_MODULE:
            return "No module available";
        case WL_IDLE_STATUS:
            return "Idle";
        case WL_NO_SSID_AVAIL:
            return "No SSID available";
        case WL_SCAN_COMPLETED:
            return "Scan completed";
        case WL_CONNECTED:
            return "Connected";
        case WL_CONNECT_FAILED:
            return "Connect failed";
        case WL_CONNECTION_LOST:
            return "Connection lost";
        case WL_DISCONNECTED:
            return "Disconnected";
        case WL_AP_CONNECTED:
            return "AP Connected";
        case WL_AP_FAILED:
            return "AP Failed";
        case WL_AP_LISTENING:
            return "AP Listening";
        default:
            return "N/A";
    }
};

// Verify the wifi capabilities on the device
bool WifiController::verifyModule() {
    byte moduleStatus = WiFi.status();
    if(moduleStatus == WL_NO_MODULE) {
        Serial.println("  Communication with WiFi module failed. Not connecting..");
        return false;
    }
    Serial.println("  Success - module status: " + statusToString(moduleStatus));
    return true;
};

// Verify that the wifi firmware is up-to-date
bool WifiController::verifyFirmware() {
    firmwareVersion = WiFi.firmwareVersion();
    if(firmwareVersion < WIFI_FIRMWARE_LATEST_VERSION) {
        Serial.println("  Firmware outdated: current(" + firmwareVersion
            + ") latest(" + WIFI_FIRMWARE_LATEST_VERSION + ")");
        return false;
    }
    Serial.println("  Firmware up to date: current(" + firmwareVersion + ")");
    return true;
};

// Return the devices MAC address
MacAddress WifiController::getMacAddress() {
    byte macBytes[6];
    WiFi.macAddress(macBytes);
    MacAddress mac = MacAddress(macBytes);
    return mac;
};

// Connect to the wifi network specified in the current settings
void WifiController::connect() {
    Serial.println("Connecting to network: " + settings->ssid);
    int ssidLen = settings->ssid.length()+1;
    int passLen = settings->password.length()+1;

    char ssid[ssidLen];
    char pass[passLen];
    
    settings->ssid.toCharArray(ssid, ssidLen);
    settings->password.toCharArray(pass, passLen);

    int attempts = 3;
    while(WiFi.status() != WL_CONNECTED && attempts > 0) {
        attempts--;

        Serial.print("Wifi.begin("); Serial.print(ssid); Serial.print(", "); Serial.print(pass); Serial.println(")");
        WiFi.begin(ssid, pass);
        delay(5000);
        Serial.println("Status: " + statusToString(WiFi.status()));
    }
};

// Check the current network connection status
void WifiController::checkConnectionStatus() {
    if(WiFi.status() != WL_CONNECTED) {
        Serial.println("WiFi disconnected - attempting to reconnect");
        connect();
    }
};

// Print a list of all currently available networks
void WifiController::printAvailableNetworks() {
    Serial.println("Scanning networks...");

    byte networkCount = WiFi.scanNetworks();

    if(networkCount == -1) {
        Serial.println("Unable to find any networks");
        return;
    }

    Serial.print("Scan complete - ");
    Serial.print(networkCount);
    Serial.println(" networks found");

    for(byte i = 0; i < networkCount; i++) {
        printNetwork(i);
    }
};

// Print the wifi network specified by 'byte'
void WifiController::printNetwork(byte i) {
    Serial.print(i+1); Serial.print(" : ");

    //print ssid
    Serial.print("SSID: "); Serial.print(WiFi.SSID(i));

    // print mac address of AP
    byte bssid[6];
    WiFi.BSSID(i, bssid);
    MacAddress apMacAddr = MacAddress(bssid);
    Serial.print("\tBSSID: "); Serial.print(apMacAddr.toString());

    // print encryption type
    Serial.print("\tEncryption: ");
    Serial.println(encryptionTypeToString(WiFi.encryptionType(i)));

    // print channel
    Serial.print("\tChannel: "); Serial.print(WiFi.channel(i));

    // print signal strength
    Serial.print("\tSignal: "); Serial.print(WiFi.RSSI(i)); Serial.println(" dBm");
};

#ifndef WIFI_DATA_H
#define WIFI_DATA_H
#include "Arduino.h"

// Represents a MC address
struct MacAddress {
    byte bytes[6];
    
    MacAddress(byte[6]);
    String toString();
};

#endif

#include "MacAddress.h""

// Create instance of MacAddress
MacAddress::MacAddress(byte b[6]){
    for(int i = 0; i < 5; i++) {
        bytes[i] = b[i];
    }
};

// Convert to string HEX representation of current mac address
String MacAddress::toString() {
    String result;
    for(int i = 5; i >= 0; i--) {
        if(bytes[i] < 0xF) { //add leading zero if only one hex digit.
            result += "0";
        }

        result += String(bytes[i], HEX); //print digit(s)
        
        if(i > 0) { // add colon separators
            result += ":";
        }
    }
    return result;
};

#ifndef ROUTES_H
#define ROUTES_H
#include "Regexp.h"

#include "globals.h"
#include "WebServer.h"
#include "Bitflag.h"
#include "Lines.h"

// web server headers

const char* HEAD_TIME_UTC          = "x-Time-UTC";
const char* HEAD_TIME_YEAR         = "x-Time-Year";
const char* HEAD_TIME_MONTH        = "x-Time-Month";
const char* HEAD_TIME_DAY          = "x-Time-Day";
const char* HEAD_TIME_HOUR         = "x-Time-Hour";
const char* HEAD_TIME_MINUTE       = "x-Time-Minute";
const char* HEAD_TIME_SECOND       = "x-Time-Second";

const char* HEAD_HUMIDITY_TARGET   = "x-Humidity-Target";
const char* HEAD_HUMIDITY_KICK_ON  = "x-Humidity-KickOn";
const char* HEAD_HUMIDITY_FAN_STOP = "x-Humidity-FanStopDelay";
const char* HEAD_HUMIDITY_UPDATE   = "x-Humidity-UpdateInterval";
const char* HEAD_HUMIDITY_AVERAGE  = "x-Humidity-Average";
const char* HEAD_HUMIDITY_ONE      = "x-Humidity-SensorOne";
const char* HEAD_HUMIDITY_TWO      = "x-Humidity-SensorTwo";
const char* HEAD_HUMIDITY_FANS     = "x-Humidity-Fans";
const char* HEAD_HUMIDITY_ATOMIZER = "x-Humidity-Atomizer";

const char* HEAD_TEMP_AVERAGE      = "x-Temperature-Average";
const char* HEAD_TEMP_ONE          = "x-Temperature-SensorOne";
const char* HEAD_TEMP_TWO          = "x-Temperature-SensorTwo";

const char* HEAD_LIGHT_MODE        = "x-Light-Mode"; // current light mode (day/night)
const char* HEAD_LS_TYPE           = "x-Light-Schedule-Type"; // light schedule type (fixed, monthly, etc.)


bool updateFixedSchedule(String body) {
    Serial.println("Updating fixed schedule...");
    char bodyChars[body.length()+1];
    char sDayHour[2], sDayMin[2], sDaySec[2], sNightHour[2], sNightMin[2], sNightSec[2];
    int dayHour, dayMin, daySec, nightHour, nightMin, nightSec;
    MatchState ms;

    // perform matching
    memset(bodyChars,0,body.length()+1);
    Serial.println(body);
    Serial.println(body.length());
    body.toCharArray(bodyChars, body.length()+1, 0);

    ms.Target(bodyChars);
    int res = ms.Match("D{(%d%d):(%d%d):(%d%d)}N{(%d%d):(%d%d):(%d%d)}", 0); // (%d%d):(%d%d):(%d%d)
    Serial.println(res);
    Serial.println(ms.level);
    if(res != REGEXP_MATCHED) {
        Serial.print("error matching: "); Serial.println(res);
        return false;
    }
    if(ms.level != 6) {
        Serial.println("not enough matches");
        return false;
    }

    // capture matches
    ms.GetCapture(sDayHour, 0);
    ms.GetCapture(sDayMin, 1);
    ms.GetCapture(sDaySec, 2);
    ms.GetCapture(sNightHour, 3);
    ms.GetCapture(sNightMin, 4);
    ms.GetCapture(sNightSec, 5);

    // convert to ints
    dayHour = String(sDayHour).toInt();
    dayMin = String(sDayMin).toInt();
    daySec = String(sDaySec).toInt();
    nightHour = String(sNightHour).toInt();
    nightMin = String(sNightMin).toInt();
    nightSec = String(sNightSec).toInt();

    // update schedule
    Serial.println("updating");
    lightControllerSchedule = new FixedSchedule(
        new ScheduleEntry(
            Time(dayHour, dayMin, daySec),
            Time(nightHour, nightMin, nightSec)
        )
    );

    return true;
};

bool updateMonthlySchedule(String body) {
    Serial.println("Updating monthly schedule");
    char line[LINE_SIZE];
    char sDayHour[2], sDayMin[2], sDaySec[2], sNightHour[2], sNightMin[2], sNightSec[2];
    int dayHour, dayMin, daySec, nightHour, nightMin, nightSec;
    MatchState ms;
    ScheduleEntry* entries[LINE_COUNT];
    Lines lines = Lines::split(body.c_str());
    lines.printLines();

    for(int i = 0; i < LINE_COUNT; i++) {
        // get line and match
        Serial.print("Checking line: "); Serial.println(i);
        lines.getLine(line, i);
        Serial.println(line);
        ms.Target(line);
        char res = ms.Match("D{(%d%d):(%d%d):(%d%d)}N{(%d%d):(%d%d):(%d%d)}", 0);

        if(res != REGEXP_MATCHED) {
            Serial.print("error matching: "); Serial.println(res);
            return false;
        }
        if(ms.level != 6) {
            Serial.println("not enough matches");
            return false;
        }

        // capture matches
        ms.GetCapture(sDayHour, 0);
        ms.GetCapture(sDayMin, 1);
        ms.GetCapture(sDaySec, 2);
        ms.GetCapture(sNightHour, 3);
        ms.GetCapture(sNightMin, 4);
        ms.GetCapture(sNightSec, 5);

        // convert to ints
        dayHour = String(sDayHour).toInt();
        dayMin = String(sDayMin).toInt();
        daySec = String(sDaySec).toInt();
        nightHour = String(sNightHour).toInt();
        nightMin = String(sNightMin).toInt();
        nightSec = String(sNightSec).toInt();

        entries[i] = new ScheduleEntry(Time(dayHour, dayMin, daySec), Time(nightHour, nightMin, nightSec));
    }

    lightControllerSchedule = new MonthlySchedule(entries);
    return true;
};

void route_getTest(WebRequest& req, WebResponse& res) {
    for(int i = 0; i < 4; i++) {
        Serial.print("params["); Serial.print(i); Serial.print("].key = "); Serial.println(req.params[i].key);
        Serial.print("params["); Serial.print(i); Serial.print("].value = "); Serial.println(req.params[i].value);
    }

    res.addHeader("Header-Test", "Test header");
    res.body="Test body contents";
    res.send();
};

void route_getTime(WebRequest& req, WebResponse& res){
    res.addHeader(HEAD_TIME_UTC, (long)now());
    res.addHeader(HEAD_TIME_YEAR, (long)year());
    res.addHeader(HEAD_TIME_MONTH, (long)month());
    res.addHeader(HEAD_TIME_DAY, (long)day());
    res.addHeader(HEAD_TIME_HOUR, (long)hour());
    res.addHeader(HEAD_TIME_MINUTE, (long)minute());
    res.addHeader(HEAD_TIME_SECOND, (long)second());

    res.send();
};

void route_getHumiditySettings(WebRequest& req, WebResponse& res){
    res.addHeader(HEAD_HUMIDITY_TARGET, humidityControllerSettings->targetHumidity);
    res.addHeader(HEAD_HUMIDITY_KICK_ON, humidityControllerSettings->kickOnHumidity);
    res.addHeader(HEAD_HUMIDITY_FAN_STOP, (long)(humidityControllerSettings->fanStopDelay));
    res.addHeader(HEAD_HUMIDITY_UPDATE, (long)(humidityControllerSettings->updateInterval));

    res.send();
};

void route_postHumiditySettings(WebRequest& req, WebResponse& res){
    HttpHeader target, kickOn, fanStop, updateInterval;
    Bitflag valuesProvided; // bitflag to indicate which values should be updated

    //get relevant headers and set flag bits when found
    if (req.getHeader(HEAD_HUMIDITY_TARGET, target)) {
        valuesProvided.setBit(BIT_HUM_TARGET);
    }
    if (req.getHeader(HEAD_HUMIDITY_KICK_ON, kickOn)) {
        valuesProvided.setBit(BIT_HUM_KICK_ON);
    }
    if (req.getHeader(HEAD_HUMIDITY_FAN_STOP, fanStop)) {
        valuesProvided.setBit(BIT_HUM_FAN_STOP);
    }
    if (req.getHeader(HEAD_HUMIDITY_UPDATE, updateInterval)) {
        valuesProvided.setBit(BIT_HUM_UPDATE);
    }

    if(!valuesProvided.checkAny()) {
        //return 400 BadRequest unless at least one new value provided
        res.status = HTTP_BAD_REQUEST;
        res.body = "No update values provided, unable to process request.";
    } else {
        if(valuesProvided.checkBit(BIT_HUM_TARGET)) {
            //update target humidity
            Serial.println("Updating target humidity");
            humidityControllerSettings->targetHumidity = target.value.toFloat();
            res.addHeader(HEAD_HUMIDITY_TARGET, humidityControllerSettings->targetHumidity);
        }
        if(valuesProvided.checkBit(BIT_HUM_KICK_ON)) {
            //update kickon humidity
            Serial.println("Updating kickon humidity");
            humidityControllerSettings->kickOnHumidity = kickOn.value.toFloat();
            res.addHeader(HEAD_HUMIDITY_KICK_ON, humidityControllerSettings->kickOnHumidity);
        }
        if(valuesProvided.checkBit(BIT_HUM_FAN_STOP)) {
            //update fan stop delay
            Serial.println("Updating fan stop delay");
            humidityControllerSettings->fanStopDelay = fanStop.value.toInt();
            res.addHeader(HEAD_HUMIDITY_FAN_STOP, (long)(humidityControllerSettings->fanStopDelay));
        }
        if(valuesProvided.checkBit(BIT_HUM_UPDATE)) {
            //update humidity update check interval
            Serial.println("Updating humidity check interval");
            humidityControllerSettings->fanStopDelay = updateInterval.value.toInt();
            res.addHeader(HEAD_HUMIDITY_UPDATE, (long)(humidityControllerSettings->updateInterval));
        }
    }

    res.send();
};

void route_getHumidityStatus(WebRequest& req, WebResponse& res){
    float avgTemp, tempOne, tempTwo;
    float avgHum, humOne, humTwo;
    bool fansEnabled, atomizerEnabled;

    HumidityController::controlStatus(fansEnabled, atomizerEnabled);
    HumidityController::humidity(avgHum, humOne, humTwo);
    HumidityController::temperature(avgTemp, tempOne, tempTwo);
    
    res.addHeader(HEAD_TEMP_AVERAGE, avgTemp);
    res.addHeader(HEAD_TEMP_ONE, tempOne);
    res.addHeader(HEAD_TEMP_TWO, tempTwo);
    res.addHeader(HEAD_HUMIDITY_AVERAGE, avgHum);
    res.addHeader(HEAD_HUMIDITY_ONE, humOne);
    res.addHeader(HEAD_HUMIDITY_TWO, humTwo);
    res.addHeader(HEAD_HUMIDITY_FANS, fansEnabled ? "enabled" : "disabled");
    res.addHeader(HEAD_HUMIDITY_ATOMIZER, atomizerEnabled ? "enabled" : "disabled");

    res.send();
};

void route_getLightStatus(WebRequest& req, WebResponse& res){
    res.addHeader(HEAD_LIGHT_MODE, LightController::getStatusString());

    res.send();
};

void route_getLightSchedule(WebRequest& req, WebResponse& res){
    //add type header
    int schedTypeCode = lightControllerSchedule->getScheduleType();
    int bodySize = 25;
    res.addHeader(HEAD_LS_TYPE, (long)schedTypeCode);
    Serial.println(schedTypeCode);

    if(schedTypeCode == ScheduleType::MONTHLY) {
        bodySize = 12 * 25; // upgrade body size to hold 12 lines
    }

    //get body string
    char body[bodySize];
    memset(body, 0, bodySize);
    lightControllerSchedule->toString(body);

    // add body to request
    res.body = body;
    Serial.println(res.body);

    //send response
    res.send();
};

void route_postLightSchedule(WebRequest& req, WebResponse& res){
    HttpHeader schedType;
    bool validSchedProvided = false;
    int schedTypeCode = 0;
    Serial.println(req.body);

    // check schedule type header is valid
    if(req.getHeader(HEAD_LS_TYPE, schedType)) {
        schedTypeCode = schedType.value.toInt();
        validSchedProvided = Schedule::validScheduleType(schedTypeCode);
    }

    if(validSchedProvided) {
        bool updateSucceeded = false;
        // check which type we're updating to.
        switch(schedTypeCode) {
            case ScheduleType::FIXED:
            {
                Serial.println("fixed");
                // update fixed schedule
                updateSucceeded = updateFixedSchedule(req.body);
                break;
            }
            case ScheduleType::MONTHLY:
            {
                Serial.println("monthly");
                // update monthly schedule
                updateSucceeded = updateMonthlySchedule(req.body);
                break;
            }
        }

        if(updateSucceeded) {
            Serial.println("Success updating schedule");
            char body[300];
            memset(body, 0, 300);
            lightControllerSchedule->toString(body);
            Serial.println(body);
        } else {
            Serial.println("Failed to update schedule");
            res.status = HTTP_SERVER_ERROR;
        }

        // send response
        res.send();
    } else {
        // return bad formatted request
        res.status = HTTP_BAD_REQUEST;
        res.body = "Invalid request, unable to parse";
        res.send();
    }
}

#endif