"use strict";

var ws_ws = null;
var ws_timeOutReconnectionWebSocket = null;
var ws_tentativeDeReconnectionSeconde = 10;
var ws_debutConnexionWebSocket = null;
var ws_contextPath = null;
var ws_OPEN = null;
var ws_CONNECTING = null;
var ws_numeroTest = 0;

function ws_isConnexionActive() {
	// Si le WebSocket est actif alors on ne retente pas une connexion
	return (ws_ws!=null && ws_OPEN!=null && ws_ws.readyState == ws_OPEN);
}

function ws_connect() {
	// Si le WebSocket est actif alors on ne retente pas une connexion
	if (ws_isConnexionActive()) return;
		
	// On déconnecte tout websocket précédemment actif
	if (ws_ws != null) {
		ws_disconnect();
	}
	
	console.log("Tentative de connexion "+((ws_numeroTest % 2) == 0 ? "WSS" : "WS")+" au WebSocket ...");
	
	if (ws_contextPath == null) contextPath = "";
	
	//var isContientPort = window.location.host.indexOf(":") != -1;
	//var target="ws://"+window.location.host+( isContientPort ? "" : ":443" )+ws_contextPath+"/websocket/websocket?_="+(new Date()).getTime();
	//var target="wss://"+window.location.host+ws_contextPath+"/websocket/websocket?_="+(new Date()).getTime();
	
	// Une fois sur 2, je tente une connexion sur le port standard (port 80), sinon sur le port sécurisé (port 443)
	var target="ws" + ((ws_numeroTest % 2) == 0 ? "s" : "") +"://"+window.location.hostname+ws_contextPath+"/websocket/websocket?_="+(new Date()).getTime();
	ws_numeroTest++;
	
	//console.log(target);
	
    if ('WebSocket' in window) {
        ws_OPEN = WebSocket.OPEN;
        ws_CONNECTING = WebSocket.CONNECTING;
        ws_ws = new WebSocket(target);
    } else if ('MozWebSocket' in window) {
        ws_OPEN = MozWebSocket.OPEN;
        ws_CONNECTING = MozWebSocket.CONNECTING;
        ws_ws = new MozWebSocket(target);
    } else {
    	// Le navigateur ne supporte pas les WebSockets
        //alert('WebSocket is not supported by this browser.'); 
        return;
    }
    
    ws_ws.onopen = function () {
        ws_log('WebSocket Info: WebSocket connection opened.');
        ws_cacherPerteWebSocket();
    };
    
    ws_ws.onmessage = function (event) {
    	//ws_log('WebSocket Received: ' + event.data);
    	var json = jQuery.parseJSON(event.data);
    	ws_traiterMessage(json);
    };
    
    ws_ws.onclose = function (event) {
    	ws_log('WebSocket Info: WebSocket connection closed.');
    	
    	event.preventDefault();
    	
    	// Affichage d'un logo indiquant la coupure de connexion
    	ws_afficherPerteWebSocket();
    	
    	// Est-ce que la raison de la coupure vient du faite que l'on ne soit pas identifé ?
    	if (event.reason == "401") {
    		// Oui
    		
    		ws_stopCron(); // On arrête le cron
    		ws_disconnect(); // On arrête le websocket en cours si besoin
    		
            // On demande le même lien afin que l'utilisateur, une fois identifiée, soit redirigée vers la dernière page utilisée.
            window.location.replace(window.location.href);
    	}
    	
    };
    
    ws_ws.onerror = function (event) {
    	ws_ws = null;
    	ws_log("WebSocket Error: " + event.data);
    	
    	// Affichage d'un logo indiquant la coupure de connexion
    	ws_afficherPerteWebSocket();
    };
    
}

function ws_afficherPerteWebSocket() {
	//$("#websocket_connexion").addClass("affichage");
}

function ws_cacherPerteWebSocket() {
	//$("#websocket_connexion").removeClass("affichage");
}

function ws_disconnect() {
    if (ws_ws != null && (ws_ws.readyState==ws_CONNECTING || ws_ws.readyState==ws_OPEN)) {
        ws_ws.close();
        ws_ws = null;
    }
}

function ws_traiterMessage(message) {
	try {
	    
	    console.log(message);
	    
		switch (message['type']) {
				
		    case 'COMMANDE_NOUVELLE' : // indique qu'une commande vient d'être créé
		        CommandeEnCours_ajouterCommandeFromJSON(message);
		        break;
		        
		    case 'COMMANDE_MISE_A_JOUR' : // indique que l'état d'une commande est arrivée
            case 'COMMANDE_RESULTAT_ARRIVE' : // indique que le résultat d'une commande est arrivée
				CommandeEnCours_majCommandeFromJSON(message);
				break;

			case 'LOG_TRAME' :
				LogTrame_ajouterLogTrame(message);
				break;
			
			case 'FIN_CHARGEMENT_DERNIERS_LOG_TRAME' :
			    LogTrame_finChargement(message);
			    break;
				
			case 'IDENTIFICATION_MODULE' :
				IdentificationModule_identificationModule(message);
				break;
				
			case 'EVENEMENT_APPARITION_ANOMALIE' :
			case 'EVENEMENT_DISPARITION_ANOMALIE' :
				PopupModuleEnAnomaliesEtAlertes_majAnomalies(message);
				break;
				
			case 'EVENEMENT_APPARITION_ALERTE' : 
			case 'EVENEMENT_DISPARITION_ALERTE' : 
				PopupModuleEnAnomaliesEtAlertes_majAlertes(message);
				break;
		
			case 'MISE_A_JOUR_FIRMWARE' :
			case 'MISE_A_JOUR_COMPACT_FAT' :
				AfficherMiseAJour_maj(message);
				break;
		}
	} catch (exception) {
		console.log(exception);
	}
}

function ws_log(message) {
	console.log(message);
}

// Envoi un message alive
function ws_envoyerAlive() {
	if (ws_ws != null) {
		ws_ws.send("{}");
	}
}

//Envoi un message via le websocket
function ws_envoyer(json) {
	if (ws_ws != null) {
		ws_ws.send(json);
	} else {
	    ws_push(json);
	}
}

// On appel cette fonction à chaque affichage d'une page
// Si etat est vrai alors on démarre une WebSocket
function ws_setEtatSessionMetier(etat) {
	if (etat == true) 
		ws_startCron();
	else {
		ws_stopCron(); // Arret du cron
		ws_disconnect(); // Arret du Websocket
	}
}

function ws_push(message) {
    $.ajax({
        url: ws_contextPath+'/jsonWebSocketPush',
        type: 'POST',
        data: {
            'json':message
        },
        error: function (request, status, error) {
            console.log("Erreur lors de la récupération de jsonWebSocketPush : "+error);
        },
        timeout: 10000, // 10 secondes,
        async: true
    });
}

// On recupere les informations en faisant un Get ( normalement envoyees via le WebSocket )
function ws_pull() {
	$.ajax({
		url: ws_contextPath+'/jsonWebSocketPull',
		success: function (donnees, status, request) {
			// Pour chaque message, on effectue le traitement
			var nb = donnees.length;
			var i=0; 
			for (i=0; i<nb; i++) {
				// traitement du message
				ws_traiterMessage(donnees[i]);
			}
		},
		error: function (request, status, error) {
			console.log("Erreur lors de la récupération de jsonPull : "+error);
		},
		timeout: 10000, // 10 secondes,
		async: true
	});
}

// Function qui va envoyer un packet ALIVE ou effectuer un GET (PULL) ou lancer un WebSocket
function ws_decision() {
	// Initialisation de la date de référence				
	if (ws_debutConnexionWebSocket == null) {
		ws_debutConnexionWebSocket = (new Date()).getTime();
	}
	
	if (ws_isConnexionActive()) {
		ws_envoyerAlive(); // On envoi un paquet alive
	} else {
		// Si cela plus fait plus de 3 fois que le délai de tentative de reconnexion est passé, 
		//   sans connexion de websocket, alors on essaie en mode Pull 
		if ( ws_debutConnexionWebSocket + (4 * ws_tentativeDeReconnectionSeconde * 1000) < (new Date()).getTime() ) {
			ws_pull(); // On récupère les informations en passant par un GET
		} else {
			ws_connect(); // On lance en directe la connexion WebSocket
		}
	}
}

// Toutes les 30 secondes, on va verifier que le WebSocket est actif.
// Si c'est le cas, on envoi un message alive pour garder la ligne active
// Sinon on redémarre une connexion
function ws_startCron() {

	// Si le contextPath n'est pas renseigné, alors on ne fait rien
	if (ws_contextPath == null) return;
	
	// On prépare un crontab de reconnexion
	if (ws_timeOutReconnectionWebSocket == null) {
		ws_decision(); // On essai de contacter le serveur et de récupérer les événements 
		
		ws_timeOutReconnectionWebSocket = setInterval(function() { 
			ws_decision(); // On essai de contacter le serveur et de récupérer les événements
		}, ws_tentativeDeReconnectionSeconde * 1000); // On paramètre le crontab
	}
}

function ws_stopCron() {
	if (ws_timeOutReconnectionWebSocket!=null) {
		clearInterval(ws_timeOutReconnectionWebSocket);
	}
	ws_timeOutReconnectionWebSocket = null;
}

function ws_setContextPath(contextPath) {
	ws_contextPath = contextPath;
}

$(document).ready(function() {
	$(window).on('unload', function() {
		ws_disconnect(); // Lorsque la fenêtre se fermera ou se rechargera, on fermera automatiquement le websocket
		ws_stopCron(); // ainsi que le cron de reconnection
	});
});