/****************************************************************************/
/* rhino.h  (c++)                                                           */
/*------------------------------------------------------------------------- */
/* Licencia GPL                                                             */
/* Archivo de cabecera de la Clase Rhino                                    */
/* Clase para la gestion del estado del controlador del Servo Robot XR4     */
/*                             RHINO                                        */
/****************************************************************************/
/* Marco Alvarez Reyna                                                      */
/* CIII UTN-FRC Argentina                                                   */
/* Mayo 2007 / Abril 2008                                                   */
/* mail: marcoalrey@gmail.com                                               */
/****************************************************************************/

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

#include "errdef.h"
#include "cmddef.h"
#include "statusdef.h"

#ifndef RHINO_H
#define RHINO_H

#define MAX_LOG_LEVEL 3 // Maximo nivel de logueo

#define MAX_RB_ERROR_CODES 128 // Max Rhino Controller Error Codes
#define MAX_RC_ERROR_CODES 32  // Max Rhino Class Error Codes

#define MSG_LENGTH 256 // Max Messages Length

/*
Por implementar:
-Cargar los mensajes de error y de estado desde un archivo.
 (sacarlos del codigo fuente)
-Renombrar las variables globales bajo un mismo criterio.
-Renombrar las variables locales bajo un mismo criterio.
-Homogeneizar un idioma para los nombres de funciones
 (o ingles o castellano)
-Implementar la funcion CALLBACK.
-Terminar de codificar el proceso de los comandos restantes.
-Separar en capas lasdistintas tareas:
             *Eliminar de la clase toda impresion en pantalla.
             *Eliminar de la clase toda escritura en HD.

Marco AR, 18/04/2008
*/

// CLASE RHINO: Gestion de estado del controlador del Servo Robot XR4 - RHINO
class Rhino{
 private:
    unsigned int uiLogLevel; // Nivel de logueo
    unsigned int uiErrorCode; // Codigo de error
    unsigned int uiStatusCode; // Codigo de estado

    // Contenedor de los ultimos datos enviados y recibidos
    struct {
	unsigned int uiLastCommandtoRhino; // Enum. del ultimo comando enviado
	char         LastCommandtoRhino[MSG_LENGTH]; // Cadena enviada
	char         LastMessageFromRhino[MSG_LENGTH]; // Cadena recibida
    }LastCmdAndMsg;

    FILE *pFile; // Puntero al archivo para el logueo de datos

    char RhinoBotErrorMsg[MAX_RB_ERROR_CODES][MSG_LENGTH]; // Msgs de error 
    char RhinoClassErrorMsg[MAX_RC_ERROR_CODES][MSG_LENGTH]; // Msgs de error

    char RhinoBotStatusMsg[MAX_RB_STATUS_CODES][MSG_LENGTH]; // Msgs de estado
    char RhinoClassStatusMsg[MAX_RC_STATUS_CODES][MSG_LENGTH]; // Msgs de estado

    char RhinoMessages[MSG_LENGTH]; // Contenedores auxiliares
    char cErrorMessage[MSG_LENGTH]; // Contenedores auxiliares
    char cStatusMessage[MSG_LENGTH]; // Contenedores auxiliares

    // Tipo de logueo seleccionado
    enum {
	LMODisplay, //Visualiza el mensage en el display
	LMOFile,    //Almacena el mensage en un archivo 
	LMOCBk      //Pasa el mensaje de error por el CallBack
    }logType;

    // Para el transpaso de mensajes a la aplicacion principal
    struct {
	bool bNewMsg; // Indicador de nuevo mensaje
	char sCBkMessage[MSG_LENGTH]; // Mensaje
    }CallBack;


    int ProcessErrorMsg(unsigned int); // Procesa codigos de error
    int ProcessStatusMsg(unsigned int); // Procesa codigos de estado

 public:
    Rhino(); // Constructor
    ~Rhino(); // Destructor

    int InitMessageVectors(char [MAX_RB_ERROR_CODES][MSG_LENGTH], char [MAX_RC_ERROR_CODES][MSG_LENGTH], char [MAX_RB_STATUS_CODES][MSG_LENGTH], char [MAX_RC_STATUS_CODES][MSG_LENGTH]); // Inicializa los mensajes del sistema
    
    int set_LogLevel(unsigned int); // Setea el niven de logueo
    int get_LogLevel(unsigned int *); // Devuelve el nivel de logueo

    int get_ErrorMsg(char *); // Devuelve el ultimo mensaje de error
    int get_ErrorMsg(unsigned int, char *); // Devuelve el mensaje de error para el argumento pasado
    int get_ErrorCode(unsigned int *); // Devuelve el ultimo codigo de error

    int get_StatusMsg(char *); // Devuelve el ultimo mensaje de estado
    int get_StatusMsg(unsigned int, char *); // Devuelve el mensaje de estado para el argumento pasado
    int get_StatusCode(unsigned int *); // Devuelve el ultimo codigo de estado

    int ProcessCommandToRhino(char *); // Procesa los comando enviado al controlador
    int ProcessMessageFromRhino(char *); // Procesa los mensajes devueltos por el controlador
    int ProcessCommandToRhino(char *, unsigned int *); // Procesa los comando enviado al controlador y devuelve su codigo
    int ProcessMessageFromRhino(unsigned int, char *, unsigned int *, char *); // Procesa los mensajes devueltos por el controlador y devuelve el mensaje correspondiente

    int CBkMsg(void); // Indica que hay un mensaje nuevo para la alicacion principal
    int get_CBkMsg(char *); // Devuelve el mensaje correspondiente

    int LogMessage(int, char *); // Loguea mensajes

    int DisplayAllErrorMessages(void); // Visualiza todos los mensajes de error
};
      
#endif //RHINO_H