#include "main.h"
#include <sstream>

#ifdef __linux__

#include <cstring>

#endif


template<class T, size_t N>
constexpr size_t size(T (&)[N]) { return N; }


extern "C" {


CLAPI void*
init_aug(augSettings settings, int flags) {
    CHECK_RET_NULLPTR(!path_exists(std::string(settings.root)), "Root path is invalid.");
    return aug_init(settings.root, settings.loadPath, flags);
}

CLAPI void
close_aug(void *aug) {
    CHECK_RET_VOID(!aug, "Failed to close augeas.");
    aug_close((augeas *) aug);
}

CLAPI bool
load_file(void *aug, const char *filePath) {
    CHECK_RET_BOOL(!aug, INVALID_STATE);
    int r = aug_load_file((augeas *) aug, filePath);
    return r == 0;
}

CLAPI void
print_preview(augeas *aug, const char *path) {
    CHECK_RET_VOID(!aug, "Augeas is in invalid state");
    int r;
    char *s;
    r = aug_preview(aug, path, &s);
    CHECK_RET_VOID(r != 0, "Failed to preview.")
    std::cout << s << std::endl;
    free(s);
}

CLAPI int rm_node(augeas *aug, const char *path) {
    CHECK_RET_INT(!aug, INVALID_STATE);
    return aug_rm(aug, path);
}



CLAPI char*
get_preview(augeas *aug, const char *path) {

    CHECK_RET_NULLPTR(!aug, INVALID_STATE);
    int r;
    char *s;

    r = aug_preview(aug, path, &s);

    if (r != 0) {
        std::cout << "Failure previewing." << std::endl;
        return nullptr;
    }

    // must be freed
    return s;
}


// Print tree of the path
CLAPI void print_tree(
        augeas *aug,
        const char *path
) {

    CHECK_RET_VOID(!aug, INVALID_STATE);

    int r;

    FILE *out = tmpfile();

    r = aug_print(aug, out, path);

    if (r != 0) {
        std::cout << "error: aug_print failure." << std::endl;
        return;
    }

    std::map<std::string, std::string> stdBindList;
    std::map<std::string, std::string>::iterator pos;

    char line[256];
    rewind(out);
    while (fgets(line, 256, out) != nullptr) {
        // remove end of line
        line[strlen(line) - 1] = '\0';
        std::string str_path = path;
        std::string s = line;
        // skip comments
        if (s.find("#comment") != std::string::npos)
            continue;
        s = s.substr(str_path.length() - 1);
        // split by '=' sign
        size_t eqpos = s.find(" = ");
        if (eqpos == std::string::npos)
            continue;
        // extract key and value
        std::string key = s.substr(0, eqpos);
        std::string value = s.substr(eqpos + 3);
        // remove '"' sign from around value
        value.erase(value.begin());
        value.erase(value.end() - 1);
        stdBindList.insert(std::pair<std::string, std::string>(key, value)); // 2

    }

    fclose(out);

    for (pos = stdBindList.begin(); pos != stdBindList.end(); pos++) {
        std::cout << "Key: " << pos->first << ";" << " Value: " << pos->second << std::endl;
    }

}
CLAPI char *get_tree(
        augeas *aug,
        const char *path
) {

    CHECK_RET_NULLPTR(!aug, INVALID_STATE);

    int r;

    FILE *out = tmpfile();

    r = aug_print(aug, out, path);

    if (r != 0) {
        std::cout << "error: aug_print failure." << std::endl;
        return nullptr;
    }

    std::map<std::string, std::string>::iterator pos;

    std::stringstream ss;

    char line[256];
    rewind(out);
    while (fgets(line, 256, out) != nullptr) {
        // remove end of line
        line[strlen(line) - 1] = '\0';
        std::string str_path = path;
        std::string s = line;
        // skip comments
        if (s.find("#comment") != std::string::npos)
            continue;
        s = s.substr(str_path.length() - 1);
        // split by '=' sign
        size_t eqpos = s.find(" = ");
        if (eqpos == std::string::npos)
            continue;
        // extract key and value
        std::string key = s.substr(0, eqpos);
        std::string value = s.substr(eqpos + 3);

        // remove '"' sign from around value
        value.erase(value.begin());
        value.erase(value.end() - 1);

        ss << ";K;" << key << ";VAL;" << value << ";ENDL;";
    }

    fclose(out);
    return strdup(ss.str().c_str());
}

CLAPI void free_str(char *str) {
    if (str != nullptr) {
        free(str);
    }
}

CLAPI bool save(augeas *aug) {
    CHECK_RET_BOOL(!aug, INVALID_STATE);
    return aug_save(aug) == 0;
}

CLAPI void get_arr( unsigned long &size, char** result)
{

}

CLAPI int match(augeas *aug, const char *match_path, char*** matches) {
    CHECK_RET_INT(!aug, INVALID_STATE);
    return aug_match(aug, match_path, matches);
}



CLAPI const char *get_node(augeas *aug, const char *path) {

    const char *value;

    CHECK_RET_NULLPTR(!aug, INVALID_STATE);
    /*
     * Return 1 if there is exactly one node matching PATH,
     * 0 if there is none, and a negative value
     * if there is more than one node matching PATH,
     * or if PATH is not a legal path expression.
     *
     * The string *value must not be freed by the caller,
     * and is valid as long as its node remains unchanged.
     */

    aug_get(aug, path, &value);
    return value;
}

CLAPI bool set_node(augeas *aug, const char *path, const char *value) {
    CHECK_RET_BOOL(!aug, INVALID_STATE);
    return aug_set(aug, path, value) == 0;
}

CLAPI bool insert_node(augeas *aug, const char *path, const char *label, int before) {
    CHECK_RET_BOOL(!aug, INVALID_STATE);
    return aug_insert(aug, path, label, before) == 0;
}

}