/*

   ReferentialMessageCore : Class to store referential to decode message

    Copyright (C) 2019  AleaJactaEst

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */


#include "modules/debug/debug.h"
#include "modules/impulse/impulsebase.h"
#include "referentialmessagecore.h"

ReferentialMessageCore *ReferentialMessageCore::singleton = nullptr;

/*
 *  ElementReferential
 */

void ElementReferential::show(int level, int pos)
{
   String a;
   for(int i=0;i<level;++i)
      a += String(CharString("+"));
   if(_id == ImpulseBase::Impulse::__LAST_ELEMENT)
   {
      //OS::get_singleton()->print("[%s:%d] level:%d %s pos:%3d ------ power:%d\n", __FILE__, __LINE__, level, a.ascii().get_data(), pos, _power2);
      DBG_PRINT("level:" + itos(level) + " " + a + " id:" + ImpulseBase::get_command_name(_id) + " pos:" + itos(pos) + " ------ power:" + itos(_power2));
   }
   else
   {
      DBG_PRINT("level:" + itos(level) + " " + a + " pos:" + itos(pos) + " id:" + ImpulseBase::get_command_name(_id));
   }
   level ++;
   for(int i=0;i<_children.size();++i)
   {
      Ref<ElementReferential> child = _children[i];
      child->show(level, i);
   }
}

int ElementReferential::read_command(Ref<BitStream> msgin)
{
   uint32_t i = msgin->get_serial(_power2);
   Ref<ElementReferential> child = _children[i];

   if ( child->_id != ImpulseBase::Impulse::__LAST_ELEMENT )
      return child->_id;
   return child->read_command(msgin);
}

/*
 *  ReferentialMessageCore
 */
void ReferentialMessageCore::_bind_methods()
{
}

ReferentialMessageCore *ReferentialMessageCore::get_singleton()
{
    if ( ReferentialMessageCore::singleton == nullptr )
        ReferentialMessageCore::singleton = new ReferentialMessageCore();
    return ReferentialMessageCore::singleton;
}

void ReferentialMessageCore::read_referential_step(Dictionary step, Vector<ElementHead> head, Ref<ElementReferential> root)
{
   uint32_t i;
   Array keys = step.keys();
   String name;
   String sep = ":";
   if ( keys.size() == 0 )
   {
      Ref<BitStream> ele;
      String a;
      int ii;

      ele.instance();
      for(ii=0;ii<head.size() - 1;++ii)
      {
         a += head.get(ii).get_name() + String(CharString("_"));
         uint32_t _size = head.get(ii).get_size();
         ele->put_serial(head.get(ii).get_pos(), getPowerOf2(_size));
      }
      a += head.get(ii).get_name();
      uint32_t _size = head.get(ii).get_size()+1;
      ele->put_serial(head.get(ii).get_pos(), getPowerOf2(_size));
      int id = ImpulseBase::get_command(a);
      if (id != ImpulseBase::Impulse::__LAST_ELEMENT)
      {
         _encoder[id].copy_ref_bitstream(ele);
         root->set_id(id);
      }
      ele.unref();
      return;
   }
   root->set_size(keys.size());
   uint32_t nb = keys.size() - 1;
   String a;
   for(i=0; i <= nb; ++i)
   {
      name = keys[i];
      Vector<String> info = name.split(sep, false, 2);
      if(info.size() == 2 )
      {
         uint32_t id = info[0].to_int();
         Ref<ElementReferential> root_child = root->add_child(ImpulseBase::Impulse::__LAST_ELEMENT, i);
         Variant child ;
         child = step[name];
         ElementHead tmp;
         tmp.create(id, nb, info[1].ascii().get_data());
         head.push_back(tmp);
         read_referential_step(child, head, root_child);
         head.remove(head.size()-1);
      }
   }
}

void ReferentialMessageCore::read_referential(Dictionary dictionary_message)
{
   Vector<ElementHead> head;
   DBG_PRINT("Read Referential Message");
   _decoder->set_id(ImpulseBase::Impulse::__LAST_ELEMENT);
   read_referential_step(dictionary_message, head, _decoder);
}

void ReferentialMessageCore::show()
{
    // For fun, list powerOf2 - TODO check is same with server side, and check size is same value for msg.xml
    /*
    {
        for(int i=0;i<67;++i)
            DBG_PRINT(itos(i) + "=> powerOf2 = " + itos(getPowerOf2(i)));
    }
    */
    // show Element to push data
    {
      for(int i = 0; i < ImpulseBase::Impulse::__LAST_ELEMENT; ++i)
      {
         DBG_PRINT(itos(i) + ") " + ImpulseBase::get_command_name(i) + " " + this->_encoder[i].show().ascii().get_data() + " [size:" + itos(this->_encoder[i].size_data()) + "]");
      }
    }
    // show element to read data
    _decoder->show();
}

void ReferentialMessageCore::clear_session()
{
    if ( ReferentialMessageCore::singleton == nullptr )
        return;
    DBG_PRINT("Clear session for Referential Message.");
    delete ReferentialMessageCore::singleton;
    ReferentialMessageCore::singleton = nullptr;
}

int ReferentialMessageCore::read_command(Ref<BitStream> msgin)
{
   return _decoder->read_command(msgin);
}