#include "funcs.c"

enum {

  K_NONE = 0,

  K_POPEN,

  K_PCLOSE,

  K_BPOPEN,

  K_BCLOSE,

  K_COMMA,

  K_COLON,

};

const char *baseKeys[] = { "", "(", ")", "[", "]", ",", ":" };

typedef struct Op {

  const OpDesc *desc;

  Var v;

  struct Op *a, *b, *c;

} Op;

void prepareKeys() {

  if (keys) return;

  keys = (const char**)calloc(1, sizeof(baseKeys) + sizeof(char*)*opsCnt);

  if (!keys) { fprintf(stderr, "out of memory\n"); exit(1); }

  memcpy(keys, baseKeys, sizeof(baseKeys));

  keysCnt = sizeof(baseKeys)/sizeof(*baseKeys);

  for(int i = 0; i < opsCnt; ++i) {

    OpDesc *d = &ops[i];

    d->k = 0;

    if (!d->key || !*d->key) continue;

    for(int j = 1; j < keysCnt; ++j)

      if (0 == strcmp(keys[j], d->key)) { d->k = j; break; }

    if (!d->k) {

      d->k = keysCnt;

      keys[keysCnt++] = d->key;

    }

  }

}

Op* opCreate(const OpDesc *d) {

  Op *op = (Op*)calloc(1, sizeof(*op));

  if (!op) { fprintf(stderr, "out of memory\n"); exit(1); }

  op->desc = d;

  return op;

}

void opDestroy(Op *op) {

  if (!op) return;

  opDestroy(op->a);

  opDestroy(op->b);

  opDestroy(op->c);

  free(op);

}

Var opCall(Op *op, U32 t);

Op* opSubItem(Op *op, U32 t, U32 idx) {

  while(op && op->desc) {

    if (op->desc->mode == M_ARRAY) {

      while(op && idx) { op = op->b; --idx; }

      return op ? op->a : op;

    } else

    if (op->desc->mode == M_INDEX) {

      U32 i = asint(opCall(op->b, t));

      op = opSubItem(op->a, t, i);

    } else {

      return op;

    }

  }

  return NULL;

}

Var opCall(Op *op, U32 t) {

  if (!op || !op->desc) return vari(0);

  if (!op->desc->func) {

    if (op->desc->mode == M_INDEX) {

      U32 idx = asint(opCall(op->b, t));

      Op *o = opSubItem(op->a, t, idx);

      return opCall(o, t);

    }

    if (op->desc->mode == M_ARRAY)

      return opCall(op->a, t);

    return op->v;

  }

  Params p = { t, opCall(op->a, t), opCall(op->b, t), opCall(op->c, t) };

  return op->desc->func(p);

}

void opPrint(Op *op, FILE *f, int level) {

  if (!f) f = stdout;

  for(int i = 0; i < level; ++i)

    fprintf(f, "  ");

  if (!op || !op->desc)

    { fprintf(f, "nop\n"); return; }

  if (!op->desc->func && op->desc->mode != M_ARRAY && op->desc->mode != M_INDEX)

    { fprintf(f, "value: %d, %d, %g\n", op->v.type, op->v.u, op->v.f); return; }

  fprintf(f, "%d:%d:%s:\n", op->desc->mode, op->desc->priority, op->desc->key);

  ++level;

  opPrint(op->a, f, level);

  opPrint(op->b, f, level);

  opPrint(op->c, f, level);

}

Op* opParsePart(const Lex **l, int priority);

Op* opParseParentheses(const Lex **p) {

  const Lex *l = *p;

  if (iskey(l++, K_POPEN)) {

    Op *op = opParsePart(&l, INT_MAX);

    if (op && iskey(l++, K_PCLOSE))

      return *p = l, op;

    opDestroy(op);

  }

  return NULL;

}

Op* opParseValue(const Lex **p, const OpDesc *d) {

  const Lex *l = *p;

  if ( d->k ? iskey(l, d->k) : (l->type == LT_INT || l->type == LT_FLOAT) ) {

    Op *op = opCreate(d);

    op->v.type = l->type == LT_FLOAT ? T_F32 : T_U32;

    op->v.u = l->u;

    return *p = l + 1, op;

  }

  return NULL;

}

Op* opParseFunc(const Lex **p, const OpDesc *d) {

  const Lex *l = *p;

  if (iskey(l++, d->k) && iskey(l++, K_POPEN)) {

    Op *sub = opParsePart(&l, INT_MAX);

    if (sub && iskey(l++, K_PCLOSE)) {

      Op *op = opCreate(d);

      op->a = sub;

      return *p = l, op;

    }

    opDestroy(sub);

  }

  return NULL;

}

Op* opParseFunc2(const Lex **p, const OpDesc *d) {

  const Lex *l = *p;

  if (iskey(l++, d->k) && iskey(l++, K_POPEN)) {

    Op *a = opParsePart(&l, INT_MAX);

    if (a && iskey(l++, K_COMMA)) {

      Op *b = opParsePart(&l, INT_MAX);

      if (b && iskey(l++, K_PCLOSE)) {

        Op *op = opCreate(d);

        op->a = a;

        op->b = b;

        return *p = l, op;

      }

      opDestroy(b);

    }

    opDestroy(a);

  }

  return NULL;

}

Op* opParseArray(const Lex **p, const OpDesc *d) {

  const Lex *l = *p;

  if (iskey(l++, d->k)) {

    Op *op = opCreate(d), *o = op;

    while(1) {

      o->a = opParsePart(&l, INT_MAX);

      if (iskey(l, K_BCLOSE)) return *p = l + 1, op;

      if (!iskey(l++, K_COMMA)) break;

      o->b = opCreate(d);

      o = o->b;

    };

    opDestroy(op);

  }

  return NULL;

}

Op* opParseIndex(const Lex **p, Op *a, const OpDesc *d) {

  const Lex *l = *p;

  if (iskey(l++, d->k)) {

    Op *b = opParsePart(&l, INT_MAX);

    if (b && iskey(l++, K_BCLOSE)) {

      Op *op = opCreate(d);

      op->a = a;

      op->b = b;

      return *p = l, op;

    }

    opDestroy(b);

  }

  return NULL;

}

Op* opParsePrefix(const Lex **p, const OpDesc *d) {

  const Lex *l = *p;

  if (iskey(l++, d->k)) {

    Op *sub = opParsePart(&l, d->priority);

    if (sub) {

      Op *op = opCreate(d);

      op->a = sub;

      return *p = l, op;

    }

  }

  return NULL;

}

Op* opParseBinary(const Lex **p, Op *a, const OpDesc *d) {

  const Lex *l = *p;

  if (iskey(l++, d->k)) {

    Op *b = opParsePart(&l, d->priority);

    if (b) {

      Op *op = opCreate(d);

      if (b->desc->priority == d->priority) {

        op->a = a;

        op->b = b->a;

        b->a = op;

        op = b;

      } else {

        op->a = a;

        op->b = b;

      }

      return *p = l, op;

    }

  }

  return NULL;

}

Op* opParseTernary(const Lex **p, Op *a, const OpDesc *d) {

  const Lex *l = *p;

  if (iskey(l++, d->k)) {

    Op *b = opParsePart(&l, d->priority - 1);

    if (b && iskey(l++, K_COLON)) {

      Op *c = opParsePart(&l, d->priority);

      if (c) {

        Op *op = opCreate(d);

        op->a = a;

        op->b = b;

        op->c = c;

        return *p = l, op;

      }

    }

    opDestroy(b);

  }

  return NULL;

}

Op* opParsePart(const Lex **p, int priority) {

  //static int level = 0;

  //printf("opParsePart:%d:%d:", level, priority);

  //lexChainPrint(*p, NULL);

  //printf("\n");

  //++level;

  const Lex *l = *p;

  Op *op = opParseParentheses(&l);

  for(int i = 0; i < opsCnt; ++i) {

    //printf("  i = %d\n", i);

    const OpDesc *d = &ops[i];

    if (d->priority > priority) break;

    switch(d->mode) {

    case M_VALUE:

      if (!op) op = opParseValue(&l, d);

      break;

    case M_FUNC:

      if (!op) op = opParseFunc(&l, d);

      break;

    case M_FUNC2:

      if (!op) op = opParseFunc2(&l, d);

      break;

    case M_ARRAY:

      if (!op) op = opParseArray(&l, d);

      break;

    case M_INDEX:

      if (op) {

        Op *o = opParseIndex(&l, op, d);

        if (o) { op = o; i = 0; }

      }

      break;

    case M_PREFIX:

      if (!op) op = opParsePrefix(&l, d);

      break;

    case M_BINARY:

      if (op) {

        Op *o = opParseBinary(&l, op, d);

        if (o) { op = o; i = 0; }

      }

      break;

    case M_TERNARY:

      if (op) {

        Op *o = opParseTernary(&l, op, d);

        if (o) { op = o; i = 0; }

      }

      break;

    }

  }

  if (op) *p = l;

  //--level;

  return op;

}

Op* opParse(const Lex *l) {

  Op *op = opParsePart(&l, INT_MAX);

  if (!op || l->type != LT_NONE)

    { fprintf(stderr, "parse error at: "); lexChainPrint(l, stderr); fprintf(stderr, "\n"); }

  return op;

}