#include "env.h"
#include "pebblisp.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#ifndef STANDALONE
#include <pebble.h>
#undef printf
#define printf(...) APP_LOG(APP_LOG_LEVEL_DEBUG, __VA_ARGS__)
#endif

Object fetchFromEnvironment(const char *name, struct Environment *env)
{
    if(!env)
        return errorObject(NULL_ENV);

    if(env->size == 0)
        return errorObject(EMPTY_ENV);

    printd("Fetching '%s' from env\n", name);
    // printEnv(env);
    for(int i = 0; i < env->size; i++) {
        printd("Try %d\n", i);
        if(env->strings[i] == NULL)
            break;
        if(strcmp(name, env->strings[i]) == 0) {
            return env->objects[i];
        }
    }

    printd("Trying outer %p\n", env->outer);
    if(env->outer) {
        // printEnv(env->outer);
        return fetchFromEnvironment(name, env->outer);
    }

    return errorObject(DID_NOT_FIND_SYMBOL);
}

struct Environment envForLambda(const Object *params, const Object *arg_forms,
                                struct Environment *outer)
{
    int paramCount = listLength(params);

    struct Environment env = {
        .outer = outer,
        .strings = NULL,
        .objects = NULL,
        .size = paramCount
    };

    if(paramCount == 0)
        return env;

    env.strings = calloc(sizeof(char*), paramCount + 1);
    env.objects = malloc(sizeof(Object) * paramCount + 1);

    const Object *march = arg_forms;
    for(int i = 0; i < paramCount; i++) {
        const char *newObjName = itemAt(params, i)->name;
        const Object newEnvObj = eval(march, outer);
        addToEnv(&env, newObjName, newEnvObj); // Could use eval_forms?
        march = march->forward;
    }

    return env;
}

// todo could include and return a starting index for faster multi-adds
// Maybe extend existing environment using a malloc'd outer, instead of realloc
void addToEnv(struct Environment *env, const char *name, const Object obj)
{
    int i;
    for(i = 0; i < env->size ; i++) {
        if(env->strings[i] == NULL) {
            env->strings[i] = calloc(sizeof(char), strlen(name) + 1);
            strncpy(env->strings[i], name, strlen(name));
            env->objects[i] = obj;
            // if(obj.type == TYPE_LIST)
            //     copyList(&env->objects[i], &obj);
            return;
        }
        if(strcmp(env->strings[i], name) == 0) {
            cleanObject(&env->objects[i]);
            env->objects[i] = obj;
            // if(obj.type == TYPE_LIST)
            //     copyList(&env->objects[i], &obj);
            return;
        }
    }

    printd("Reallocating environment\n");
    const int inc = 5;
    env->size += inc;
    env->strings = realloc(env->strings, sizeof(char*) * env->size);
    env->objects = realloc(env->objects, sizeof(Object) * env->size);

    for(int j = 0; j < inc; j++) {
        env->strings[i + j] = NULL;
    }

    env->strings[i] = malloc(strlen(name) + 1);
    strncpy(env->strings[i], name, strlen(name) + 1);
    env->objects[i] = obj;
}

void printEnv(struct Environment *env)
{
    if(!env) {
        printf("NULL env\n");
        return;
    }
    for(int i = 0; i < env->size; i++) {
        if(env->strings[i] == NULL)
            return;
        printf("env[%d]: '%s'\n  ", i, env->strings[i]);
        printObj(&env->objects[i]);
    }
}

void addFunc(const char *name, Object (*func)(Object, Object, struct Environment*),
             struct Environment *env)
{
    Object o = newObject(TYPE_FUNC);
    o.func = func;
    addToEnv(env, name, o);
}

void deleteEnv(struct Environment *e)
{
    int i = 0;
    while(e->strings[i]) {
        free(e->strings[i]);
        cleanObject(&e->objects[i]);
        i++;
    }
    free(e->strings);
    e->strings = NULL;

    free(e->objects);
    e->objects = NULL;
}

const char *codes[] = {
    // Exponentiate a^b
    "(def exp (fn (a b) "
      "(if (= b 0)"
        "1"
        "(* a (exp a (- b 1)))"
      ")"
    "))",

    // Square a
    "(def sq (fn (a) (exp a 2)))",

    // Cube a
    "(def cube (fn (a) (exp a 3)))",

    // Return the larger of the two
    "(def max (fn (a b) (if (> a b) a b)))",

    // Return the smaller of the two
    "(def min (fn (a b) (if (< a b) a b)))",

    // Arbitrary recursion tester
    "(def ad (fn (a) (if (> a 10) a (ad (* 10 a) ))))",

    // A demo tip calculator
    "(def spent (fn (a) \
      (cat \"Tip: $\" \"\" \"\" (/ a 5) \".\" \
        (/ (* 100 (% a 5)) 5) \
      ) \
     ))",

    NULL
};

struct Environment defaultEnv()
{
    struct Environment e;
    e.outer = NULL;
    e.strings = calloc(sizeof(char*), MAX_ENV_ELM);
    e.objects = malloc(sizeof(Object) * MAX_ENV_ELM);
    e.size = MAX_ENV_ELM;

    addFunc("+", &add, &e);
    addFunc("-", &sub, &e);
    addFunc("*", &mul, &e);
    addFunc("/", &dvi, &e);
    addFunc("%", &mod, &e);
    addFunc("=", &equ, &e);
    addFunc(">", &gth, &e);
    addFunc("<", &lth, &e);
    addFunc("len", &len, &e);
    addFunc("cat", &catObjects, &e);

    int i = 0;
    while(codes[i]) {
        parseEval(codes[i++], &e);
    }

    return e;
}