//Definicion del provider

var KLAY = {};
/*
Ext.REMOTING_API =
{
  actions:
  {
    KLAY:
    [
      {
        name: 'request',
        len: 3
      }
    ]
  },
  enableBuffer: 0,
  maxRetries: 0,
  type:'remoting',
  url: 'index.php'
};
*/
///////Ext.Direct.Manager.addProvider(Ext.REMOTING_API);

//Ext.require('Ext.direct.*', function(){Ext.direct.Manager.addProvider(Ext.REMOTING_API);});

//Configuracion general de ExtJs
Ext.QuickTips.init();
//Ext.form.Field.prototype.msgTarget = 'side';
Ext.form.field.Text.prototype.blankText = 'El campo es obligatorio';

//Ext.supports = {};
//Ext.feature.detect();
//Ext.supports.Touch = false;

Ext.supports.Touch = false;
Ext.supports.TouchEvents = false;
Ext.supports.touchScroll = 0;

//Carga de KLAY.API
KLAY.API = new function()
{
  /**
   * Ejecuta el metodo cargando el API involucrado bajo demanda
   *
   * @param string TAB tab en el que se quiere ejecutar el metodo
   * @param string INSTANCIA instancia a la que pertenece el metodo
   * @param string MODULO modulo al que pertenece el metodo
   * @param string METODO metodo que se quiere ejecutar
   * @param array PARAMETROS arreglo con los parametros que seran transmitidos al metodo
   * @param boolean DO_NOT_LOAD bandera que si se manda en true no se carga el API
   * @return mixed regresa lo que regresa el metodo evaluado, solo se regresa valor si el API ya estaba cargado
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.eval = function(TAB, INSTANCIA, MODULO, METODO, PARAMETROS, DO_NOT_LOAD)
  {
    var e_TIPO, e_METODO, e_RETURN, ERROR, RETURN;

    //Se verifica si existe el API solicitado y si no existe se carga
    try
    {
      eval("e_TIPO = typeof(API['" + TAB + "']." + INSTANCIA + '.' + MODULO + ');');

      //Si no se marca error y no existe la varialbe se arroja una excepcion para ejecutar el codigo de catch
      if(e_TIPO == 'undefined')
        throw '';

      //Si la variable existe pero no es un objeto se detiene la ejecucion
      if(e_TIPO != 'object')
      {
        //KLAY.MSG.show_msgs('ERROR', 'alert');
        return;
      }
    }
    catch(ERROR)
    {
      //Si el cargar APIs esta deshabilitado se regresa falso
      if(DO_NOT_LOAD)
      {
        //KLAY.MSG.show_msgs('ERROR', 'alert');
        return;
      }

      //Se manda cargar el api y se detiene la ejecucion
      KLAY.API.request(TAB, INSTANCIA, MODULO, METODO, PARAMETROS)
      return;
    }

    //Se verifica si existe el metodo solicitado y si no existe se regresa falso
    try
    {
      eval("e_METODO = API['" + TAB + "']." + INSTANCIA + '.' + MODULO + '.' + METODO);
      if(e_METODO == undefined)
      {
        //KLAY.MSG.show_msgs('ERROR', 'alert');
        return;
      }
    }
    catch(ERROR)
    {
      //KLAY.MSG.show_msgs('ERROR', 'alert');
      return;
    }

    //Se evalua el metodo y si el metodo falla se regresa falso y si no falla se regresa lo que regresa el metodo
    try
    {
      var PARAMETROS_STRING = this.array_to_params(PARAMETROS);

      eval("RETURN = API['" + TAB + "']." + INSTANCIA + '.' + MODULO + '.' + METODO + '(' + PARAMETROS_STRING + ')');
      return RETURN;
    }
    catch(ERROR)
    {
      //KLAY.MSG.show_msgs('ERROR', 'alert');
      return;
    }
  }

  /**
   * Ejecuta un metodo de un API
   *
   * @param string RUTA_MODULO ruta modulo del metodo que se quiere ejecutar
   * @param array PARAMETROS arreglo con los parametros que seran transmitidos al metodo
   * @return mixed se devuelve lo que devuelva el metodo ejecutado
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.call = function(RUTA_MODULO, PARAMETROS)
  {
    return this.tab_call('NOTAB', RUTA_MODULO, PARAMETROS);
  }

  /**
   * Ejecuta un metodo de un API dentro de un tab
   *
   * @param string TAB tab en el que se quiere ejecutar el metodo
   * @param string RUTA_MODULO ruta modulo del metodo que se quiere ejecutar
   * @param array PARAMETROS arreglo con los parametros que seran transmitidos al metodo
   * @param string ASIGNAR_INSTANCIA
   * @return mixed se devuelve lo que devuelva el metodo ejecutado, solo se regresa valor si el metodo se ejecuta en un tab existente y no se especifica el parametro INSTANCIA
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.tab_call = function(TAB, RUTA_MODULO, PARAMETROS, ASIGNAR_INSTANCIA)
  {
    Ext.util.Format.thousandSeparator = ',';
    Ext.util.Format.decimalSeparator = '.';
    
    var ELEMENTOS, INSTANCIA, MODULO, METODO;

    //Se obtiene la INSTANCIA
    ELEMENTOS = RUTA_MODULO.split(':', 2);
    INSTANCIA = ELEMENTOS[0];

    //Se obtiene el MODULO y el METODO
    ELEMENTOS = ELEMENTOS[1].split('.');
    METODO = ELEMENTOS.pop();
    MODULO = ELEMENTOS.join('.')

    if(TAB != 'NOTAB')
      TAB = KLAY.API.call('KLAY:C0.GUI.MAIN.PANEL.tabpanel_get_tab', [TAB]);

    if(ASIGNAR_INSTANCIA)
      KLAY.API.call('KLAY:C0.GUI.MAIN.PANEL.set_instancia_tab', [TAB, ASIGNAR_INSTANCIA, callback_tab_call]);
    else
      return callback_tab_call();

    function callback_tab_call()
    {
      return KLAY.API.eval(TAB, INSTANCIA, MODULO, METODO, PARAMETROS);
    }
  }

  /**
   * Carga un API en el tab señalado
   *
   * @param string TAB tab en el que se quiere cargar el API
   * @param string INSTANCIA instancia a la que pertenece API
   * @param string MODULO modulo en donde se encuentra el API
   * @param string METODO metodo que se desea ejecutar despues de haber cargado el API
   * @param array PARAMETROS arreglo con los parametros que seran transmitidos al metodo
   * @return void
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.request = function(TAB, INSTANCIA, MODULO, METODO, PARAMETROS)
  {
    this.tab_call_action
    (
      TAB,
      'KLAY:C1.ACTION.MAIN.LOAD_API',
      {API: INSTANCIA + ':' + MODULO, EMPRESA: 'VERSATIL'},
      function(result, opts)
      {
        if(KLAY.API.check_path(TAB, INSTANCIA, MODULO))
        {
          //Se carga el API en el objeto correspondiente
          try
          {
            eval("API['" + TAB + "']." + INSTANCIA + '.' + MODULO + ' = new ' + result.responseText);
            eval("API['" + TAB + "']." + INSTANCIA + '.' + MODULO + ".TAB = '" + TAB + "'");

            if(TAB != 'NOTAB')
              eval("API['" + TAB + "']." + INSTANCIA + '.' + MODULO + ".PANEL = API['" + TAB + "'].GUI.PANEL");
          }
          catch(ERROR)
          {
            //KLAY.MSG.show_msgs('ERROR', 'alert');
            return;
          }

          //Se ejecuta el comando que quedo pendiente
          if(METODO)
            KLAY.API.eval(TAB, INSTANCIA, MODULO, METODO, PARAMETROS, true);
        }
      }
    );
  }

  /**
   * Manda llamar un action
   *
   * @param string ACTION ruta modulo del action que se desea ejecutar
   * @param array PARAMETROS arreglo con los parametros que seran transmitidos al metodo
   * @param function HANDLER metodo que se ejecutara despues de haber cargado el action
   * @return void
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.call_action = function(ACTION, PARAMETROS, CALLBACK)
  {
    this.tab_call_action('NOTAB', ACTION, PARAMETROS, CALLBACK);
  }

  /**
   * Manda llamar un action especificando el TAB para que el action cargue la sesion auxiliar correspondiente
   *
   * @param string TAB sesion auxiliar que se desea cargar
   * @param string ACTION ruta modulo del action que se desea ejecutar
   * @param array PARAMETROS arreglo con los parametros que seran transmitidos al metodo
   * @param function HANDLER metodo que se ejecutara despues de haber cargado el action
   * @return void
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.tab_call_action = function(TAB, ACTION, PARAMETROS, CALLBACK, ASIGNAR_INSTANCIA)
  {
    if(TAB != 'NOTAB')
    {
      TAB = KLAY.API.call('KLAY:C0.GUI.MAIN.PANEL.tabpanel_get_tab', [TAB]);
    }

    if(ASIGNAR_INSTANCIA)
    {
      KLAY.API.call('KLAY:C0.GUI.MAIN.PANEL.set_instancia_tab', [TAB, ASIGNAR_INSTANCIA, callback_tab_call_action]);
    }
    else
    {
      return callback_tab_call_action();
    }

    function callback_tab_call_action()
    {
      Ext.Ajax.request
      (
        {
          url: 'index.php?ACTION=' + ACTION + '&TAB=' + TAB,
          params: PARAMETROS,
          success: function(result, opts)
          {
            if(CALLBACK)
            {
              CALLBACK(result, opts);
            }
          },
          failure: function(response, opts)
          {
            //console.log('server-side failure with status code ' + response.status);
          }
        }
      );
      /*
      KLAY.request
      (
        ACTION,
        TAB,
        PARAMETROS,
        function(result, event)
        {
         // KLAY.MSG.add_msgs('ERROR', result.MSGS.ERRORES);
         // KLAY.MSG.show_msgs('ERROR', 'alert');
         // KLAY.MSG.add_msgs('AVISO', result.MSGS.AVISOS)
         // KLAY.MSG.show_msgs('AVISO', 'alert');
          if(CALLBACK)
            CALLBACK(result, event);
        }
      );
      */
    }

    return TAB;
  }

  /**
   * Genera un URL
   *
   * @param string GET: cadena donde deben venir los valores que seran enviados por GET
   * @return string: URL
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.url = function(GET)
  {
    return '?' + GET;
  }

  /**
   * Genera un URL incluyendo el TAB para determinar la sesion auxiliar que se desea utilizar
   *
   * @param string TAB: sesion auxiliar que se desea utilizar
   * @param string GET: cadena donde deben venir los valores que seran enviados por GET
   * @return string: URL incluyendo el TAB
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.tab_url = function(TAB, GET)
  {
    return '?' + GET + '&TAB=' + TAB;
  }

  /**
   * Revisa si existe la ruta de objetos necesarios para cargar un API en la ubicacion correcta, y si no existen los crea
   *
   * @param string TAB tab en donde se necesita revisar la ruta
   * @param string INSTANCIA instancia en la que se quiere revisar la ruta
   * @param string MODULO ruta que se quiere revisar
   * @return true si se pudo revisar o generar la ruta y false si no
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.check_path = function(TAB, INSTANCIA, MODULO)
  {
    var m_INSTANCIA_MODULO = INSTANCIA.split('.');

    if(m_INSTANCIA_MODULO[1] != undefined)
    {
      INSTANCIA = m_INSTANCIA_MODULO[0];

      MODULO = m_INSTANCIA_MODULO[1] + '.' + MODULO;
    }
    else if(INSTANCIA.indexOf('#') >= 0)
    {
      INSTANCIA = INSTANCIA.replace('#', '');
    }

    //Si el MODULO existe y es un objeto regresa true, si no es un objeto regresa false
    if(KLAY.API.object_exists("API['" + TAB + "']." + INSTANCIA + '.' + MODULO))
    {
      if(KLAY.API.is_object("API['" + TAB + "']." + INSTANCIA + '.' + MODULO))
        return true;
      else
      {
        //KLAY.MSG.show_msgs('ERROR', 'alert');
        return false;
      }
    }

    //Si la INSTANCIA existe pero no es un objeto regresa false, si no existe lo crea
    if(KLAY.API.object_exists("API['" + TAB + "']." + INSTANCIA))
    {
      if(!KLAY.API.is_object("API['" + TAB + "']." + INSTANCIA))
      {
        //KLAY.MSG.show_msgs('ERROR', 'alert');
        return false;
      }
    }
    else
    {
      eval("API['" + TAB + "']." + INSTANCIA + ' = new function(){};');
    }

    //Se revisa el path al MODULO, si algun valor intermedio existe y no es un objeto se regresa false
    var ELEMENTOS = MODULO.split('.');
    var MODULO_A_REVISAR = ELEMENTOS[0];
    for(var CONT = 0; CONT < ELEMENTOS.length; CONT++)
    {
      if(KLAY.API.object_exists("API['" + TAB + "']." + INSTANCIA + '.' + MODULO_A_REVISAR))
      {
        if(!KLAY.API.is_object("API['" + TAB + "']." + INSTANCIA + '.' + MODULO_A_REVISAR))
        {
          //KLAY.MSG.show_msgs('ERROR', 'alert');
          return false;
        }
      }
      else
      {
        eval("API['" + TAB + "']." + INSTANCIA + '.' + MODULO_A_REVISAR + ' = new function(){};');
      }

      if(CONT + 1 <= ELEMENTOS.length)
        MODULO_A_REVISAR = MODULO_A_REVISAR + '.' + ELEMENTOS[CONT + 1];
    }

    return true;
  }

  /**
   * Revisa si un objeto existe
   *
   * @param string OBJECT_PATH ruta del objeto que se quiere revisar
   * @return true si existe y false si no existe
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.object_exists = function(OBJECT_PATH)
  {
    var e_VALOR, ERROR;

    try
    {
      eval("e_VALOR = " + OBJECT_PATH + ";");

      if(!e_VALOR)
        return false;
     }
     catch(ERROR)
     {
        return false
     }

     return true;
  }

  /**
   * Revisa si una variable es de tipo objeto
   *
   * @param string OBJECT_PATH ruta del objeto que se quiere revisar
   * @return true si es objeto y false si no
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.is_object = function(OBJECT_PATH)
  {
    var e_TIPO, ERROR;

    try
    {
      eval("e_TIPO = typeof(" + OBJECT_PATH + ");");

      if(e_TIPO != 'object')
        return false;
     }
     catch(ERROR)
     {
        return false
     }

     return true;
  }

  /**
   * Devuelve un string que hace referencia a los elementos de un arreglo separados por comas
   * para poder utilizar el string al mandar llamar una funcion
   *
   * @param array PARAMETROS arreglo de donde se obtendran los elementos que se pondran en el string
   * @return string lista de elementos del arreglo
   *
   * Creacion 06 de Agosto del 2009
   * @author Roberto Palos
   */
  this.array_to_params = function(PARAMETROS)
  {
    var PARAMETROS_STRING = '';

    if(PARAMETROS)
    {
      PARAMETROS_STRING = 'PARAMETROS[0]';
      for(var CONT = 1; CONT < PARAMETROS.length; CONT++)
        PARAMETROS_STRING = PARAMETROS_STRING + ', PARAMETROS[' + CONT + ']';
    }

    return PARAMETROS_STRING;
  }

  /**
   * Devuelve un string aleatorio
   *
   * @param int length: longitud del string a devolver
   * @return string: string aleatorio
   *
   * Creacion 09 de Diciembre del 2009
   * @author Roberto Palos
   */
  this.random_string = function(length)
  {
    var chars = "ABCDEFGHIJKLMNOPQRSTUVWXTZ";
    var randomstring = '';

    for (var cont = 0; cont < length; cont++)
    {
      var rnum = Math.floor(Math.random() * chars.length);
      randomstring += chars.substring(rnum, rnum + 1);
    }

    return randomstring;
  }
};

/////KLAY = {};
////Ext.MessageBox.buttonText = {ok: 'Aceptar', cancel: 'Cancelar', yes: 'Si', no: 'No'};

//Inicializacion de API
API = Array();
API['NOTAB'] = new function(){};

//Se carga el api start
KLAY.API.request('NOTAB', 'KLAY', 'C0.GUI.MAIN.START', 'start', ['VERSATIL']);

//Autocarga de APIs

function dump(arr,level)
{
  var dumped_text = "";
  if(!level)
    level = 0;

  //The padding given at the beginning of the line.
  var level_padding = "";

  for(var j=0;j<level+1;j++)
    level_padding += "    ";

  //Array/Hashes/Objects
  if(typeof(arr) == 'object')
  {
   for(var item in arr)
   {
    var value = arr[item];

    //If it is an array,
    if(typeof(value) == 'object')
    {
      dumped_text += level_padding + "'" + item + "' ...\n";
      if(level < 1)
        dumped_text += dump(value, level+1);
    }
    else
    {
      dumped_text += level_padding + "'" + item + "' => \"" + value + "\"\n";
    }
   }
  }
  else
  { //Stings/Chars/Numbers etc.
   dumped_text = "===>" + arr + "<===(" + typeof(arr) + ")";
  }
  return dumped_text;
}