#include <assert.h>

#include <debug.h>

#include <string/new.h>
#include <string/free.h>

#include <stringtree/println.h>
#include <stringtree/free.h>

#include <parse/position/struct.h>
#include <parse/position/new.h>
#include <parse/position/free.h>

#include <istream/string/new.h>
#include <istream/file/new.h>
#include <istream/read.h>
#include <istream/free.h>

#include <wcistream/istream/new.h>
#include <wcistream/read.h>
#include <wcistream/free.h>

#include <parse/token/struct.h>

#include <parse/tokenizer/struct.h>
#include <parse/tokenizer/new.h>
#include <parse/tokenizer/next.h>
#include <parse/tokenizer/free.h>

#include <parse/parse.h>

#include <wcostream/ostream/new.h>
#include <wcostream/free.h>

#include <ostream/file/new.h>
#include <ostream/free.h>

#include <statement/prettyprint.h>

#include <statement/execute.h>
#include <statement/prettyprint_errors.h>
#include <statement/free.h>

#include "handle_string.h"

void handle_string(
    struct environment** environment,
    struct booleans* booleans,
    const char* input_string,
    bool echo,
    bool print_with_colors,
    struct wcostream* wc_stdout)
{
    ENTER;
    
    assert(input_string);
    
    struct istream* stream = new_string_istream(
        /* read-only text: */ (const uint8_t*) input_string);
    
    struct wcistream* wcstream = new_istream_wcistream(
        /* binary stream: */ stream);
    
    struct string* filename = new_string(
        /* data: */ L"<command-line>",
        /* len: */ (size_t) -1);
    
    struct position* position = new_position(
        /* filename: */ filename,
        /* line number: */ 1,
        /* column: */ 1);
    
    struct tokenizer* tokenizer = new_tokenizer(
        /* stream: */ wcstream,
        /* inital position (mutated): */ position);
    
    istream_read(stream);
    
    wcistream_read(wcstream);
    
    tokenizer_next(tokenizer);
    
    if (tokenizer->token->kind == tk_EOF)
    {
        // error: empty file
        TODO;
    }
    
    while (tokenizer->token->kind != tk_EOF)
    {
        struct statement* statement = parse(
            /* tokenizer: */ tokenizer);
        
        struct stringtree* error_messages =
            statement_prettyprint_errors(statement);
        
        if (error_messages)
        {
            // print one (or more) error expressions
            TODO;
            
            // exit(1);
            TODO;
        }
        
        if (echo)
        {
            struct stringtree* stree = statement_prettyprint(
                /* chosen color reference: */ NULL,
                /* instance: */ statement,
                /* print with color? */ print_with_colors);
            
            stringtree_println(stree, wc_stdout);
            
            free_stringtree(stree);
        }
        
        statement_execute(
            /* instance: */ statement,
            /* environment: */ environment,
            /* booleans: */ booleans,
            /* wide-character stdout: */ wc_stdout,
            /* print value: */ true,
            /* print with color?: */ print_with_colors);
        
        while (tokenizer->token->kind == tk_newline)
        {
            tokenizer_next(tokenizer);
        }
        
        free_stringtree(error_messages);
        
        free_statement(statement);
    }
    
    free_tokenizer(tokenizer);
    
    free_position(position);
    
    free_string(filename);
    
    free_wcistream(wcstream);
    
    free_istream(stream);
    
    EXIT;
}