#include "lex.h"
#include "parse.h"
#include "exec.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void set_map_pair(KeyValMap* map, char* key, char* val) {
for (int i = 0; i < map->count; i++) {
        char* key_i = get_from_KeyValMap(map, i)->key;
        if (key_i == NULL) continue;
        if (strcmp(key_i, key) == 0) {
            // TODO: maybe copy instead
            strcpy(
                map->blocks[i / map->block_size][i % map->block_size].val,
                val
            );
            break;
        }
    }
}

MaybeStr get_map_value(KeyValMap* map, char* key) {
    for (int i = 0; i < map->count; i++) {
        char* key_i = get_from_KeyValMap(map, i)->key;
        if (key_i == NULL) continue;
        if (strcmp(key_i, key) == 0) {
            return (MaybeStr){
                .some = true,
                .value = get_from_KeyValMap(map, i)->val
            };
        }
    }
    return (MaybeStr){.some = false};
} 

void unset_map_key(KeyValMap* map, char* key) {
    for (int i = 0; i < map->count; i++) {
        char* key_i = get_from_KeyValMap(map, i)->key;
        if (key_i == NULL) continue;
        if (strcmp(key_i, key) == 0) {
            map->blocks[i / map->block_size][i % map->block_size].key = NULL;
            break;
        }
    }
}



char* get_var(char* varname, ShellState* shstate) {
    MaybeStr maybe_varval = get_map_value(&shstate->shell_vars, varname); 
    if (maybe_varval.some == true) return maybe_varval.value;
    return getenv(varname);
}

typedef struct {
    QuotationMode qmode;  
    char* content;
} ExpandedChunk;


ExpandedChunk expand_chunk(Chunk chunk, ShellState* shstate) {
    char* content;
    if (chunk.qmode == SINGLE_Q || chunk.kind == LITERAL) {
        if (chunk.qmode == SINGLE_Q && chunk.kind != LITERAL) exit(69);
        content = chunk.as.literal_str;
    } else if (chunk.kind == VAR_EXP) {
        content = get_var(chunk.as.varname, shstate);
    } else if (chunk.kind == REGION_EXP) {
        exit(7); // Not supported yet; arithm
    }
    return (ExpandedChunk){.qmode = chunk.qmode, .content = content};
}

DECLARE_VEC(char*, StrVec)


typedef struct {
    StrVec complete_strs;
    String active_str;
} WordSplittingGerm;

void add_expchunk(char* next_str, WordSplittingGerm* curr_res) {
     for (int pos = 0; pos < strlen(next_str); pos++) {
        if (next_str[pos] == ' ') {
            push_to_StrVec(&curr_res->complete_strs, inner(&curr_res->active_str));
            curr_res->active_str = make_String(256);
        } else {
            push_to_String(&curr_res->active_str, next_str[pos]);
        }
    }
}

StrVec expand_word(Word word, ShellState* state) {
    WordSplittingGerm curr_res = {.complete_strs = make_StrVec(256), .active_str = make_String(25)};
    for (int i = 0; i < word.count; i++) {
        Chunk curr_cunk = *get_from_Word(&word, i);
        ExpandedChunk curr_exp = expand_chunk(curr_cunk, state);
        switch (curr_exp.qmode) {
            case UN_Q:
                add_expchunk(curr_exp.content, &curr_res);
                break;
            case SINGLE_Q:
                append_str_to_String(&curr_res.active_str, curr_exp.content);
                break;
            case DOUBLE_Q:
                append_str_to_String(&curr_res.active_str, curr_exp.content);
        }
    }

    if (curr_res.active_str.count > 0) {
        push_to_StrVec(&curr_res.complete_strs, inner(&curr_res.active_str));
    }

    return curr_res.complete_strs;
   
    /*
    char** res_ptr = malloc(sizeof(char*) * curr_res.complete_strs.count);
    for (int j = 0; j < curr_res.complete_strs.count; j++) {
        res_ptr[j] = curr_res.complete_strs.blocks[j / curr_res.complete_strs.block_size][j % curr_res.complete_strs.block_size];
    }
    return res_ptr;
    */
}


void merge_strvecs(StrVec* target, StrVec* source) {
    for (int i = 0; i < source->count; i++) {
        push_to_StrVec(target, *get_from_StrVec(source, i));
    }
}

void command_thing(Command command, ShellState* shstate) {
    StrVec arg_str_vec = make_StrVec(256);
    for (int i = 0; i < command.args.count; i++) {
        Token arg_i = *get_from_TokenVec(&command.args, i);
        StrVec expanded_i;
        switch (arg_i.kind) {
            case TOK_WORD:
                expanded_i = expand_word(arg_i.as.word, shstate);
                merge_strvecs(&arg_str_vec, &expanded_i);
                break;
            default:
                exit(67);
        }
    }
    int argcount = arg_str_vec.count;
    char** arg_str_arr = malloc(sizeof(char*) * argcount);
    for (int j = 0; j < argcount; j++) {
        arg_str_arr[j] = *get_from_StrVec(&arg_str_vec, j);
    }
    for (int k = 0; k < argcount; k++) {
        printf("\t\tArg%d: %s\n", k, arg_str_arr[k]);
    }
}

void run_pipeline(Pipeline pl, ShellState* shstate) {
    for (int i = 0; i < pl.count; i++) {
        printf("\tCommand %d:\n", i);
        command_thing(get_from_Pipeline(&pl, i)->cmd, shstate);
    }
}