#include "avbddclegacy.h"

#include "avb_driver.h"

//#include <windows.h>

#pragma pack(push)
#pragma pack(4)
#include "TS_drv.h"
#include "Int.h"
#include "VIFunc.h"
#pragma pack(pop)

//#include "time_metrics.h"

//#include <QDebug>

//#define USE_DDC_TIME_TAG_BUFFER

//const avb_1553_message_t avb_frame_end_of_minor__={0};
//const avb_1553_message_t avb_frame_end_of_major__={0};
//const avb_1553_message_t avb_frame_skip_next_message__={0};
#ifdef __GNUC__
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#endif

static IAvbDriverClient* avbDriverClient;

static IAvbDriver* avbDriverInstance=0;

static bool sim_rt[32];

extern void DdcSimulator_SimulateBcTick();
extern bool DdcSimulator_isSimulator();

template<typename T_> struct ddc_buffer_map_t
{
  enum { max_buff=250 };
  typedef T_ value_t;
  typedef T_* ptype_t;

  T_* db[max_buff];

  int add(T_* b)
  {
    for(int i=3; i<max_buff; ++i)
      if (db[i]==b)
        return i;
    for(int i=3; i<max_buff; ++i)
      if (db[i]==0)
      {
        db[i]=b;
        return i;
      }
    return 0;
  }

  int set(int pos, T_* b)
  {
    if (pos>=3 && pos<max_buff)
    {
      db[pos]=b;
      return pos;
    }
    return 0;
  }

  T_* fromId(int id)
  {
    if (id>=3 && id<max_buff)
      return db[id];
    return 0;
  }

  int fromDb(T_* b)
  {
    for(int i=3; i<max_buff; ++i)
      if (db[i]==b)
        return i;
    return 0;
  }
};

typedef ddc_buffer_map_t<avb_1553_data_buffer_t> db_map_t;
typedef ddc_buffer_map_t<avb_1553_message_t> msg_map_t;
typedef ddc_buffer_map_t<avb_1553_bc_message_t> frame_map_t;

//avb_1553_bc_message_t avb_1553_end_of_minor_frame;


#define DCALL(x_)   (logError( x_ , __LINE__))

static S32BIT bc_isr(Device_p d, S16BIT p1, S16BIT p2);
static S32BIT mon_isr(Device_p d);

typedef union {
  uint16_t raw;
  struct {
    unsigned int wc: 5;
    unsigned int sa: 5;
    unsigned int tr: 1;
    unsigned int rt: 5;
  };
  CMD idea;
} cw_t;

/*
static CMD cv_cmd(avb_1553_message_t& msg, avb_1553_terminal_t& rt)
{
  cw_t tmp;
  tmp.wc=msg.wc;
  tmp.sa=msg.sa;
  tmp.tr=msg.tr ? 1 : 0;
  tmp.rt=rt.adr;

  return tmp.idea;
}
*/

static CMD ENCODE_CMD(int rt, int tr, int sa, int wc)
{
  CMD idea;
  idea.subadr=sa;
  idea.tadr=rt;
  idea.t_r=tr;
  idea.wcnt=wc;
  return idea;
}

//static DWORD WINAPI ThreadProc(void* param);
typedef struct {
  bool niceInterrupt;
  bool use_ddc_tt_buffer;
  bool debug_msg_level;

  unsigned int major_frame_count;
  unsigned int major_frame_last_tt;
  unsigned int minor_frame_count;
  unsigned int minor_frame_last_tt;
  unsigned int minor_frame_sequencer;

  avb_1553_major_frame_handler_t begin_of_major_frame_handler;
  avb_1553_major_frame_handler_t end_of_major_frame_handler;
  avb_1553_major_frame_handler_t end_of_minor_frame_handler;

} frame_exec_t;

static volatile frame_exec_t frame_exec;

#define DBG_C(level_, msg_)  ({if (frame_exec.debug_msg_level>=level_) {/*avbDriverClient->logError(msg_)/-qDebug()<< msg_ ;*/}})

struct ddc_wrapper_t {
  int cardNo;

  Device_p pCrd;
  DRV_CONFIG dCfg;
  CARD_STATE st;
  IDEA_INFO info;
  Error_t err;

  char rtl_ver[1024];
  char driver_ver[1024];
  char part_no[1024];
  char rtl_core_ver[1024];

  bool frame_installed;

  unsigned num_msg;

  frame_map_t fmap;
  msg_map_t mmap;
  db_map_t bmap;

  MESSAGE ddc_msg[256];
  U16BIT frameList[1024];

  unsigned int bc_served_events;
  unsigned int mon_served_events;
  unsigned int rt_served_events;

  avb_1553_isr_t app_isr;
  avb_1553_monitor_isr_t app_mon_isr;

  HANDLE hEvent;
  HANDLE hTh;
  DWORD idThread;

  Error_t logError(Error_t e, unsigned int lineno=0)
  {
    if (!e)
       return e;
    char buffer[1024];
    ddcGetErrorMessage(pCrd, e, buffer);
    avbDriverClient->logError("DDC Error: %d = %s @%u", e, buffer, lineno);//qWarning()<<"DDC Error: "<<e<<" "<<buffer;

    return e;
  }


  bool init(int card_num=0)
  {
    cardNo=card_num;

    avbDriverClient->logError("DDC: card=%d", card_num);//qDebug()<<"DDC: "<<"card="<<cardNo;

    for(int i=0; i<2; ++i)
    {
      err=DCALL(ddcResetCard(&pCrd, &dCfg, cardNo));
      if (err)
      {
        IdeaResetCard(cardNo, IDEA_BC_AND_MON);
        IdeaShutdown(cardNo);
      }
      if (!err)
      {
        avbDriverClient->logError("DDR Reset: %s", dCfg.bcrt_code);
        break;
      }
    }

    if (err)
    {
      IdeaShutdown(cardNo);
      return false;
    }
    info=ddcGetIdeaInfo(pCrd);

    avbDriverClient->logError(
                "DDC: P/N=%d (%d), driver=%d", info.part_number, info.card_type);
    //qDebug()<<"DDC: "<<info.part_number<<" ("<<info.card_type<<"), driver: "<<info.driver_ver<<", selft test ="<<info.self_test;

    err=DCALL(ddcIdeaVersion(pCrd, rtl_ver, driver_ver, part_no));

    //qDebug()<<"DDC: P/N "<<part_no<<", RTL: "<<rtl_ver<<", Driver: "<<driver_ver;

    err|=DCALL(ddcIdeaCoreVersion(pCrd, rtl_core_ver));

    avbDriverClient->logError(
                "DDC: P/N=%s, driver=%s, rtl=%s (%s)",
                part_no, driver_ver, rtl_ver, rtl_core_ver);

    //qDebug()<<"DDC: RTL Core Version: "<<rtl_ver;

    err|=DCALL(ddcCardState(pCrd, &st));


    if (err)
      return false;

    avbDriverClient->logError(
                "DDC: reset state: %d, %d", st.bcrt, st.card);

    //qDebug()<<"DDC: State at reset: "<<st.bcrt<<", "<<st.card;

    if (st.bcrt!=IDEA_HALTED)
    {
      //qDebug()<<"DDC: card not HALTED, halting it...";
      err=DCALL(ddcHaltIdea(pCrd));
      //qDebug()<<"DDC: card halt "<<(err ? "FAILED" : "PASSED");
    }

    //hEvent=::CreateEvent(0, FALSE, FALSE, 0);
    //hTh=::CreateThread(0, 0, ThreadProc, 0, 0, &idThread);
    //::SetThreadPriority(hTh, THREAD_PRIORITY_TIME_CRITICAL);

    DCALL(ddcDef_int_mask(pCrd, 0xFFFF));

    //Error_t(*usr_handler_p)(Device_p, S16BIT, S16BIT) =
    //        (Error_t(*)(Device_p, S16BIT, S16BIT)) bc_isr;

    err=DCALL(ddcSetBCRTEvent(pCrd, bc_isr)); //(Error_t (* __DECL)(Device_p, S16BIT, S16BIT))bc_isr));
    err=DCALL(ddcSetMONEvent(pCrd, mon_isr));

    err=DCALL(ddcDef_monitor_stack(pCrd, CYCLIC_STACK));
    err=DCALL(ddcSelect_bus(pCrd, YES, YES));

    //DCALL(ddcSetRespTimeout(pCrd, 20));
    return err==0;
  }

  unsigned int getRunState()
  {
    DCALL(ddcCardState(pCrd, &st));

    return st.card;
  }

  void setMinorFrameTime(S32BIT time)
  {
    avbDriverClient->logError("DDC: MF time=%u", time);

    //qDebug()<<"MF Time:"<<time;
    err=DCALL(ddcDef_minor_frame_time(pCrd, time));
  }


  int go_bc(int times)
  {
     avbDriverClient->logError("DDC: GO BC");
     DCALL(ddcHalt_bcrt(pCrd));

     DCALL(ddcDef_int_mask_bcrt(pCrd, ~ ((1<<4)|(1<<5)|(1<<6)|(1<<7))));

     //DCALL(ddcDef_int_mask_bcrt(pCrd, ~ ((1<<4)|(1<<5)|(1<<6))));

     //qDebug()<<"DDC: run Bc...";


     DCALL(ddcRun_bc(pCrd, 1, times<1 ? IDEA_FOREVER : times));

     DCALL(ddcCardState(pCrd, &st));


     avbDriverClient->logError(
                 "DDC: reset state: %d, %d", st.bcrt, st.card);

     enableSkipMessage(true);

     if (DdcSimulator_isSimulator())
     {
       for(int i=1; i<31; ++i)
         DCALL(ddcSet_busy(pCrd, i, NO));
     }

     //DCALL(ddcRun_rt(pCrd));

     return err;
  }
  int go_mon()
  {
      //return 0;
      avbDriverClient->logError("DDC: GO MON");

      if (app_mon_isr)
        ddcDef_int_mask_monitor(pCrd, ~ (1<<14));
      else
        ddcDef_int_mask_monitor(pCrd, ~0);

      //qDebug()<<"DDC: run Mon...";
      err=DCALL(ddcRun_mon(pCrd));

      return err;
  }

  int halt_mon()
  {
      avbDriverClient->logError("DDC: Halt MOM");
      ddcDef_int_mask_monitor(pCrd, ~0);

      //qDebug()<<"DDC: HaltMon";
      err=DCALL(ddcHalt_mon(pCrd));

      return err;

  }

  int halt_bc()
  {
      avbDriverClient->logError("DDC: Halt BC");
      //qDebug()<<"DDC: HaltBcRt";
      DCALL(ddcDef_int_mask_bcrt(pCrd, ~0));

      err=DCALL(ddcHalt_bcrt(pCrd));

      halt_mon();
      return err;
  }


  int stop()
  {
      //qDebug()<<"DDC: HaltIdea";
      avbDriverClient->logError("DDC: stop");

      err=DCALL(ddcHaltIdea(pCrd));

      return err;
  }

  void write_mode_data(unsigned int ta, unsigned int mode, avb_1553_word_t w)
  {
      DCALL(ddcWrite_mode_data(pCrd, ta, mode, w));
  }

  void enableSkipMessage(bool enable=true)
  {
      //avbDriverClient->logError("DDC: SKIP=%s", enable ? "ENA" : "DIS");
      //DCALL(ddcSkip_next_message(pCrd, enable ? IDEA_NO : IDEA_YES));
  }

  void checkIntrStatus(avb_1553_intr_status_t& sts)
  {
    //ViInt32 i_tot, i_mon_host, i_mon_card, i_bc_host, i_bc_card;
    //IdeaDbgOSGetCounts(cardNo, &i_tot, &i_mon_host, &i_mon_card, &i_bc_host, &i_bc_card);

    sts.raised=bc_served_events; //i_bc_card;
    sts.served=bc_served_events;
  }

  void shutdown()
  {
    if (pCrd)
    {
      ddcHaltIdea(pCrd);
      ddcShutDownIdea(&pCrd);
      pCrd=0;
    }
  }

  ~ddc_wrapper_t()
  {
    shutdown();
  }
};

static ddc_wrapper_t ddc_cx;

static unsigned long tt_base=0;

//metricRegistered metricDdcDriverISR("DRV1553");
#define mISR metricDdcDriverISR
//static metricRegistered mISRMON("DDC_MON_ISR", 0, 0, &mISR);
//static metricRegistered mISRSched("DDC_BC_SCHED", 0, 0, &mISR);
//static metricRegistered mISRSUnknown("DDC_BC_UNKNOW", 0, 0, &mISR);

static unsigned int tt_synch_fpos;

static void bc_schedule_nice_interrupt(Device_p d)
{
    //metricMeasure xx(mISRSched);

    if (frame_exec.minor_frame_sequencer>9999)
        return;

   //++frame_exec.minor_frame_sequencer;
   for(; frame_exec.minor_frame_sequencer<250; ++frame_exec.minor_frame_sequencer)
   {
       U16BIT type=0x0080;
       U16BIT subtype=ddc_cx.frameList[frame_exec.minor_frame_sequencer];
       if (subtype==END_OF_MAJOR)
       {
         frame_exec.minor_frame_sequencer=10000;
         break;
       }
       else if (subtype==END_OF_MINOR)
       {
           ++frame_exec.minor_frame_sequencer;
           break;
       }

       if (subtype==tt_synch_fpos)
           continue;

       {
           MESSAGE m;
           Error_t sts=ddcRead_message(ddc_cx.pCrd, subtype, &m);
           if (sts)
               continue;
           if (m.det_error!=NO_ERROR)
           {
               if (m.det_error==BIT_LIT_IN_STATUS)
                   type=0x82;
               else
                   type=0x81;
           }
           S16BIT itype=type | (subtype<<8);
           S16BIT param=0;
           bc_isr(d, itype, param);
       }
   }
}

static S32BIT bc_isr(Device_p d, S16BIT itype, S16BIT /*param*/)
{

  //metricMeasure xx(mISR);

  U16BIT type=itype & 0x00FF;
  U16BIT subtype=(itype>>8) & 0x00FF;


  switch(type)
  {
  case 0x83:
    switch(subtype)
    {
    case 0x00FE: //end of major
        //++frame_exec.major_frame_count;
        subtype=1;
        break;
    case 0x00FF: //end of minor
        //++frame_exec.minor_frame_count;
        subtype=2;
      break;
    }

  case 0x80: //succ. message
  case 0x81: //comm. error
  case 0x82: //bit set status
      ++ddc_cx.bc_served_events;
      if (subtype==1)
      {
        ++frame_exec.major_frame_count;
        frame_exec.minor_frame_count=0;
        frame_exec.minor_frame_sequencer=0;
        U32BIT tt_val;

        if (frame_exec.use_ddc_tt_buffer)
        {
          static U32BIT tt_buff[256];
          S16BIT tt_count;
          Error_t sts=ddcRead_time_tags(ddc_cx.pCrd, tt_buff, &tt_count);
          if (sts==0 && tt_count>0)
            tt_val=tt_buff[0];
          else
            ddcRead_mon_rtc(ddc_cx.pCrd, &tt_val);
        }
        else
          ddcRead_mon_rtc(ddc_cx.pCrd, &tt_val);

        frame_exec.major_frame_last_tt=tt_val;
        if (frame_exec.begin_of_major_frame_handler)
          frame_exec.begin_of_major_frame_handler(avbDriverInstance, frame_exec.major_frame_count, tt_val);
      }
      else if (subtype==2)
      {
          U32BIT tt_val;

          ddcRead_mon_rtc(ddc_cx.pCrd, &tt_val);
          frame_exec.minor_frame_last_tt=tt_val;

          ++frame_exec.minor_frame_count;
          if (frame_exec.niceInterrupt)
            bc_schedule_nice_interrupt(d);

          if (frame_exec.end_of_minor_frame_handler)
            frame_exec.end_of_minor_frame_handler(avbDriverInstance, frame_exec.minor_frame_count, tt_val);
      }
      else
      {
        avb_1553_message_t* msg=ddc_cx.mmap.fromId(subtype);

        U32BIT tt_val;
        ddcRead_mon_rtc(ddc_cx.pCrd, &tt_val);

        if (msg->sa==0)
        {
            {
                tt_base=tt_val;
                break;
            }
        }
        if (msg)
        {

          bool ok= (type==0x80);

          if (msg->msgHandler)
              msg->msgHandler(avbDriverInstance, ok, msg, tt_val);
        }
      }
      break;
  default:
      {
          //metricMeasure xx(mISRSUnknown);
      }
      break;
  }

  return 0;
}


static S32BIT mon_isr(Device_p /*d*/)
{

  //metricMeasure xx(mISRMON);

  ++ddc_cx.mon_served_events;

  if (ddc_cx.app_mon_isr)
      ddc_cx.app_mon_isr(0);

  return 0;
}


class AvbDDCDriver: public IAvbDriver
{
public:
  AvbDDCDriver()
  {
    ddc_cx.init();
  }
  virtual ~AvbDDCDriver()
  {
    ddc_cx.shutdown();
  }

  virtual bool initialize()
  {
    return false;
  }

  virtual avb_1553_intr_status_t getIntrStatus()
  {
    avb_1553_intr_status_t sts;
    ddc_cx.checkIntrStatus(sts);
    sts.major_frames=frame_exec.major_frame_count;
    sts.major_frame_tt=frame_exec.major_frame_last_tt;
    return sts;
  }

  virtual bool go(int times)
  {
    if (!ddc_cx.frame_installed)
    {
        installFrame();
    }
      //return false;

    bool ok=ddc_cx.go_bc(times)==0;
    static U32BIT tt_history[512];
    S16BIT n=0;
    avbDriverClient->logError("Clearinng tt queue");
    ddc_cx.logError(ddcRead_time_tags(ddc_cx.pCrd, tt_history, &n), 0);
    return ok;
  }
  virtual bool stop()
  {
      ddc_cx.halt_mon();
      return ddc_cx.halt_bc()==0;
  }
  virtual bool shutdown()
  {
      ddc_cx.stop();
      ddc_cx.shutdown();
      return true;
  }
  virtual bool go_mon()
  {
      return ddc_cx.go_mon()==0;
  }
  virtual bool halt_mon()
  {
      return ddc_cx.halt_mon()==0;
  }

  virtual bool setUpMessages(unsigned int /*num_of_message*/, const avb_1553_message_t *const /*msg_table*/)
  {
    return false;
  }

  unsigned int calcTime(unsigned t, unsigned int wc)
  {
      if (t)
          return t;
      return (wc+4)*20+25;
  }

  avb_1553_bc_frame_t* xframe;

  virtual bool setUpBcFrame(avb_1553_bc_frame_t& frame)
  {
    xframe=&frame;
    installFrame();
    return true;
  }

  bool installFrame()
  {
    static INJ_ERR kInjErr;
    static MESSAGE msgBeginOfFrame;

    static MESSAGE msgBeginOfFrame_tt={IDEA_NOP, ENCODE_CMD(1, 0, 1, 1), ENCODE_CMD(1, 0, 1, 1), 50, 1, 1, IDEA_BUS_A, IDEA_IMR_TIME_TAG, IDEA_IMR_INT_ON_END_OF_MESSAGE, &kInjErr};
    static MESSAGE msgBeginOfFrame_nott={IDEA_NOP, ENCODE_CMD(1, 0, 1, 1), ENCODE_CMD(1, 0, 1, 1), 50, 1, 1, IDEA_BUS_A, IDEA_IMR_NO_OPERATION, IDEA_IMR_INT_ON_END_OF_MESSAGE, &kInjErr};

    avb_1553_bc_frame_t& frame=*xframe;
    if (frame_exec.use_ddc_tt_buffer)
      msgBeginOfFrame=msgBeginOfFrame_tt;
    else
      msgBeginOfFrame=msgBeginOfFrame_nott;

    static MESSAGE msgEndOfMinor={IDEA_NOP, ENCODE_CMD(1, 0, 1, 1), ENCODE_CMD(1, 0, 1, 1), 50, 1, 1, IDEA_BUS_A, IDEA_IMR_NO_OPERATION, IDEA_IMR_INT_ON_END_OF_MESSAGE, &kInjErr};

    ddc_cx.num_msg=0;
    unsigned int N=frame.num_of_message;

    bool end_of_major_find=false;

    for(int i=0; i<32; ++i)
        sim_rt[i]=0;

    ddc_cx.logError(ddcDef_message(ddc_cx.pCrd, 1, &msgBeginOfFrame));
    ddc_cx.logError(ddcDef_message(ddc_cx.pCrd, 2, &msgEndOfMinor));

    ddc_cx.frameList[0]=1;
    unsigned int fpos=0;


    if (frame.minor_frame_time<10000)
        frame.minor_frame_time=10000;
    //frame.minor_frame_time=20000;

    for(unsigned int i=0; i<N; ++i, ++fpos)
    {
      avb_1553_bc_message_t* bc_msg_p=frame.msg[i];
      if (!bc_msg_p)
          break;

      ++ddc_cx.num_msg;

      avb_1553_bc_message_t& bc_msg=*bc_msg_p;

      avb_1553_message_t* msg=bc_msg.msg;

      if (msg==avb_frame_end_of_minor)
      {
          avbDriverClient->logError("DDC: %u: END OF MINOR",i);//DBG_C(1, "F["<<i<<"] END OF MINOR");

          //ddc_cx.frameList[fpos]=2;
          //++fpos;
          //++ddc_cx.num_msg;

          ddc_cx.frameList[fpos]=IDEA_END_OF_MINOR;
          continue;
      }
      if (msg==avb_frame_end_of_major)
      {
          avbDriverClient->logError("DDC: %u(%u): END OF MAJOR",i, fpos);//DBG_C(1,"F["<<fpos<<"] END OF MAJOR");

          //ddc_cx.frameList[fpos]=2;
          //++fpos;
          //++ddc_cx.num_msg;
          ddc_cx.frameList[fpos]=IDEA_END_OF_MAJOR;
          end_of_major_find=true;
          continue;
      }

      int bc_i=ddc_cx.fmap.fromDb(&bc_msg);
      if (bc_i)
      {
          avbDriverClient->logError("DDC: %u(%u): F[%u]",i, fpos, bc_i );//DBG_C(1,"F["<<fpos<<"]="<<bc_i);

          ddc_cx.frameList[fpos]=bc_i;
          continue;
      }

      bc_i=ddc_cx.fmap.add(&bc_msg);


      bc_msg.avbReserved_=bc_i;
      bc_msg.avbReserved_BcPos=fpos;
      MESSAGE& dm=ddc_cx.ddc_msg[bc_i];

      ddc_cx.frameList[fpos]=bc_i;

      //avbDriverClient->logError("DDC: %u(%u): M[%u] %s: %u:%u:%u:%u",i, fpos, bc_i, msg->nickName, dm.cmd_1.tadr, dm.cmd_1.subadr, dm.cmd_1.t_r, dm.cmd_1.wcnt );//DBG_C(1,"F["<<fpos<<"] NEW MESSAGE: "<<bc_i<<" "<<msg->nickName);

      memset(&dm, 0, sizeof dm);

      dm.inj_error_ptr=&kInjErr;

      dm.first_intermessage_routine=IDEA_IMR_NO_OPERATION;
      dm.second_intermessage_routine=IDEA_IMR_NO_OPERATION;

      //bc_msg.interrupt=avb_bc_interrupt;

      dm.first_intermessage_routine=(msg->type==avb_t_nop_skip_next) ? IDEA_IMR_SKIP_NEXT : IDEA_IMR_NO_OPERATION;
      dm.second_intermessage_routine=bc_msg.interrupt ? IDEA_IMR_INT_ON_END_OF_MESSAGE : IDEA_IMR_NO_OPERATION;

      if (msg->sa==0)
      {
          dm.first_intermessage_routine=IDEA_IMR_TIME_TAG;
          dm.second_intermessage_routine=IDEA_IMR_INT_ON_END_OF_MESSAGE;
          tt_synch_fpos=fpos;
          //ddc_cx.frameList[fpos]=2000;
      }

      if (!msg || !msg->target)
      {
          DBG_C(1,"M["<<bc_i<<"] IDEA NOP");

          dm.comm_type=IDEA_NOP;
          dm.time_to_next_message=calcTime(bc_msg.time_to_next, 10);
          dm.cmd_1.subadr=1;
          dm.cmd_1.tadr=1;
          dm.cmd_1.wcnt=10;
          dm.cmd_1.t_r=0;
          dm.cmd_2=dm.cmd_1;
          continue;
      }

      if (msg->msgHandler && !frame_exec.niceInterrupt)
        dm.second_intermessage_routine=IDEA_IMR_INT_ON_END_OF_MESSAGE;

      dm.cmd_1.subadr=msg->sa;
      dm.cmd_1.tadr=msg->target->adr; //msg->tr==avb_tx ? msg->src->adr : msg->dst->adr;
      dm.cmd_1.t_r=msg->tr==avb_tx ? 1 : 0;
      dm.cmd_1.wcnt=msg->wc>=32 ? 0 : msg->wc;
      dm.cmd_2=dm.cmd_1;

      if (msg->target->mode==avb_term_simulated)
          sim_rt[msg->target->adr]=true;

      if (msg->target->mode==avb_term_disabled || msg->type==avb_t_nop || msg->type==avb_t_nop_skip_next)
          dm.comm_type=IDEA_NOP;
      else
        dm.comm_type=(msg->sa==0 || msg->sa==31) ? IDEA_MODE : ( (msg->tr==avb_tx) ? TRANSMIT : RECEIVE);

      dm.time_to_next_message=calcTime(bc_msg.time_to_next, msg->wc);

      dm.bus=bc_msg.bus==avb_bus_B ? BUS_B : BUS_A;

      //DBG_C(1, "M["<<bc_i<<"] ct="<<dm.comm_type<<" CMD1: "<<dm.cmd_1.tadr<<"-"<<dm.cmd_1.t_r<<"-"<<dm.cmd_1.subadr<<"-"<<dm.cmd_1.wcnt);
      avbDriverClient->logError("DDC: %u(%u): M[%u] %s: %u %u:%u:%u:%u",i, fpos, bc_i, msg->nickName, dm.comm_type, dm.cmd_1.tadr, dm.cmd_1.subadr, dm.cmd_1.t_r, dm.cmd_1.wcnt );//DBG_C(1,"F["<<fpos<<"] NEW MESSAGE: "<<bc_i<<" "<<msg->nickName);

      int msg_i=ddc_cx.mmap.fromDb(msg);
      if (msg_i)
      {
          //qDebug()<<"M["<<bc_i<<"] DB: "<<msg_i;
          avbDriverClient->logError("DDC: defMsg: %u, %u", msg_i,bc_i);
          dm.data_table_no=msg_i;
          dm.last_data_table_no=dm.data_table_no;

          ddc_cx.logError(ddcDef_message(ddc_cx.pCrd, bc_i, &dm));
          continue;
      }

      msg_i=ddc_cx.mmap.add(msg);

      msg->avbReserved_=msg_i;
      msg->avbReserved_BcPos=fpos;

      DBG_C(1,"M["<<bc_i<<"] NEW DB: "<<msg_i<<" size="<<msg->wc);
      avbDriverClient->logError("DDC: newMsg: %u, %u", msg_i,bc_i);

      ddc_cx.logError(ddcDef_table_size(ddc_cx.pCrd, msg_i, msg->wc));

      dm.data_table_no=msg_i;
      dm.last_data_table_no=msg_i;

      ddc_cx.logError(ddcDef_message(ddc_cx.pCrd, bc_i, &dm));
    }


    if (true || !end_of_major_find)
    {
        ddc_cx.frameList[ddc_cx.num_msg]=IDEA_END_OF_MINOR; //2;
        ++ddc_cx.num_msg;
        ddc_cx.frameList[ddc_cx.num_msg]=IDEA_END_OF_MAJOR;
        ++ddc_cx.num_msg;
    }
    //++ddc_cx.num_msg; //the default major frame begin message

    ddc_cx.setMinorFrameTime(frame.minor_frame_time);

    //DBG_C(0,"Def Frame: "<<ddc_cx.num_msg);
    //for(unsigned int n=0; n<ddc_cx.num_msg; ++n)
    //    DBG_C(1,"  "<<n<<": "<<ddc_cx.frameList[n]);

    avbDriverClient->logError("DDC: frame: %u, mt=%u", ddc_cx.num_msg, frame.minor_frame_time);
    //for(unsigned int n=0; n<ddc_cx.num_msg; ++n)
    //    avbDriverClient->logError("  [%d]=%d", n, ddc_cx.frameList[n]);

    ddc_cx.logError(ddcDef_frame(ddc_cx.pCrd, ddc_cx.num_msg, ddc_cx.frameList));

    ddc_cx.setMinorFrameTime(frame.minor_frame_time);

    for(int i=1; i<30; ++i)
        if (false && sim_rt[i])
        {
            static RT_DEFS rt;
            rt.inj_error=&kInjErr;
            ddc_cx.logError(ddcDef_emulate_rt(ddc_cx.pCrd, i, IDEA_YES));
            ddc_cx.logError(ddcDef_rt(ddc_cx.pCrd, i, &rt));
        }
        else
            ddc_cx.logError(ddcDef_emulate_rt(ddc_cx.pCrd, i, IDEA_NO));

    ddc_cx.frame_installed=true;

    if (0)
    {
        static RT_DEFS rt;
        rt.inj_error=&kInjErr;
        ddc_cx.logError(ddcDef_emulate_rt(ddc_cx.pCrd, 0x3, IDEA_YES));
        ddc_cx.logError(ddcDef_rt(ddc_cx.pCrd, 3, &rt));
    }

    ddcDef_emulate_bc(ddc_cx.pCrd, 0x1c, IDEA_NO);
    return true;
  }

  run_status_t getRunState()
  {
      switch(ddc_cx.getRunState())
      {
      default:
          return sts_halt;
      case RUN_BCRT_MONITOR_STATE:
          return sts_bc_mon_run;
      case RUN_MONITOR_STATE:
          return sts_mon_run;
      case RUN_BCRT_STATE:
          return sts_bc_run;
      }
  }

  void set_isr(avb_1553_isr_t isr)
  {
      ddc_cx.app_isr=isr;
  }

  void set_mon_isr(avb_1553_monitor_isr_t isr)
  {
      ddc_cx.app_mon_isr=isr;
  }

  void enableMonitorIsr(bool enable)
  {
      if (enable)
        ddcDef_int_mask_monitor(ddc_cx.pCrd, ~(1<<14));
      else
        ddcDef_int_mask_monitor(ddc_cx.pCrd, 0xFFFF);

  }
  bool getMonitorRawBuffer(avb_1553_monitor_info_t *const b)
  {
      //return false;

      static S16BIT buffer[64*1024];
      S16BIT count=(S16BIT)sizeof(buffer)/sizeof(S16BIT);
      S16BIT messages=sizeof(buffer)/(40*sizeof(S16BIT));

      ddc_cx.err=ddc_cx.logError(ddcRead_mon_stack_part(ddc_cx.pCrd, buffer, &count, &messages));
      if (!b)
          return false;
      b->size=count;
      b->buffer=(avb_1553_word_t*)buffer;

      if (ddc_cx.err)
          return false;
      return true;
  }

  void writeSyncWord(avb_1553_word_t w) override
  {
      //DCALL(ddcWrite_mode_data(ddc_cx.pCrd, 0, 17, w));
      avbDriverClient->logError("DDC: SynchW=%X", w);
      ddc_cx.write_mode_data(0x1c/*0*/, 17, w);
      //if (w==0)
      //    ddcSet_rtc(ddc_cx.pCrd, 0);
  }

  bool insertMessage(const avb_1553_bc_message_t* const m)
  {

      //avbDriverClient->logError("DDC: Insert message: %d", m->avbReserved_BcPos);
      //ddc_cx.logError(ddcInsert_message(ddc_cx.pCrd, m->avbReserved_BcPos+1));
      return true;
  }

  bool enableSkipMessage(bool enable)
  {
      ddc_cx.enableSkipMessage(enable);
      return true;
  }

  int getLastDriverError()
  {
      return ddc_cx.err;
  }
  const char* getDriverErrrorMessage(int /*error_code*/)
  {
      static char tmp[1024];
      ddcGetErrorMessage(ddc_cx.pCrd, ddc_cx.err, tmp);
      return tmp;
  }

  bool mon_decode_msg(avb_1553_mon_decoded_t * const decoded, void * const buffer)
  {
      MON_MSG msg;

      memset(decoded, 0, sizeof *decoded);

      Error_t err=ddcDecode_mon_message(ddc_cx.pCrd, (U16BIT*)buffer, &msg);
      if (err)
          return false;
      bool c1=msg.comm_type==RECEIVE || msg.comm_type==MODE || msg.error_inf.illegal==YES;

      decoded->invalid=msg.error_inf.illegal==YES;
      decoded->modecode=msg.comm_type==MODE;
      decoded->bus=msg.bus==BUS_A ? 0 : 1;
      decoded->broadcast=msg.broadcast==YES;

      decoded->cmd.raw=c1 ? msg.cmd_1 : msg.cmd_2;
      decoded->rx_sts_received=msg.stat_r_flag==1;
      decoded->tx_sts_received=msg.stat_t_flag==1;

      decoded->sts.raw=c1 ? msg.rx_status : msg.tx_status;

      decoded->rtrt_tx_cmd.raw=!c1 ? msg.cmd_1 : msg.cmd_2;
      decoded->rtrt_tx_sts.raw=!c1 ? msg.rx_status : msg.tx_status;

      //decoded->data=(avb_1553_word_t*)msg.data_buf;
      decoded->next=msg.next_msg;
      decoded->timetag=msg.rtc;
      decoded->wc=msg.word_count;

      for(int w=0; w<msg.word_count; ++w)
        decoded->data[w]=(avb_1553_word_t)msg.data_buf[w];

      decoded->rt=c1 ? msg.s_cmd_1.tadr : msg.s_cmd_2.tadr;
      decoded->err=msg.error==YES ? true : false;
      decoded->sa=c1 ? msg.s_cmd_1.sadr : msg.s_cmd_2.sadr;
      decoded->tr=c1 ? msg.s_cmd_1.tr : msg.s_cmd_2.tr;

      decoded->internal_eror_code=msg.error_inf.code;

      if (decoded->err)
      {
        decoded->no_response=msg.error_inf.type==TYPE_NO_RESPONSE;
        decoded->bit_in_status_err=msg.error_inf.tx_status!=NO_ERROR || msg.error_inf.tx_status!=NO_ERROR;
      }

      return true;
  }

  virtual void simulateBcTick()
  {
    DdcSimulator_SimulateBcTick();
  }

  virtual bool readDataBuffer(avb_1553_message_t* const msg, void* const dst, unsigned int wc)
  {
    if (wc>32)
      return false;
    S16BIT w= (S16BIT) ((wc==0) ? msg->wc : wc);
    ddcRead_data(ddc_cx.pCrd, msg->avbReserved_, (S16BIT*)dst, w);
    return true;
  }

  virtual bool writeDataBuffer(const avb_1553_message_t* const msg, void* const src, unsigned int wc=0)
  {
    if (wc>32)
      return false;
    S16BIT w= (S16BIT) ((wc==0) ? msg->wc : wc);
    ddcWrite_data(ddc_cx.pCrd, msg->avbReserved_, (S16BIT*)src, w, 1);
    return true;
  }

  virtual void set_begin_of_major_frame_handler(avb_1553_major_frame_handler_t handler)
  {
    frame_exec.begin_of_major_frame_handler=handler;
  }

  virtual void set_minor_frame_handler(avb_1553_major_frame_handler_t handler)
  {
    frame_exec.end_of_minor_frame_handler=handler;
  }

  virtual void set_end_of_frame_handler(avb_1553_major_frame_handler_t handler)
  {
    frame_exec.end_of_major_frame_handler=handler;
  }

  virtual avb_microseconds_t getTimetag()
  {
      //static U32BIT tt_base=0;
      U32BIT tt_val;
#if 0
    static U32BIT tt_history[128];
    S16BIT n=8;
    ddc_cx.logError(ddcRead_time_tags(ddc_cx.pCrd, tt_history, &n), 0);
    if (n)
    {
        tt_base=tt_history[0];
        avbDriverClient->logError("DDC TBASE=%d", tt_base);
    }
#endif
    ddcRead_mon_rtc(ddc_cx.pCrd, &tt_val);
    tt_val-=tt_base;
    return tt_val;
  }

  virtual void niceInterrupt(bool enable)
  {
      frame_exec.niceInterrupt=enable;
  }
  virtual const char* getDeviceName()
  {
      return ddc_cx.part_no;
  }

  virtual bool isSimulator() const
  {
    return DdcSimulator_isSimulator();
  }
};


IAvbDriver* AvbDriverCreate(const char* /*subtype*/,IAvbDriverClient* client)
{
  avbDriverClient=client;
  frame_exec.niceInterrupt=true;
  frame_exec.use_ddc_tt_buffer=false;

  if (avbDriverInstance==0)
  {
      avbDriverInstance=new AvbDDCDriver;
  }

  return avbDriverInstance;
}

#if 0
#include <QSettings>

IAvbDriver* Avb_DriverCreate(QSettings *settings)
{
  frame_exec.niceInterrupt=true;

  avbDriverInstance=new AvbDDCDriver;

  if (settings)
  {
    settings->beginGroup("avbDriver_DDC");
    QVariant tmp=settings->value("niceInterrupts");
    if (tmp.isValid())
    {
      frame_exec.niceInterrupt=tmp.toBool();
    }
    tmp=settings->value("USE_DDC_TIME_TAG_BUFFER");
    if (tmp.isValid())
    {
      frame_exec.use_ddc_tt_buffer=tmp.toBool();
    }
    tmp=settings->value("DDC_DEBUG_MSG_LEVEL");
    if (tmp.isValid())
      frame_exec.debug_msg_level=tmp.toInt();
    settings->endGroup();
  }
  qDebug()<<"[DDC] niceInterrups="<<frame_exec.niceInterrupt<<", use_tt_buff="<<frame_exec.use_ddc_tt_buffer;
  return avbDriverInstance;
}

IAvbDriver::~IAvbDriver()
{
}

AvbDdcLegacy::AvbDdcLegacy()
{
}
#endif