#define _EXPORT_KERNEL 1

#include "yapi.hh"
extern "C" {

#if __ANDROID__
#include "android/log.h"
#endif

#include "YapInterface.h"
#include "blobs.h"

X_API char *Yap_TermToString(Term t, size_t *length, encoding_t encodingp,
                             int flags);

X_API void YAP_UserCPredicate(const char *, YAP_UserCPred, arity_t arity);
X_API void YAP_UserCPredicateWithArgs(const char *, YAP_UserCPred, arity_t,
                                      YAP_Term);
X_API void YAP_UserBackCPredicate(const char *, YAP_UserCPred, YAP_UserCPred,
                                  arity_t, arity_t);

  #if YAP_PYTHON
  X_API bool     do_init_python(void);
  #endif

}

YAPAtomTerm::YAPAtomTerm(char *s)
{ // build string
  BACKUP_H();

  CACHE_REGS
  seq_tv_t inp, out;
  inp.val.c = s;
  inp.type = YAP_STRING_CHARS;
  out.type = YAP_STRING_ATOM;
  if (Yap_CVT_Text(&inp, &out PASS_REGS))
    mk(MkAtomTerm(out.val.a));
  else
    t = 0L;
  RECOVER_H();
}

YAPAtomTerm::YAPAtomTerm(char *s, size_t len)
{ // build string
  BACKUP_H();

  CACHE_REGS
  seq_tv_t inp, out;
  inp.val.c = s;
  inp.type = YAP_STRING_CHARS;
  out.type = YAP_STRING_ATOM | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
  out.max = len;
  if (Yap_CVT_Text(&inp, &out PASS_REGS))
    mk(MkAtomTerm(out.val.a));
  else
    t = 0L;
  RECOVER_H();
}

YAPAtomTerm::YAPAtomTerm(wchar_t *s) : YAPTerm()
{ // build string
  BACKUP_H();

  CACHE_REGS
  seq_tv_t inp, out;
  inp.val.w = s;
  inp.type = YAP_STRING_WCHARS;
  out.type = YAP_STRING_ATOM;
  if (Yap_CVT_Text(&inp, &out PASS_REGS))
    mk(MkAtomTerm(out.val.a));
  else
    t = 0L;
  RECOVER_H();
}

YAPAtomTerm::YAPAtomTerm(wchar_t *s, size_t len) : YAPTerm()
{ // build string
  BACKUP_H();

  CACHE_REGS
  seq_tv_t inp, out;
  inp.val.w = s;
  inp.type = YAP_STRING_WCHARS;
  out.type = YAP_STRING_ATOM | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
  out.max = len;
  if (Yap_CVT_Text(&inp, &out PASS_REGS))
    mk(MkAtomTerm(out.val.a));
  else
    t = 0L;
  RECOVER_H();
}

YAPStringTerm::YAPStringTerm(char *s)
{ // build string
  BACKUP_H();

  CACHE_REGS
  seq_tv_t inp, out;
  inp.val.c = s;
  inp.type = YAP_STRING_CHARS;
  out.type = YAP_STRING_STRING;
  if (Yap_CVT_Text(&inp, &out PASS_REGS))
    mk(out.val.t);
  else
    t = 0L;
  RECOVER_H();
}

YAPStringTerm::YAPStringTerm(char *s, size_t len)
{ // build string
  BACKUP_H();

  CACHE_REGS

  seq_tv_t inp, out;
  inp.val.c = s;
  inp.type = YAP_STRING_CHARS;
  out.type = YAP_STRING_STRING | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
  out.max = len;
  if (Yap_CVT_Text(&inp, &out PASS_REGS))
    mk(out.val.t);
  else
    t = 0L;
  RECOVER_H();
}

YAPStringTerm::YAPStringTerm(wchar_t *s) : YAPTerm()
{ // build string
  BACKUP_H();

  CACHE_REGS

  seq_tv_t inp, out;
  inp.val.w = s;
  inp.type = YAP_STRING_WCHARS;
  out.type = YAP_STRING_STRING;
  if (Yap_CVT_Text(&inp, &out PASS_REGS))
    mk(out.val.t);
  else
    t = 0L;
  RECOVER_H();
}

YAPStringTerm::YAPStringTerm(wchar_t *s, size_t len)
    : YAPTerm()
{ // build string
  BACKUP_H();

  CACHE_REGS

  seq_tv_t inp, out;
  inp.val.w = s;
  inp.type = YAP_STRING_WCHARS;
  out.type = YAP_STRING_STRING | YAP_STRING_NCHARS | YAP_STRING_TRUNC;
  out.max = len;
  if (Yap_CVT_Text(&inp, &out PASS_REGS))
    mk(out.val.t);
  else
    t = 0L;
  RECOVER_H();
}

YAPApplTerm::YAPApplTerm(YAPFunctor f, YAPTerm ts[]) 
{
  BACKUP_H();
  arity_t arity = ArityOfFunctor(f.f);
  Term o = Yap_MkNewApplTerm(f.f, arity);
  Term *tt = RepAppl(o)+1;
  for (arity_t i = 0; i < arity; i++)
    tt[i] = ts[i].term();
  mk(o);
  RECOVER_H();
}

YAPApplTerm::YAPApplTerm(std::string f, std::vector<YAPTerm> ts)
{
  BACKUP_H();
  arity_t arity = ts.size();
  Functor ff = Yap_MkFunctor(Yap_LookupAtom(f.c_str()),arity);
  Term o = Yap_MkNewApplTerm(ff, arity);
  Term *tt = RepAppl(o)+1;
  for (arity_t i = 0; i < arity; i++)
    tt[i] = ts[i].term();
  mk(o);
}

YAPApplTerm::YAPApplTerm(YAPFunctor f) : YAPTerm()
{
  BACKUP_H();
  arity_t arity = ArityOfFunctor(f.f);
  mk(Yap_MkNewApplTerm(f.f, arity));
  RECOVER_H();
}

YAPFunctor YAPApplTerm::getFunctor() { return YAPFunctor(FunctorOfTerm(gt())); }

Term &YAPTerm::operator[](arity_t i)
{
  BACKUP_MACHINE_REGS();
  Term t0 = gt();
  Term tf = 0;
  if (IsApplTerm(t0))
  {
    // Functor f = FunctorOfTerm(t0);
    // if (IsExtensionFunctor(f))
    //  return 0;
    tf = RepAppl(t0)[(i + 1)];
  }
  else if (IsPairTerm(t0))
  {
    if (i == 0)
      tf = HeadOfTerm(t0);
    else if (i == 1)
      tf = TailOfTerm(t0);
    RECOVER_MACHINE_REGS();
    tf = RepPair(tf)[i];
  }
  RECOVER_MACHINE_REGS();
  Yap_Error(TYPE_ERROR_COMPOUND, tf, "");
  throw YAPError();
}

Term &YAPListTerm::operator[](arity_t i)
{
  BACKUP_MACHINE_REGS();
  Term t0 = gt();
  Term tf = 0;
  while (IsPairTerm(t0))
  {
    if (i == 0)
    {
      tf = HeadOfTerm(t0);
      break;
    }
    else
    {
      t0 = TailOfTerm(t0);
      i--;
    }
  }
  RECOVER_MACHINE_REGS();
  return RepPair(tf)[i];
}

YAPPairTerm::YAPPairTerm(YAPTerm th, YAPTerm tl)
{
  CACHE_REGS
  BACKUP_H();
  mk(MkPairTerm(th.term(), tl.term()));
  RECOVER_H();
}

YAPPairTerm::YAPPairTerm()
{
  BACKUP_H();
  mk(TermNil);
  RECOVER_H();
}

YAP_tag_t YAPTerm::tag()
{
  Term tt = gt();
  if (IsVarTerm(tt))
  {
    CELL *pt = VarOfTerm(tt);
    if (IsUnboundVar(pt))
    {
      CACHE_REGS
      if (IsAttVar(pt))
        return YAP_TAG_ATT;
      return YAP_TAG_UNBOUND;
    }
    return YAP_TAG_REF;
  }
  if (IsPairTerm(tt))
    return YAP_TAG_PAIR;
  if (IsAtomOrIntTerm(tt))
  {
    if (IsAtomTerm(tt))
      return YAP_TAG_ATOM;
    return YAP_TAG_INT;
  }
  else
  {
    Functor f = FunctorOfTerm(tt);

    if (IsExtensionFunctor(f))
    {
      if (f == FunctorDBRef)
      {
        return YAP_TAG_DBREF;
      }
      if (f == FunctorLongInt)
      {
        return YAP_TAG_LONG_INT;
      }
      if (f == FunctorBigInt)
      {
        big_blob_type bt = (big_blob_type)RepAppl(tt)[1];
        switch (bt)
        {
        case BIG_INT:
          return YAP_TAG_BIG_INT;
        case BIG_RATIONAL:
          return YAP_TAG_RATIONAL;
        default:
          return YAP_TAG_OPAQUE;
        }
      }
    }
    return YAP_TAG_APPL;
  }
}

Term YAPTerm::deepCopy()
{
  yhandle_t tn;
  BACKUP_MACHINE_REGS();

  tn = Yap_CopyTerm(gt());

  RECOVER_MACHINE_REGS();
  return (tn);
}

Term YAPListTerm::dup()
{
  yhandle_t tn;
  BACKUP_MACHINE_REGS();

  tn = Yap_CopyTerm(gt());

  RECOVER_MACHINE_REGS();
  return tn;
}

intptr_t YAPTerm::numberVars(intptr_t i0, bool skip_singletons)
{
  BACKUP_MACHINE_REGS();

  intptr_t i = Yap_NumberVars(gt(), i0, skip_singletons);

  RECOVER_MACHINE_REGS();
  return i;
}

const char *YAPQuery::text() { return YAPTerm(goal).text(); }

YAPIntegerTerm::YAPIntegerTerm(intptr_t i)
{
  CACHE_REGS Term tn = MkIntegerTerm(i);
  mk(tn);
}

/*
YAPTerm *YAPTerm::vars()
{
  BACKUP_MACHINE_REGS();
  CACHE_REGS
  YAPPairTerm lv = YAPPairTerm(Yap_TermVariables(gt(), 0 PASS_REGS));
  RECOVER_MACHINE_REGS();
  return lv;
}
 */

YAPTerm::YAPTerm(void *ptr)
{
  CACHE_REGS
  mk(MkIntegerTerm((Int)ptr));
}

Term YAPListTerm::car()
{
  Term to = gt();
  if (IsPairTerm(to))
    return (HeadOfTerm(to));
  else
  {
    Yap_Error(TYPE_ERROR_LIST, to, "");
    throw YAPError();
    return 0;
  }
}

YAPListTerm::YAPListTerm(YAPTerm ts[], arity_t n)
{
  CACHE_REGS
  BACKUP_H();
  if (n == 0)
    t = TermNil;
  while (HR + n * 2 > ASP - 1024)
  {
    RECOVER_H();
    if (!Yap_dogc(0, NULL PASS_REGS))
    {
      t = TermNil;
    }
    BACKUP_H();
  }
  t = AbsPair(HR);
  for (arity_t i = 0; i < n; i++)
  {
    HR[2 * i] = ts[i].gt();
    HR[2 * i + 1] = AbsPair(HR + (2 * i + 2));
  }
}

YAPVarTerm::YAPVarTerm()
{
  CACHE_REGS
  mk(MkVarTerm());
}

const char *YAPAtom::getName(void) { return Yap_AtomToUTF8Text(a, nullptr); }

void YAPQuery::openQuery(Term t, Term *ts)
{
  CACHE_REGS
  if (ts) {
    arity_t arity = ap->ArityOfPE;
    for (arity_t i = 0; i < arity; i++)
    {
      XREGS[i + 1] = ts[i];
    }
  }
  setNext();
}

bool YAPEngine::call(YAPPredicate ap, YAPTerm ts[])
{
  try
  {
    CACHE_REGS
    if (ap.ap == NULL)
      return false;                         
    BACKUP_MACHINE_REGS();
    arity_t arity = ap.getArity();
    bool result;
    YAP_dogoalinfo q;
    sigjmp_buf q_env;

    for (arity_t i = 0; i < arity; i++)
      XREGS[i + 1] = ts[i].term();

    if (ap.ap == nullptr || ap.ap->OpcodeOfPred == UNDEF_OPCODE)
    {
      Term g = YAP_MkApplTerm(ap.ap->FunctorOfPred, arity, XREGS+1);
      ap = YAPPredicate(rewriteUndefEngineQuery(ap.ap, g, ap.ap->ModuleOfPred));
    }

    q.CurSlot = Yap_StartSlots();
    q.p = P;
    q.cp = CP;
    // allow Prolog style exceotion handling
    LOCAL_RestartEnv = &q_env;
    if (sigsetjmp(q_env, false))
    {
      throw YAPError();
    }
    // don't forget, on success these bindings will still be there);
    result = YAP_LeaveGoal(false, &q);
    Yap_CloseHandles(q.CurSlot);
    RECOVER_MACHINE_REGS();
    return result;
  }
  catch (YAPError e)
  {
    YAP_LeaveGoal(false, &q);
    Yap_CloseHandles(q.CurSlot);
    std::cerr << "Exception received by  " << YAPApplTerm(ap.functor(), ts).text() << ".\n Forwarded...\n\n";
    throw e;
  }
}

bool YAPEngine::mgoal(Term t, Term tmod)
{
  try
  {
    CACHE_REGS
    BACKUP_MACHINE_REGS();
    Term *ts = nullptr;
    PredEntry *ap = Yap_get_pred(t, tmod, "C++");

    if (ap == nullptr || ap->OpcodeOfPred == UNDEF_OPCODE)
    {
      ap = rewriteUndefEngineQuery(ap, t, tmod);
      if (ap == nullptr || ap->OpcodeOfPred == UNDEF_OPCODE)
	return false;
    } else
      {
	/* legal ap */
     arity_t arity = ap->ArityOfPE;

      if (arity) {
        if (IsApplTerm(t))
        {
          ts = RepAppl(t) + 1;
        }
        else
        {
          ts = RepPair(t);
        }
        for (arity_t i = 0; i < arity; i++)
          XREGS[i + 1] = ts[i];
      } else if ( IsAtomTerm(t)) {
        ts = nullptr;
      }

    }
    bool result;
    sigjmp_buf q_env;
    q.CurSlot = Yap_StartSlots();
    q.p = P;
    q.cp = CP;
    // allow Prolog style exceotion handling
    LOCAL_RestartEnv = &q_env;
    if (sigsetjmp(q_env, false))
    {
      throw YAPError();
    }
    // don't forget, on success these guys may create slots
    __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec  ");

    result = (bool)YAP_EnterGoal(ap, nullptr, &q);
    //  fprintf(stderr,"in");Yap_DebugPlWrite(t);
    {
      YAP_LeaveGoal(false, &q);
      RECOVER_MACHINE_REGS();
      return result;
    }
  }
  catch (YAPError e)
  {
    YAP_LeaveGoal(false, &q);
    Yap_CloseHandles(q.CurSlot);
    throw e;
  }
}

void YAPEngine::release()
{

  BACKUP_MACHINE_REGS();
  YAP_LeaveGoal(FALSE, &q);
  RECOVER_MACHINE_REGS();
}

Term YAPEngine::fun(Term t)
{
  CACHE_REGS
  try
  {
    BACKUP_MACHINE_REGS();
    Term tmod = CurrentModule, *ts = nullptr;
    PredEntry *ap;
    arity_t arity;
    Functor f;
    sigjmp_buf q_env;
    Atom name;

    if (IsApplTerm(t))
    {
      ts = RepAppl(t) + 1;
      f = (Functor)ts[-1];
      name = NameOfFunctor(f);
      arity = ArityOfFunctor(f);
      for (arity_t i = 0; i < arity; i++)
        XREGS[i + 1] = ts[i];
    }
    else if (IsAtomTerm(t))
    {
      name = AtomOfTerm(t);
      f = nullptr;
      arity = 0;
    }
    else if (IsPairTerm(t))
    {
      XREGS[1] = ts[0];
      XREGS[2] = ts[1];
      arity = 2;
      name = AtomDot;
      f = FunctorDot;
    }
    else
    {
      Yap_ThrowError(TYPE_ERROR_CALLABLE, t, 0);
      return 0L;
    }
    XREGS[arity + 1] = MkVarTerm();
    arity++;
    f = Yap_MkFunctor(name, arity);
    ap = (PredEntry *)(PredPropByFunc(f, tmod));
    if (ap == nullptr || ap->OpcodeOfPred == UNDEF_OPCODE)
    {
      Term g = (Yap_MkApplTerm(f,arity, ts) );
      ap = rewriteUndefEngineQuery(ap, g, (ap->ModuleOfPred));
    }
    q.CurSlot = Yap_StartSlots();
    q.p = P;
    q.cp = CP;
    // make sure this is safe
    yhandle_t o = Yap_InitHandle(XREGS[arity]);
    // allow Prolog style exception handling
    LOCAL_RestartEnv = &q_env;
    if (sigsetjmp(q_env, false))
    {
      throw YAPError();
    }
    // don't forget, on success these guys may create slots
    __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec  ");

    if (YAP_EnterGoal(ap, nullptr, &q) == 0)
      return 0;
    XREGS[arity] = Yap_GetFromSlot(o);
    __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out  %ld", o);
    YAP_LeaveGoal(false, &q);
    Yap_CloseHandles(q.CurSlot);
    RECOVER_MACHINE_REGS();
    return XREGS[arity];
  }
  catch (YAPError e)
  {
    YAP_LeaveGoal(false, &q);
    Yap_CloseHandles(q.CurSlot);
    std::cerr << "Exception received by  " << __func__ << "( " << YAPTerm(t).text() << ").\n Forwarded...";
    throw e;
  }
}

YAPQuery::YAPQuery(YAPFunctor f, YAPTerm mod, YAPTerm ts[])
    : YAPPredicate(f, mod)
{
  /* ignore flags  for now */
  BACKUP_MACHINE_REGS();
    Term *nts;
  Term goal;
  
  if ( ts) {

  goal = YAPApplTerm(f, ts).term();
  nts = RepAppl(goal)+1;

} else {
  goal = MkVarTerm();
  nts = nullptr;
}
    openQuery(goal, nts);
  names = YAPPairTerm( TermNil );
  RECOVER_MACHINE_REGS();
}

#if 0
YAPQuery::YAPQuery(YAPFunctor f, YAPTerm ts[]) : YAPPredicate(f) {
  /* ignore flags for now */
  BACKUP_MACHINE_REGS();
  CELL *nts;
  if (ts) {
  goal =  YAPApplTerm(f, nts);
  } else {
   goal = YAPVarTerm();
   nts = nullptr;
  }
  names = YAPPairTerm( TermNil );
  openQuery(goal.term(), nts);
  RECOVER_MACHINE_REGS();
}
#endif

YAPQuery::YAPQuery(YAPTerm t) : YAPPredicate(t)
{
  BACKUP_MACHINE_REGS();
 CELL *nts;
 Term tt = t.term();
 goal = t;
 if (IsApplTerm(tt)) {
     Functor f = FunctorOfTerm(tt);
     if (IsExtensionFunctor(f))
       nts =                                              nullptr;
     nts = RepAppl(goal.term())+1;
  } else if (IsPairTerm(tt)) {
         nts = RepPair(tt);
  } else {
    nts = nullptr;
  }
  openQuery(tt, nts);
  names =  YAPPairTerm( TermNil );
  RECOVER_MACHINE_REGS();
}


YAPQuery::YAPQuery(YAPPredicate p, YAPTerm ts[]) : YAPPredicate(p.ap) {
  BACKUP_MACHINE_REGS();
  arity_t arity = p.ap->ArityOfPE;
  if (arity) {
    goal = YAPApplTerm(YAPFunctor(p.ap->FunctorOfPred), ts).term();
    for (arity_t i =0; i < arity; i++)
      XREGS[i+1]=ts[i].term();
    openQuery(goal.term(), nullptr);
  } else {
    goal = YAPAtomTerm((Atom)(p.ap->FunctorOfPred));
    openQuery(goal.term(), nullptr);
  }
  names = TermNil;
  RECOVER_MACHINE_REGS();
}

bool YAPQuery::next()
{
  CACHE_REGS
    bool result = false;
  Term terr;
  if (ap == NULL || ap->OpcodeOfPred == UNDEF_OPCODE) {
    ap = rewriteUndefQuery();
  }
  LOCAL_RestartEnv = &q_env;
  try
  {
    BACKUP_MACHINE_REGS();
    if (!q_open)
      return false;
    if (sigsetjmp(q_env, false))
    {
      throw YAPError();
    }
    // don't forget, on success these guys may create slots
    __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "exec  ");

    if (q_state == 0)
    {
      result = (bool)YAP_EnterGoal(ap, nullptr, &q_h);
    }
    else
    {
      LOCAL_AllowRestart = q_open;
      result = (bool)YAP_RetryGoal(&q_h);
    }
    if (result)
    {
      __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "vnames  %d %s %ld",
                          q_state, vnames.text(), LOCAL_CurSlot);
    }
    else
    {
      __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "fail");
    }
    q_state = 1;
    if ((terr = Yap_GetException()))
    {
      if ((terr = Yap_GetException()))
      {
        throw YAPError();
      }
    }
    __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "out  %d", result);

    if (!result)
    {
      YAP_LeaveGoal(false, &q_h);
      Yap_CloseHandles(q_handles);
      q_open = false;
    }
    else
    {
      q_handles = Yap_StartSlots();
    }
    RECOVER_MACHINE_REGS();
    return result;
  }
  catch (YAPError e)
  {
    q_open = false;
    Yap_PopTermFromDB(LOCAL_ActiveError->errorTerm);
    memset(LOCAL_ActiveError, 0, sizeof(*LOCAL_ActiveError));
    YAP_LeaveGoal(false, &q_h);
    Yap_CloseHandles(q_handles);
    q_open = false;
    std::cerr << "Exception received by  " << __func__ << "( " << YAPTerm(terr).text() << ").\n Forwarded...\n\n";
    throw e;
  }
}

PredEntry *
YAPQuery::rewriteUndefQuery()
{
  Term ts[3];
  ARG1 = ts[0] = goal.term();
  ARG2 = ts[1] = ap->ModuleOfPred;
  ARG3 = ts[2] = Yap_cp_as_integer(B PASS_REGS);
  goal = YAPApplTerm(FunctorUndefinedQuery, ts);
  return ap = PredUndefinedQuery;
}

PredEntry *
YAPEngine::rewriteUndefEngineQuery(PredEntry *a, Term goal, Term mod)
{
  Term ts[3];
  ARG1 = ts[0] = goal;
  ARG2 = ts[1] = mod;
  ARG3 = ts[2] = Yap_cp_as_integer(B PASS_REGS);
  return PredUndefinedQuery;
  //return YAPApplTerm(FunctorUndefinedQuery, ts);
}

void YAPQuery::cut()
{
  CACHE_REGS

  BACKUP_MACHINE_REGS();
  if (!q_open || q_state == 0)
    return;
  YAP_LeaveGoal(FALSE, &q_h);
  q_open = 0;
  // LOCAL_execution = this;
  RECOVER_MACHINE_REGS();
}

bool YAPQuery::deterministic()
{
  CACHE_REGS

  BACKUP_MACHINE_REGS();
  if (!q_open || q_state == 0)
    return false;
  choiceptr myB = (choiceptr)(LCL0 - q_h.b);
  return (B >= myB);
  RECOVER_MACHINE_REGS();
}

YAPTerm YAPQuery::getTerm(yhandle_t t) { return YAPTerm(t); }

void YAPQuery::close()
{
  CACHE_REGS

  RECOVER_MACHINE_REGS();
  Yap_ResetException(worker_id);
  /* need to implement backtracking here */
  if (q_open != true || q_state == 0)
  {
    RECOVER_MACHINE_REGS();
    return;
  }
  YAP_LeaveGoal(FALSE, &q_h);
  q_open = 0;
  Yap_CloseHandles(q_handles);
  // LOCAL_execution = this;
  RECOVER_MACHINE_REGS();
}

#if __ANDROID__

#include <jni.h>
#include <string.h>

JNIEnv *Yap_jenv;

extern JNIEXPORT jint JNICALL JNI_MySQLOnLoad(JavaVM *vm, void *reserved);

JNIEXPORT jint JNICALL JNI_MySQLOnLoad(JavaVM *vm, void *reserved)
{
  JNIEnv *env;
  if (vm->GetEnv(reinterpret_cast<void **>(&env), JNI_VERSION_1_6) != JNI_OK)
  {
    return -1;
  }
  Yap_jenv = env;

  return JNI_VERSION_1_6;
}

char *Yap_AndroidBufp;

static size_t Yap_AndroidMax, Yap_AndroidSz;

extern void (*Yap_DisplayWithJava)(int c);

void Yap_displayWithJava(int c)
{
  char *ptr = Yap_AndroidBufp;
  if (!ptr)
    ptr = Yap_AndroidBufp = (char *)malloc(Yap_AndroidSz);
  ptr[Yap_AndroidSz++] = c;
  if (Yap_AndroidMax - 1 == Yap_AndroidSz)
  {
    if (Yap_AndroidMax < 32 * 1024)
    {
      Yap_AndroidMax *= 2;
    }
    else
    {
      Yap_AndroidMax += 32 * 1024;
    }
    Yap_AndroidBufp = (char *)realloc(ptr, Yap_AndroidMax);
  }
  Yap_AndroidBufp[Yap_AndroidSz] = '\0';
  if (c == '\n')
  {
    Yap_AndroidBufp[Yap_AndroidSz] = '\0';
    curren->run(Yap_AndroidBufp);
    Yap_AndroidSz = 0;
  }
}

#endif


void YAPEngine::doInit(YAP_file_type_t BootMode)
{
  if ((BootMode = YAP_Init(&engine_args->init_args)) == YAP_FOUND_BOOT_ERROR)
  {
    throw YAPError();
  }
  /* Begin preprocessor code */
  /* live */
  __android_log_print(ANDROID_LOG_INFO, "YAPDroid", "initialize_prolog");
#if __ANDROID__
  Yap_AndroidBufp = (char *)malloc(Yap_AndroidMax = 4096);
  Yap_AndroidBufp[0] = '\0';
  Yap_AndroidSz = 0;
#endif
  //yerror = YAPError();
#if YAP_PYTHON
    do_init_python();
#endif
    YAP_PredEntryPtr p = YAP_AtomToPred( YAP_LookupAtom("initialize_prolog") );
    YAPQuery initq = YAPQuery(YAPPredicate(p), nullptr);
    if (initq.next())
      {
	initq.cut();
  }
    CurrentModule = TermUser;

}

YAPEngine::YAPEngine(int argc, char *argv[],
		     YAPCallback *cb)
      : _callback(0) { // a single engine can be active

      YAP_file_type_t BootMode;
      engine_args = new YAPEngineArgs();
      BootMode = YAP_parse_yap_arguments(argc, argv, &engine_args->init_args);
      // delYAPCallback()b
      // if (cb)
      //  setYAPCallback(cb);
      doInit(BootMode);
    }


    YAPPredicate::YAPPredicate(YAPAtom at)
    {
      CACHE_REGS
	ap = RepPredProp(PredPropByAtom(at.a, Yap_CurrentModule()));
    }

    YAPPredicate::YAPPredicate(YAPAtom at, uintptr_t arity)
    {
      CACHE_REGS
	if (arity)
	  {
	    Functor f = Yap_MkFunctor(at.a, arity);
	    ap = RepPredProp(PredPropByFunc(f, Yap_CurrentModule()));
	  }
	else
	  {
	    ap = RepPredProp(PredPropByAtom(at.a, Yap_CurrentModule()));
	  }
    }

    /// auxiliary routine to find a predicate in the current module.
    PredEntry *YAPPredicate::getPred(YAPTerm &tt, Term *&outp)
    {
      CACHE_REGS
	Term m = Yap_CurrentModule(), t = tt.term();
      t = Yap_StripModule(t, &m);
      if (IsVarTerm(t) || IsNumTerm(t))
	{
	  if (IsVarTerm(t))
	    Yap_ThrowError(INSTANTIATION_ERROR, tt.term(), 0);
	  else if (IsNumTerm(t))
	    Yap_ThrowError(TYPE_ERROR_CALLABLE, tt.term(), 0);
	  throw YAPError();
	}
      tt.put(t);
      if (IsAtomTerm(t))
	{
	  ap = RepPredProp(PredPropByAtom(AtomOfTerm(t), m));
	  outp = (Term *)NULL;
	  return ap;
	}
      else if (IsPairTerm(t))
	{
	  Term ts[2];
	  ts[0] = t;
	  ts[1] = m;
	  t = Yap_MkApplTerm(FunctorCsult, 2, ts);
	  tt.put(t);
	  outp = RepAppl(t) + 1;
	}
      Functor f = FunctorOfTerm(t);
      if (IsExtensionFunctor(f))
	{
	  Yap_ThrowError(TYPE_ERROR_CALLABLE, t, 0);
	}
      else
	{
	  ap = RepPredProp(PredPropByFunc(f, m));
	  outp = RepAppl(t) + 1;
	}
      return ap;
    }

    bool YAPPrologPredicate::assertClause(YAPTerm cl, bool last,
						YAPTerm source)
    {
      CACHE_REGS

	RECOVER_MACHINE_REGS();
      Term tt = cl.gt();
      Term sourcet;
      Term ntt = cl.gt();
      if (source.initialized())
	sourcet = source.gt();
      else
	sourcet = TermZERO;
      yamop *codeaddr = Yap_cclause(tt, ap->ArityOfPE, Yap_CurrentModule(),
				    sourcet); /* vsc: give the number of arguments
						 to cclause in case there is overflow */
      if (LOCAL_ErrorMessage)
	{
	  RECOVER_MACHINE_REGS();
	  return false;
	}
      Term *tref = &ntt;
      if (Yap_addclause(ntt, codeaddr, (last ? TermAssertz : TermAsserta),
			Yap_CurrentModule(), tref))
	{
	  RECOVER_MACHINE_REGS();
	}
      return tref;
    }

    bool YAPPrologPredicate::assertFact(YAPTerm *cl, bool last)
    {
      CACHE_REGS
	arity_t i;
      RECOVER_MACHINE_REGS();
      Term tt = AbsAppl(HR);
      *HR++ = (CELL)(ap->FunctorOfPred);
      for (i = 0; i < ap->ArityOfPE; i++, cl++)
	*HR++ = cl->gt();
      yamop *codeaddr = Yap_cclause(tt, ap->ArityOfPE, Yap_CurrentModule(),
				    tt); /* vsc: give the number of arguments
					    to cclause in case there is overflow */
      if (LOCAL_ErrorMessage)
	{
	  RECOVER_MACHINE_REGS();
	  return false;
	}
      Term *tref = &tt;
      if (Yap_addclause(tt, codeaddr, (last ? TermAssertz : TermAsserta),
			Yap_CurrentModule(), tref))
	{
	  RECOVER_MACHINE_REGS();
	}
      return tref;
    }

    void *YAPPrologPredicate::retractClause(YAPTerm skeleton, bool all)
    {
      return 0;
    }

    std::string YAPError::text()
    {
      char buf[256];
      std::string s = "";
      if (LOCAL_ActiveError->errorFunction)
	{
	  s += LOCAL_ActiveError->errorFile;
	  s += ":";
	  sprintf(buf, "%ld", (long int)LOCAL_ActiveError->errorLine);
	  s += buf;
	  s += ":0 in C-code";
	}
      if (LOCAL_ActiveError->prologPredLine)
	{
	  s += "\n";
	  s += LOCAL_ActiveError->prologPredFile->StrOfAE;
	  s += ":";
	  sprintf(buf, "%ld", (long int)LOCAL_ActiveError->prologPredLine);
	  s += buf; // std::to_string(LOCAL_ActiveError->prologPredLine) ;
	  // YAPIntegerTerm(LOCAL_ActiveError->prologPredLine).text();
	  s += ":0   ";
	  s += LOCAL_ActiveError->prologPredModule;
	  s += ":";
	  s += (LOCAL_ActiveError->prologPredName)->StrOfAE;
	  s += "/";
	  sprintf(buf, "%ld", (long int)LOCAL_ActiveError->prologPredArity);
	  s += // std::to_string(LOCAL_ActiveError->prologPredArity);
	    buf;
	}
      s += " error ";
      if (LOCAL_ActiveError->classAsText != nullptr)
	s += LOCAL_ActiveError->classAsText->StrOfAE;
      s += ".";
      s += LOCAL_ActiveError->errorAsText->StrOfAE;
      s += ".\n";
      if (LOCAL_ActiveError->errorTerm)
	{
	  Term t = LOCAL_ActiveError->errorTerm->Entry;
	  if (t)
	    {
	      s += "error term is: ";
	      s += YAPTerm(t).text();
	      s += "\n";
	    }
	}
      printf("%s\n", s.c_str());
      return s.c_str();
    }

    void YAPEngine::reSet()
    {
      /* ignore flags  for now */
      BACKUP_MACHINE_REGS();
      Yap_RebootHandles(worker_id);
      while (B->cp_b)
	B = B->cp_b;
      P = FAILCODE;
      Yap_exec_absmi(true, YAP_EXEC_ABSMI);
      /* recover stack space */
      HR = B->cp_h;
      TR = B->cp_tr;
#ifdef DEPTH_LIMIT
      DEPTH = B->cp_depth;
#endif /* DEPTH_LIMIT */
      YENV = ENV = B->cp_env;

      RECOVER_MACHINE_REGS();
    }

    YAPError::YAPError(yap_error_number id, YAPTerm culprit, std::string txt)
    {
      ID = id;
      goal = culprit.text();
      info = txt;
    }

    Term  YAPEngine::top_level( std::string s)
    {
      /// parse string s and make term with var names
      /// available.
      Term tp;
      ARG1 = YAP_ReadBuffer(s.data(), &tp);
      ARG2 = tp;
      ARG3 = MkVarTerm();
      YAPPredicate p = YAPPredicate(YAP_TopGoal());
      YAPQuery *Q = new YAPQuery(p,0);
      Term ts[2];
      ts[0]= MkAddressTerm(Q);
      if (Q->next()) {
	ts[1]= ARG3;
      } else {
	ts[1] = TermNil;
      }
      return YAP_MkApplTerm(YAP_MkFunctor(YAP_LookupAtom("t"), 2), 2, ts);
    }

    Term YAPEngine::next_answer(YAPQuery * &Q) {

      /// parse string s and make term with var names
      /// available.
      Term ts[2];
      ts[0]= MkAddressTerm(Q);
      if (Q->next()) {
	ts[1] = ARG3;
      } else {
	ts[1] = TermNil;
      }
      return YAP_MkApplTerm(YAP_MkFunctor(YAP_LookupAtom("t"), 2), 2, ts);
    }