#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "p99/p99_id.h"

typedef struct {
    char** n_;
    void*** v_;
    int l;
} closure;

#define LAMBDA__L(t, arg, esc) \
         ({void* t(closure *env_, void* arg) {append_(env_, arg, ""#arg); closure* clos_par = env_; esc;} \
          (void*)t;})

#define function(arg, esc) LAMBDA__L(P99_UNIQ(LAMBDA_FUNCTION_L), arg, esc)
#define eval(func_lambda, x) ((void*(*)(void*, void*)) func_lambda) (env_, x)
#define LAMBDA(x) ({closure* env_ = lambda__(); x;})
#define $(x) s_search(clos_par, ""#x)
#define L_FUNCTION void*

closure* lambda__() {
     closure* env_ = malloc(sizeof(closure));
     env_->n_ = malloc(sizeof(char*));
     env_->v_ = malloc(sizeof(void*[2]));
     env_->l = 0;
    return env_;
}

void append_(closure* closure_, void* arg, char* n) {
    char* s = malloc(sizeof(char*)*100);
    *(closure_->v_ + closure_->l) = malloc(sizeof(void*)*2);
    strncpy(s, n, strlen(n));
    memcpy(*(closure_->v_ + closure_->l), (void*[2]){arg, (void*)s}, sizeof(void*)*2);
    closure_->v_ = realloc(closure_->v_, sizeof(void*[2])*++closure_->l);
    //if (closure_->l >= 10000) {printf("\nLAMBDA FUNCTION: STACKOVERFLOR\n"); exit(EXIT_SUCCESS);}
}

void* s_search(closure* closure__, char* par) {
    int i = 0;
    for (void** p =  *closure__->v_; i <= (closure__->l-1); p++) {
        if (strcmp(par, (char*)*(*(closure__->v_ + i) + 1)) == 0) {
            return **(closure__->v_ + i);
        }
        i++;
    }
  printf("LAMBDA FUNCTION: PARAMETER %s DON'T FOUND\n", par);
  exit(EXIT_SUCCESS);
  return NULL;
}

int main() {
  int* d = malloc(sizeof(int));
  (*d) = 234;
  int* x = malloc(sizeof(int));
  (*x) = 100;

    void* t = function(x, return function(y, return function(_, return eval(eval($(_), $(y)), $(x)););););
    void* first = function(l, return function(e, return $(l);););
    void* f = LAMBDA(
        eval(eval(eval(t, d), x), first);
    );

  return 0;
}