#include <stdio.h>
#include <time.h>
#include <string.h>

#undef timeout
#include "mqtt/async_client.h"

#include <nlohmann/json.hpp>
using json = nlohmann::json;

#include <csignal>

/* From Arduino.h */

#define HIGH 0x1
#define LOW 0x00

#define IO_INPUT 0x02
#define IO_OUTPUT 0x04

#define DIGITAL 0x08
#define ANALOG 0x10

#define PI 3.1415926535897932384626433832795
#define HALF_PI 1.5707963267948966192313216916398

#define true 1
#define false 0

/* Configuration MQTT */
const std::string ADDRESS = "tcp://rabbitmq:1883";
const std::string CLIENTID = "CppClientTP";
const std::string TOPIC = "geii/in/#";
const int QOS = 1;

int s0, s1;

// Temps

// Timestamp unix en millisecondes
// t_start :      timestamp de départ
// t_backup :     timestamp de la précédente itération
// t_elapsed :    temps écoulé en secondes depuis le départ
// dt (delta t) : temps écoulé en secondes depuis la dernière itération
unsigned long t_start, t_backup;
double t_elapsed, dt;

unsigned long millis()
{
	struct timespec now;
	clock_gettime(CLOCK_REALTIME, &now);
	return ((unsigned long)now.tv_sec) * 1000 + ((unsigned long)now.tv_nsec) / 1000000;
}

#define OP_DIGITAL_READ 0
#define OP_DIGITAL_WRITE 1
#define OP_ANALOG_READ 2
#define OP_ANALOG_WRITE 3
#define OP_PIN_MODE 4

typedef struct PinIO
{
  unsigned char mode;
  int ivalue;
  double dvalue;
  int error; // % = 1 /error ex 1 / 20 = 5 %
  double efficacite; // 0 - 100%
  unsigned long start;
  unsigned long time;
  double duration;
  unsigned int nb; // compteur d'activation
  int memory;
  unsigned char raising;
  unsigned char falling;
} PinIO;

PinIO _digital[256];

void pinMode(unsigned char p, unsigned char mode)
{
  _digital[p].mode = 0x01 | mode;

  _digital[p].ivalue = 0;
  _digital[p].dvalue = 0.0;

  _digital[p].nb = 0;
  _digital[p].time = 0.0;
  _digital[p].duration = 0.0;
  _digital[p].start = 0;
  _digital[p].raising = 0;
  _digital[p].memory = 0;
}

// Réception des messages MQTT
// ************************************************************
class callback : public virtual mqtt::callback
{
public:
	void message_arrived(mqtt::const_message_ptr msg) override
	{
		std::string payload = msg->to_string();

		std::cout << "MQTT IN : ";

		try
		{
			json j = json::parse(payload);

			// Ne rien faire si l'objet JSON est vide
			if (j.empty())
				return;

			if (j.contains("b0"))
				s0 = j["b0"].get<int>() != 0;

			std::cout << "boutons : " << s0 << std::endl;
		}
		catch (const json::parse_error &e)
		{
			std::cerr << "Erreur JSON : " << e.what() << "\n";
		}
	}
};
// ************************************************************

mqtt::async_client client(ADDRESS, CLIENTID);

void open() {

	callback cb;
	client.set_callback(cb);

	mqtt::connect_options connOpts;
	connOpts.set_clean_session(true);
	connOpts.set_user_name("admin");
	connOpts.set_password("geii2025");

	try
	{
		client.connect(connOpts)->wait();
		client.start_consuming();
		client.subscribe(TOPIC, QOS)->wait();
	}
	catch (const mqtt::exception &exc)
	{
		std::cerr << "Erreur MQTT: " << exc.what() << "\n";
		return;
	}
}

void close() {
	try
	{
		client.unsubscribe(TOPIC)->wait();
		client.stop_consuming();
		client.disconnect()->wait();
	}
	catch (const mqtt::exception &exc)
	{
		std::cerr << "Erreur déconnexion MQTT: " << exc.what() << std::endl;
	}

	std::cout << "Fin du programme" << std::endl;
}

void send()
{
	json obj = {
			{"s0", s0},
			{"s1", s1},
			{"s2", 0},
			{"s3", 1},
			{"s4", 1},
	};

	std::string payload = obj.dump();
	auto msg = mqtt::make_message("geii/out", payload);
	msg->set_qos(0);
	client.publish(msg);

	std::cout << s0 << std::endl;

	usleep(100000);
}


/* ********************************************************
 *  TEMPORISATION RETARD A LA MONTEE                      *
 *  La sortie passe à 1 au bout de la tempo               *
 ******************************************************** */

class TemporisationRetardMontee
{
    // methodes
  public :
    // Contructeur qui prend la duree souhaitee de la temporisation
	TemporisationRetardMontee(unsigned long duree)
	{
		this->duree = duree;
		sortie = false;
		captureTemps = false;
	}
    // Activation de la temporisation. Doit etre fait tout le temps de la duree de la tempo
	void activation()
	{
		// Capture du temps de reference
		if(!captureTemps)
		{
			debut = millis();
			captureTemps = true;
		}
		// Calcul du temps ecoule depuis le temps de reference
		tempsEcoule = millis() - debut;
		// Mise a 1 de la fin de tempo
		if (tempsEcoule >= duree)
		{
			sortie = true;
			captureTemps = false;
		}
		else
		{
			sortie = false;
		}
	}
	// Precharge de la temporisation
	void setDuree(unsigned long majduree)
	{
		duree = majduree;
		sortie = false;
		captureTemps = false;
	}
	// Interrogation du bit de fin de tempo
  bool getSortie()
	{
		return(sortie);
	}
	// Recuperation du temps ecoule depuis le debut si necessaire
	unsigned long getTempsEcoule()
	{
		return(tempsEcoule);
	}

  // Attributs
  private:
    unsigned long duree;
    unsigned long debut;
    unsigned long tempsEcoule;
		bool captureTemps;
    bool sortie;
};

/********************************************************
* TEMPORISATION RETARD A LA DESCENTE                *
*  La sortie passe à 0 au bout de la tempo              *
*********************************************************/
class TemporisationRetardDescente
{
  public :
    // Contructeur qui prend la duree souhaitee de la temporisation
	TemporisationRetardDescente(unsigned long duree)
	{
		this->duree = duree;
		sortie = false;
		captureTemps = false;
	}
    // Activation de la temporisation. Doit etre fait tout le temps de la duree de la tempo
	void activation()
	{
		// Capture du temps de reference
		if(!captureTemps)
		{
			debut = millis();
			captureTemps = true;
			sortie = true;
		}
		// Calcul du temps ecoule depuis le temps de reference
		tempsEcoule = millis() - debut;
		// Mise a 0 de la fin de tempo
		if (tempsEcoule >= duree)
		{
			sortie = false;
			captureTemps = false;
		}
	}
	// Precharge de la temporisation
	void setDuree(unsigned long majduree)
	{
		duree = majduree;
		sortie = false;
		captureTemps = false;
	}
	// Interrogration du bit de fin de tempo
    bool getSortie()
	{
		return(sortie);
	}
	// Recuperation du temps ecoule depuis le debut si necessaire
    unsigned long getTempsEcoule()
	{
		return(tempsEcoule);
	}

  private:
    unsigned long duree;
    unsigned long debut;
    unsigned long tempsEcoule;
    bool captureTemps;
    bool sortie;
};

/********************************************************
****  CLIGNOTEUR *************************************
*********************************************************/
class Clignoteur
{
    // methodes
  public :
	// Construteur qui prend en parametre le temps haut ou bas souhaitee
	Clignoteur(int baseDeTemps)
	{
		this->baseDeTemps = baseDeTemps;
	}
	// Fonction qui renvoie true si le clignoteur est ├á l'├®tat haut et false s'il est ├á l'├®tat bas
    bool statut()
	{
		return ((millis() / baseDeTemps) % 2 == 1);
	}

    // Attributs
  private:
    int baseDeTemps;
};

/********************************************************
****  COMPTEUR *************************************
**** ATTENTION : Il faut gerer le front montant dans le programme
*********************************************************/
class Compteur
{
    // methodes
  public :
	// Constructeur qui prend en parametre la valeur de preselection
	Compteur(int valeurPreselection)
	{
		this->valeurPreselection = valeurPreselection;
		valeur = 0;
	}
	// Incrementation du compteur
	void incrementer()
	{
		valeur++;
	}
	// Decrementation du compteur
	void decrementer()
	{
		valeur--;
	}
	// remise a zero du compteur
	void remettreAZero()
	{
		valeur = 0;
	}
	// recuperation de la valeur courante
	int getValeurCourante()
	{
		return(valeur);
	}
	// est-ce que la preselection est atteinte (sortie Q compteur Siemens ou Schnieder)
	bool getSortie()
	{
		return(valeur == valeurPreselection);
	}

    // Attributs
  private:
    int valeur;
    int valeurPreselection;
};

/********************************************************
****  MISE A L'ECHELLE DE VALEUR ************************
*********************************************************/
class MiseAEchelle
{
  public :
	// Constructeur qui ne prend en parametre la plage d'entree et la plage de sortie
	MiseAEchelle(float minEntree,float maxEntree,float minSortie,float maxSortie)
	{
		this->minEntree = minEntree;
		this->maxEntree = maxEntree;
		this->minSortie = minSortie;
		this->maxSortie = maxSortie;
	}
	// fonction de conversion qui prend la valeur a convertir et renvoie la valeur convertie
	float convertir(float valeurAConvertir)
	{
		if(valeurAConvertir >= minEntree && valeurAConvertir <= maxEntree)
		{
			float norm = (1 / (maxEntree - minEntree)) * (valeurAConvertir - minEntree);
			float scale = (maxSortie - minSortie) * norm + minSortie;
			return(scale);
		}
		return(-1000);
	}

    // Attributs
  private:
    float minEntree;
    float minSortie;
    float maxEntree;
	float maxSortie;
};

/* READ */

int digitalRead(int p)
{
  return ((_digital[p].mode & IO_INPUT) && (_digital[p].mode & DIGITAL) && (_digital[p].mode & 0x01)) ? _digital[p].ivalue : 0;
}

double analogRead(int p)
{
  return ((_digital[p].mode & IO_INPUT) && (_digital[p].mode & ANALOG) && (_digital[p].mode & 0x01)) ? _digital[p].dvalue : 0.0;
}

/* WRITE */

void digitalWrite(unsigned int p, int value)
{
  if (p > 255)
  {
    printf("Pin %d is out of Range.", p);
    return;
  }

  // En panne !
  if (!(_digital[p].mode & 0x01))
  {
    return;
  }

  if (!(_digital[p].mode & IO_OUTPUT && _digital[p].mode & DIGITAL))
  {
    printf("Pin %d is not a digital input.", p);
    return;
  }

  unsigned long m = millis();

  if (value != _digital[p].ivalue)
  {
    _digital[p].time = _digital[p].time > 5000 ? 0 : 5000 - _digital[p].time;
  }
  else
  {
    _digital[p].time += m - _digital[p].start;
  }

  if (value && !_digital[p].ivalue)
  {
    _digital[p].start = m;
    _digital[p].nb += 1;
  }
  else if (value)
  {
    _digital[p].duration += dt;
  }

  _digital[p].raising = (_digital[p].memory < _digital[p].ivalue);
  _digital[p].falling = (_digital[p].memory > _digital[p].ivalue);
  _digital[p].memory = _digital[p].ivalue;
  _digital[p].ivalue = value;
}

void analogWrite(unsigned int p, double value)
{
  if (p > 31)
  {
    printf("Pin %d is out of Range.", p);
    return;
  }

  // En panne
  if (!(_digital[p].mode & 0x01))
  {
    return;
  }

  if (!(_digital[p].mode & IO_OUTPUT) || !(_digital[p].mode & ANALOG))
  {
    printf("Pin %d is not a analog input.", p);
    return;
  }

  _digital[p].dvalue = value;
}