#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <errno.h>
#include <stdlib.h>
#include <netinet/udp.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <string.h>
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdint.h>

#define MAX_TCP_CONNEXION 10
#define BUFFER_SIZE 1024

//Fonction permettant d'envoyer en broadcast un message 
void sendUDPBroadcast(unsigned char *message, int taille_message, int port) {
    int broadcast_enable = 1;
    //Option broadcast ON
    int s = socket(AF_INET, SOCK_DGRAM, 0);
    //Création de la socket : s = file descriptor de la socket, AF_INET (socket internet), SOCK_DGRAM (datagramme, UDP, sans connexion)
    if(s < 0){
        //Test de la valeur de retour de la socket
        perror("sendUDPBroadcast.socket");
        exit(-1); 
    }
    if (setsockopt(s, SOL_SOCKET, SO_BROADCAST, &broadcast_enable, sizeof(broadcast_enable)) < 0) {
        //Mise option broadcast à la socket
        perror("sendUDPBroadcast.setsockopt");
        exit(-1);
    }
    
    struct sockaddr_in broadcast_address;
    memset(&broadcast_address, 0, sizeof(broadcast_address));
    broadcast_address.sin_family = AF_INET;
    broadcast_address.sin_port = htons(port);
    broadcast_address.sin_addr.s_addr = INADDR_BROADCAST; //255.255.255.255
    
    //Envoie du message grâce à la socket
    if(sendto(s, message, taille_message, 0, (struct sockaddr *) &broadcast_address,
            sizeof(broadcast_address)) < 0 ) {
        perror("sendUDPBroadcast.sendto");
        exit(-1);
    }
}


void sendUDPUnicast(char *address, unsigned char *message, int taille_message, int port) {
    int s = socket(AF_INET, SOCK_DGRAM, 0);
    //Création de la socket : s = file descriptor de la socket, AF_INET (socket internet), SOCK_DGRAM (datagramme, UDP, sans connexion)
    if(s < 0){
        //Test de la valeur de retour de la socket
        perror("sendUDPUnicast.socket");
        exit(-1); 
    }
    struct sockaddr_in unicast_address;
    //Creation structure adresse de destination
    memset(&unicast_address, 0, sizeof(unicast_address));
    //Mise à zéro de la structure d'adresse
    unicast_address.sin_family = AF_INET;
    unicast_address.sin_port = htons(port);
    //Mise du port en ordre du réseau (big endian)
    unicast_address.sin_addr.s_addr = inet_addr(address);
    if(sendto(s, message, taille_message, 0, (struct sockaddr *) &unicast_address, sizeof(unicast_address)) < 0 ) {
        perror("sendUDPUnicast.sendto");
        exit(-1);
    }
}

// Retourne l'adresse ip d'une connexion active
static int socketVersNomUDP(struct sockaddr *padresse, char *nom){
    void *ip;
    int taille_nom;
    if(padresse->sa_family == AF_INET){
        struct sockaddr_in *ipv4 = (struct sockaddr_in *) padresse;
        ip = (void *) &ipv4->sin_addr;
        taille_nom = INET_ADDRSTRLEN;
    }
    if(padresse->sa_family == AF_INET6){
        struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *) padresse;
        ip = (void *)&ipv6->sin6_addr;
        taille_nom = INET6_ADDRSTRLEN;
    }
    char nom_deco[20];
    inet_ntop(padresse->sa_family, ip, nom_deco, taille_nom);
    sprintf(nom, "%s", nom_deco + 7);
    return 0;
}
static int socketVersNomTCP(int s, char *nom){
    struct sockaddr_storage adresse;
    struct sockaddr *padresse = (struct sockaddr *) &adresse;
    socklen_t taille = sizeof adresse;
    int statut;

    /* Recupere l'adresse de la socket distante */
    statut = getpeername(s, padresse, &taille);
    if(statut<0){
        perror("socketVersNom.getpeername");
        return -1;
    }

    /* Recupere le nom de la machine */
    return socketVersNomUDP(padresse, nom);
}

// Fonction permettant de créer le serveur TCP
int initialisationServeurTCP(char *service){
    struct addrinfo precisions, *resultat, *origine;
    int statut;
    int s;

    /* Construction de la structure adresse */
    memset(&precisions, 0, sizeof precisions);
    precisions.ai_family = AF_UNSPEC;
    precisions.ai_socktype = SOCK_STREAM;
    precisions.ai_flags = AI_PASSIVE;
    statut = getaddrinfo(NULL, service, &precisions, &origine);
    if(statut < 0){ 
        perror("initialisationSocketUDP.getaddrinfo");
        exit(EXIT_FAILURE); 
    }
    struct addrinfo *p;
    for(p = origine, resultat = origine; p != NULL; p = p->ai_next) {
        if(p->ai_family == AF_INET6){ 
            resultat = p; 
            break;
        }
    }

    /* Creation d'une socket */
    s = socket(resultat->ai_family, resultat->ai_socktype, resultat->ai_protocol);
    if(s < 0){
        perror("initialisationSocketUDP.socket");
        exit(EXIT_FAILURE);
    }

    /* Options utiles */
    int vrai = 1;
    if(setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &vrai, sizeof(vrai))<0) {
        perror("initialisationServeurUDPgenerique.setsockopt (REUSEADDR)");
        exit(-1);
    }

    /* Specification de l'adresse de la socket */
    statut = bind(s, resultat->ai_addr, resultat->ai_addrlen);
    if(statut<0) {
        perror("initialisationServeurUDP.bind");
        exit(-1);
    }

    /* Liberation de la structure d'informations */
    freeaddrinfo(origine);

    /* Taille de la queue d'attente */
    statut = listen(s, MAX_TCP_CONNEXION);
    if(statut < 0)
        return -1;
    return s;
}

// Accepte toutes les connexions au serveur TCP et execute la fonction en argument
int boucleServeurTCP(int socket, void (*traitement)(int, char *)){
    while(1){
	    // accept connection
        struct sockaddr ip_src;
        socklen_t ip_len = sizeof(struct sockaddr);
        int socket_dialogue = accept(socket, &ip_src, &ip_len);
        if(socket_dialogue < 0){
            perror("boucleServeur.accept");
            return -1;
        }

	    // get ip addr
        char char_ip[20];
        int status = socketVersNomTCP(socket_dialogue, char_ip);
        if(status < 0)
            perror("socketVersNom");

	    // callback function
        traitement(socket_dialogue, char_ip);
    }
    return 0;
}

// Creation d'un serveur UDP
int initialisationServeurUDP(char *service){
    struct addrinfo precisions, *resultat, *origine;
    int statut;
    int s;

    /* Construction de la structure adresse */
    memset(&precisions, 0, sizeof precisions);
    precisions.ai_family = AF_UNSPEC;
    precisions.ai_socktype = SOCK_DGRAM;
    precisions.ai_flags = AI_PASSIVE;
    statut = getaddrinfo(NULL, service, &precisions, &origine);
    if(statut < 0){ perror("initialisationSocketUDP.getaddrinfo"); exit(EXIT_FAILURE); }

    struct addrinfo *p;
    for(p=origine, resultat=origine; p!=NULL; p=p->ai_next)
    if(p->ai_family == AF_INET6){ resultat=p; break; }

    /* Creation d'une socket */
    s = socket(resultat->ai_family, resultat->ai_socktype, resultat->ai_protocol);
    if(s<0){ perror("initialisationSocketUDP.socket"); exit(EXIT_FAILURE); }

    /* Options utiles */
    int vrai = 1;
    if(setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &vrai, sizeof(vrai)) < 0){
        perror("initialisationServeurUDPgenerique.setsockopt (REUSEADDR)");
        exit(-1);
    }

    /* Specification de l'adresse de la socket */
    statut = bind(s, resultat->ai_addr, resultat->ai_addrlen);
    if(statut < 0) { perror("initialisationServeurUDP.bind"); exit(-1); }

    /* Liberation de la structure d'informations */
    freeaddrinfo(origine);

    return s;
}

// Reception des messages UDP et execute la fonction passee en argument
int boucleServeurUDP(int s, void (*traitement)(unsigned char *, int, char *)){
    while(1){
        struct sockaddr_storage adresse;
        struct sockaddr *padresse = (struct sockaddr *) &adresse;
        socklen_t taille = sizeof(adresse);
        unsigned char message[BUFFER_SIZE];

        int nboctets = recvfrom(s, message, BUFFER_SIZE, 0, (struct sockaddr *) padresse, &taille);
        if(nboctets < 0) return -1;

        /* Recupere le nom de la machine */
        char char_ip[20];
        int status = socketVersNomUDP(padresse, char_ip);
        if(status < 0)
            perror("socketVersNom");

        traitement(message, nboctets, char_ip);
    }
    return 0;
}

// Initialise un client TCP
int openTCPClient(char *hote, int port) {
    int s;
    struct sockaddr_in adresse;
    socklen_t taille = sizeof adresse;
    
    // creation socket
    s = socket(PF_INET, SOCK_STREAM, 0);
    if(s<0){ perror("connexionServeur.socket"); exit(-1); }
    
    // connexion
    memset(&adresse, 0, sizeof(adresse));
    adresse.sin_family=AF_INET;
    adresse.sin_port = htons(port);
    adresse.sin_addr.s_addr = inet_addr(hote);
    if(connect(s,(struct sockaddr *)&adresse, taille)<0) return -1;
    return s;
}

// Envoie un message TCP sur une connexion active
void sendTCP(int socket, char *message, int length_message){
    if(length_message <= 0)
        return;
    write(socket, message, length_message);
}

// Recois un message TCP sur une connexion active
int receiveTCP(int socket, char *message, int max_length){
    return read(socket, message, max_length);
}