#include "menu.h"
using namespace Menu;

////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// navNode - Navigation layer controller
//
////////////////////////////////////////////////////////////////////////////////

// navCmd navNode::navKeys(char ch) {
//   trace(Serial<<"navNode::navKeys"<<endl);
//   if (strchr(numericChars,ch)) {
//     return navCmd(idxCmd,ch-'1');
//   }
//   for(uint8_t i=0;i<sizeof(options->navCodes)/sizeof(navCode);i++)
//     if (options->navCodes[i].ch==ch) return options->navCodes[i].cmd;
//   return noCmd;
// }

// generic navigation (aux function)
navCmd navNode::doNavigation(navCmd cmd) {
  trace(Serial<<"navNode::doNavigation"<<endl);
  idx_t osel=sel;
  idx_t nsel=sel;
  navCmd rCmd=cmd;
  bool changed=false;
  // trace(if(cmd.cmd!=noCmd) Serial<<"navigate "<<*target<<" with command:"<<cmd.cmd<<" index:"<<nsel<<endl);
  switch(cmd.cmd) {
    /*case scrlDownCmd:
      if (!target->isVariant())
        root->out.doNav(cmd,*this);*/
    case upCmd:
      // trace(Serial<<"up"<<endl;);
      nsel++;
      if (nsel>=sz()) {if(wrap()) nsel=0; else nsel=sz()-1;}
      // trace(Serial<<"new sel:"<<nsel<<endl);
      break;
      /*case scrlUpCmd:
        if (!target->isVariant())
          root->out.doNav(cmd,*this);*/
    case downCmd:
      // trace(Serial<<"down"<<endl);
      if (nsel||!target->is(_asPad)) {
        nsel--;
        if (nsel<0) {if(wrap()) nsel=sz()-1; else nsel=0;}
        break;
      }
    case escCmd:
      assert(root);
      rCmd=root->exit();
      break;
    case enterCmd:
      assert(root);
      rCmd=root->enter();
      break;
    case selCmd:
    case numValue:
    case idxCmd: {
        idx_t at=(idx_t)cmd.param;//-'1';send us numeric index pls!
        if (at>=0&&at<sz()) {
          changed=true;
          nsel=at;
        }
      }
      break;
    case noCmd:
    default: break;
  }
  // trace(Serial<<"changed:"<<changed<<" sels?"<<(osel!=nsel)<<endl);
  if((osel!=nsel)||changed) {//selection changed, must have been and idx/sel or an up/down movement
    // trace(Serial<<"changed"<<endl);
    if (target->sysStyles()&(_parentDraw|_isVariant)) {
      trace(Serial<<"setting dirty"<<endl);
      target->dirty=true;
      //this works but might be too much, we dont want to invaludate all the menu!
      // if (_parentDraw/*&&root->level*/) root->path[root->level-1].target->dirty=true;
    } else {
      operator[](osel).dirty=true;
      operator[](nsel).dirty=true;
    }
    //send focus In/Out events
    if (selBlurEvent&target->events()) target->operator()(selBlurEvent,*this,*target);
    event(blurEvent,osel);
    sel=nsel;
    if (cmd.cmd==selCmd||cmd.cmd==idxCmd) {//do accelerator and enter the option
      assert(root);
      rCmd=root->enter();
    }//other commands up/down just receive focus events
    event(focusEvent,nsel);
    if (selFocusEvent&target->events()) target->operator()(selFocusEvent,*this,*target);
  } //else its an enter/esc or a non-changing index!
  //Serial<<"doNavigation returning "<<rCmd<<endl;
  return rCmd;
}

result navNode::event(eventMask e,idx_t i) {
  trace(Serial<<"navNode::event"<<endl);
  prompt& p=operator[](i);
  eventMask m=p.events();
  eventMask me=(eventMask)(e&m);
  if (me) return p.eventHandler(e,*this,i);//p(e,p);
  return proceed;
}

result navNode::sysEvent(eventMask e,idx_t i) {
  trace(Serial<<"navNode::sysEvent"<<endl);
  prompt& p=operator[](i);
  return p(e,*this,p);
}

void navRoot::doInput(menuIn& in) {
  trace(Serial<<"navRoot::doInput"<<endl);
  if (sleepTask) {
    navCmd c=in.getCmd();
    if (c==enterCmd || c==escCmd) idleOff();
  } else {
    idx_t inputBurstCnt=inputBurst+1;
    //if (in.available())
    while ((!sleepTask)&&in.available()&&(--inputBurstCnt)) {//if not doing something else and there is input
      //Serial.print(".");
      navFocus->parseInput(node(),in);//deliver navigation input task to target...
    }
  }
  trace(Serial<<"navRoot::doInput ended!"<<endl);
}

void navRoot::doNav(navCmd cmd) {
  trace(Serial<<"navRoot::doNav"<<endl);
  if (sleepTask&&(cmd.cmd==enterCmd || cmd.cmd==escCmd)) idleOff();
  else if (!sleepTask) switch (cmd.cmd) {
    case scrlUpCmd:
    case scrlDownCmd:
      out.doNav(cmd,node());//scroll is perceived better at output device
      break;
    default:
      navFocus->doNav(node(),cmd);
  }
}

navCmd navRoot::enter() {
  trace(Serial<<"navRoot::enter"<<endl);
  if (
    selected().enabled
    &&selected().sysHandler(activateEvent,node(),selected())==proceed
  ) {
    trace(Serial<<"enabled by syshandler"<<endl);
    prompt& sel=selected();
    bool canNav=sel.canNav();
    bool isMenu=sel.isMenu();
    result go=node().event(enterEvent);//item event sent here
    navCmd rCmd=enterCmd;
    if (go==proceed&&isMenu&&canNav) {
      trace(Serial<<"go for canNav && isMenu"<<endl);
      if (level<maxDepth) {
        trace(Serial<<"level<maxDepth"<<endl);
        active().dirty=true;
        menuNode* dest=(menuNode*)&selected();
        level++;
        node().target=dest;
        node().sel=0;
        active().dirty=true;
        sel.sysHandler(enterEvent,node(),selected());
        rCmd=enterCmd;
      } else {
        idleOn(maxDepthError);
        rCmd=noCmd;
      }
    } else if (go==quit&&!selected().isMenu()) exit();
    if (canNav) {
      trace(Serial<<"canNav"<<endl);
      navFocus=(navTarget*)&sel;
      navFocus->dirty=true;
      if (!isMenu) in.fieldOn();
    }
    return rCmd;
  }
  return noCmd;
}

navCmd navRoot::exit() {
  trace(Serial<<"navRoot::exit"<<endl);
  navFocus->dirty=true;
  if (navFocus->isMenu()) {
    if (level) {
      level--;
      node().event(exitEvent,node().sel);
    } else if (canExit) {
      node().event(exitEvent,node().sel);
      idleOn(idleTask);
    }
  } else {
    node().event(exitEvent,node().sel);
    in.fieldOff();
  }
  active().dirty=true;
  navFocus=&active();
  return escCmd;
}

bool navRoot::changed(const menuOut& out) {
  if (sleepTask) return idleChanged;
  if (node().changed(out)) {
    lastChanged=millis();
    return true;
  } else if (canExit&&timeOut&&(millis()-lastChanged)/1000>timeOut) idleOn(idleTask);
  return false;
}


#ifdef MENU_ASYNC
// prompt* navRoot::seek(char* uri) {
//   StringStream s(uri);
//   size_t len = std::count(s.begin(), s.end(), '/');
//   if (uri[0]=='/') s>>'/';  else len++;
//   assert(len<(1<<(sizeof(idx_t)<<3)));
//   idx_t sel[len];
//   for(int n=0;n<len;n++) {
//     s>>sel[n];
//     s>>'/';
//   }
//   return seek(sel,len);
// }
// prompt* navRoot::seek(idx_t* uri,idx_t len) {
//   trace(Serial<<"menuNode::seek"<<endl);
//   if (len&&uri[0]>=0&&uri[0]<sz()) {
//     prompt& e=operator[](uri[0]);
//     assert(e.isMenu());
//     return e.seek(++uri,--len);
//   } else return NULL;
// }
void navRoot::escTo(idx_t lvl) {
  assert(lvl>=0);
  // if (lvl<0) return;
  while(level>lvl) {
    trace(Serial<<"escaping "<<level<<endl);
    doNav(escCmd);
  }
}
bool navRoot::async(const char* at) {
  trace(Serial<<"navRoot::async "<<at<<endl);
  if (!(at&&*at)||at[0]=='/')
    return path[0].target->async(at, *this, 0);
  else
    return active().async(at, *this, level+1);//TODO: check max_depth here!
}
menuOut& navRoot::printPath(menuOut& o,menuNode* to) const {
  trace(Serial<<"printPath:");
  for(idx_t n=0;n<level&&path[n].target!=to;n++) {
    o.print('/');
    o.print(path[n].sel);
  }
  trace(Serial<<endl);
  return o;
}
//async printMenu on arbitrary menuOut device
Used navRoot::printMenu(menuOut& o) const {
  trace(Serial<<"navRoot::printMenu(menuOut& o)"<<endl);
  if ((active().sysStyles()&_parentDraw)&&level)
    return o.printMenu(path[level-1]);
  else return o.printMenu(node());
}

#endif