/*
* This file is part of the TraKERS\Middleware package.
*
* (c) IRI <http://www.iri.centrepompidou.fr/>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/

/*
 * Projet : TraKERS
 * Module : MIDDLEWARE
 * Sous-Module : Communication
 * Classe : WSClient
 * 
 * Auteur : alexandre.bastien@iri.centrepompidou.fr
 * 
 * Fonctionnalités : Reçoit des notifications du Front IDILL.
 * Interprète les positions des curseurs dans le temps à partir du top du front.
 * 
 * STATUS : EN DEVELOPPEMENT.
 * 
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Fleck;
using System.Threading;
using System.Timers;
using System.Windows.Media.Media3D;

namespace Communication
{
    public class WSClient
    {
        //Server WebSocket.
        WebSocketServer server;
        List<IWebSocketConnection> allSockets;

        //Permet de savoir si un curseur pour la main gauche/droite a été créé.
        private bool leftHandCursorCreated;
        private bool rightHandCursorCreated;
        private bool gesturesMessageCreated, modeMessageCreated;
        private bool gestureLocked, modLocked;
        //Intervalle minimum entre les gestures.
        private int timerElapsing;
        //Timers.
        private System.Timers.Timer _gesturesTimer;
        private System.Timers.Timer _userPositionTimer;
        //Dernier code envoyé.
        private String lastCode;
        //Messages envoyés en WS.
        private String rightHandMessage, leftHandMessage, gesturesMessage, modeMessage;
        //Messages précédents
        private String prevRightHandMessage, prevLeftHandMessage, prevGestureMessage, prevModeMessage;

        /*
        * Constructeur : On initialise le serveur avec une adresse et un port, au début les curseurs
        * ne sont pas créés et on indique au ThreadPool une fonction de callback de manière à vérifier
        * s'il reçoit des notifications.
        */
        public WSClient(String host, int port, int _timerElapsing)
        {
            FleckLog.Level = LogLevel.Debug;
            allSockets = new List<IWebSocketConnection>();
            server = new WebSocketServer(port, "ws://" + host + ":" + port);

            //Au départ, aucune main n'est dans le champ de recherche et aucune gesture n'est détectée.
            leftHandCursorCreated = false;
            rightHandCursorCreated = false;
            gesturesMessageCreated = false;
            modeMessageCreated = false;
            gestureLocked = false;
            modLocked = false;
            lastCode = "";

            timerElapsing = 500;// _timerElapsing;

            rightHandMessage = leftHandMessage = gesturesMessage = modeMessage = "";

            //On démarre le serveur WebSocket.
            server.Start(socket =>
            {
                socket.OnOpen = () =>
                {
                    Console.WriteLine("Open!");
                    allSockets.Add(socket);
                };
                socket.OnClose = () =>
                {
                    Console.WriteLine("Close!");
                    allSockets.Remove(socket);
                };
                /*socket.OnMessage = message =>
                {
                    Console.WriteLine(message);
                    allSockets.ToList().ForEach(s => s.Send("Echo: " + message));
                };*/
            });

            //On initialise le threadPool (appelé toutes les N ms).
            ThreadPool.QueueUserWorkItem(ThreadPoolCallback);

            //On instancie le timer à N ms.
            _gesturesTimer = new System.Timers.Timer(timerElapsing);
            _userPositionTimer = new System.Timers.Timer(timerElapsing/5);
            //Dès que le timer est expiré, on appelle _timer_Elapsed.
            _gesturesTimer.Elapsed += new ElapsedEventHandler(_gesturesTimer_Elapsed);
            _userPositionTimer.Elapsed += new ElapsedEventHandler(_userPositionTimer_Elapsed);

            /*var input = Console.ReadLine();
            while (input != "exit")
            {
                foreach (var socket in allSockets.ToList())
                {
                    socket.Send(input);
                }
                input = Console.ReadLine();
            }*/
        }

        /*
         * Méthode appelée à l'expiration du timer pour les gestures et modes.
         */
        public void _gesturesTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            //On débloque la détection de gesture.
            gestureLocked = false;
            //On débloque la notification de nouveau mode.
            //modLocked = false;
            lastCode = "";
            //On arrête le timer.
            _gesturesTimer.Stop();
        }

        /*
         * Méthode appelée à l'expiration du timer pour les positions d'utilisateur.
         */
        public void _userPositionTimer_Elapsed(object sender, ElapsedEventArgs e)
        {
            //On débloque la détection de gesture.
            //gestureLocked = false;
            //On débloque la notification de nouveau mode.
            modLocked = false;
            lastCode = "";
            //On arrête le timer.
            _userPositionTimer.Stop();
        }

        /*
        * Méthode appelée lors d'une notification de type : main gauche entrée dans le champ.
        */
        public void LeftHandTracked(Point3D pt)
        {
            leftHandMessage = "0-" + pt.X + ";" + pt.Y + ";" + pt.Z;
            //Si le curseur de la main gauche n'est pas créé, alors on le crée.
            if (!leftHandCursorCreated)
                leftHandCursorCreated = true;
        }

        /*
        * Méthode appelée lors d'une notification de type : main droite entrée dans le champ.
        */
        public void RightHandTracked(Point3D pt)
        {
            rightHandMessage = "1-" + pt.X + ";" + pt.Y + ";" + pt.Z;
            //Si le curseur de la main droite n'est pas créé, alors on le crée.
            if (!rightHandCursorCreated)
                rightHandCursorCreated = true;
        }

        /*
        * Méthode appelée lors d'une notification de type : main gauche sortie du champ.
        */
        public void LeftHandQuit()
        {
            leftHandMessage = "";
            //Si le curseur de la main gauche existe, alors on le supprime.
            if (leftHandCursorCreated)
                leftHandCursorCreated = false;
        }

        /*
        * Méthode appelée lors d'une notification de type : main droite sortie du champ.
        */
        public void RightHandQuit()
        {
            rightHandMessage = "";
            //Si le curseur de la main droite existe, alors on le supprime.
            if (rightHandCursorCreated)
                rightHandCursorCreated = false;
        }

        /*
        * Méthode appelée lorsqu'une gesture a été détectée et que l'événement approprié a été lancé.
        */
        public void GesturePerformed(String code)
        {
            //Si le code vient d'être envoyé, on passe.
            /*if (lastCode.Equals(code))
                return;
            lastCode = code;*/
            //Si une gesture a été effectuée, on bloque un certain temps.
            if (!gestureLocked)
            {
                gestureLocked = true;

                //On crée un message contenant le code à envoyer.
                //if (!gesturesMessageCreated)
                //{
                    gesturesMessageCreated = true;
                    gesturesMessage = "2-" + code;

                    //Console.WriteLine(gesturesMessage);
                    
                    foreach (var socket in allSockets.ToList())
                    {
                        socket.Send(gesturesMessage);
                    }

                    //On démarre le timer.
                    _gesturesTimer.Start();

                    //Console.WriteLine(gestureMessage);
                //}
            }
        }

        /*
        * Méthode appelée lorsqu'on doit entrer dans un autre mode.
        */
        public void ModeNotification(String code)
        {
            //Si le code vient d'être envoyé, on passe.
            /*if (lastCode.Equals(code))
                return;
            lastCode = code;*/
            //Si on a été notifié.
            if (!modLocked)
            {
                modLocked = true;

                //On crée un message contenant le code à envoyer.
                //if (!modeMessageCreated)
                //{
                    modeMessageCreated = true;
                    modeMessage = "2-" + code;
                    //On démarre le timer.

                    foreach (var socket in allSockets.ToList())
                    {
                        socket.Send(modeMessage);
                    }
                    _userPositionTimer.Start();

                    //Console.WriteLine(modeMessage);
                //}
            }
        }

        /*
        * Méthode de callback vérifiant toutes les 25 ms les nouvelles notifications.
        * Il est à noter que si le temps de rafraîchissement des trop rapide, les messages n'ont pas
        * le temps d'être envoyés.
        */
        private void ThreadPoolCallback(Object threadContext)
        {
            while (true)
            {
                /*//S'il existe un message de gesture.
                if (gesturesMessage != null && !gesturesMessage.Equals(""))// && !gesturesMessage.Equals(prevGestureMessage))
                {
                    //On l'envoie au client (au host et au port spécifiés dans le constructeur).
                    foreach (var socket in allSockets.ToList())
                    {
                        socket.Send(gesturesMessage);
                        //prevGestureMessage = gesturesMessage;
                    }
                }

                //S'il existe un message de mode.
                if (modeMessage != null && !modeMessage.Equals(""))// && !modeMessage.Equals(prevModeMessage))
                {
                    //On l'envoie au client (au host et au port spécifiés dans le constructeur).
                    foreach (var socket in allSockets.ToList())
                    {
                        socket.Send(modeMessage);
                        //prevModeMessage = modeMessage;
                    }
                }*/

                //Si la main gauche est détectée.
                if (leftHandMessage != null && !leftHandMessage.Equals("") && !leftHandMessage.Equals(prevLeftHandMessage))
                {
                    //On l'envoie au client (au host et au port spécifiés dans le constructeur).
                    foreach (var socket in allSockets.ToList())
                    {
                        socket.Send(leftHandMessage);
                        prevLeftHandMessage = leftHandMessage;
                    }
                }
                //Si la main droite est détectée.
                if (rightHandMessage != null && !rightHandMessage.Equals("") && !rightHandMessage.Equals(prevRightHandMessage))
                {
                    //On l'envoie au client (au host et au port spécifiés dans le constructeur).
                    foreach (var socket in allSockets.ToList())
                    {
                        socket.Send(rightHandMessage);
                        prevRightHandMessage = rightHandMessage;
                    }
                }
                
                //On attend 25 ms.
                Thread.Sleep(25);

                //Si une gesture a été effectuée et que le délai d'attente est expiré.
                if (gesturesMessageCreated && !gestureLocked)
                {
                    //On débloque la détection de gesture et on supprime l'objet envoyant les messages OSC de gesture.
                    gesturesMessageCreated = false;
                    gesturesMessage = "";
                }

                //Si un mode a été effectuée et que le délai d'attente est expiré.
                if (modeMessageCreated && !modLocked)
                {
                    //On débloque la détection de gesture et on supprime l'objet envoyant les messages OSC de gesture.
                    modeMessageCreated = false;
                    modeMessage = "";
                }
            }
        }

        /*
         * Getters et Setters
         */
        public void setTimerElapsing(int _timerElapsing)
        {
            timerElapsing = _timerElapsing;
        }

        public int getTimerElapsing()
        {
            return timerElapsing;
        }
    }
}
