#pragma once

#include "gp/containers/array.hpp"
#include "gp/containers/vector.hpp"
#include "gp/text/ascii.hpp"

using string = gp::vector<char>;

#define FOREACH_LEXEME_TYPE \
    LEX(leftBracket) \
    LEX(rightBracket) \
    LEX(leftParenthesis) \
    LEX(rightParenthesis) \
    LEX(leftCurlyBrace) \
    LEX(rightCurlyBrace) \
    LEX(period) \
    LEX(semicolon) \
    LEX(colon) \
    LEX(doubleColon) \
    LEX(comma) \
    LEX(at) \
    LEX(pointer) \
    LEX(as) \
    LEX(try_) \
    LEX(catch_) \
    LEX(raise_) \
    LEX(defer) \
    LEX(assign) \
    LEX(addAssign) \
    LEX(substractAssign) \
    LEX(multiplyAssign) \
    LEX(divideAssign) \
    LEX(concatenateAssign) \
    LEX(remainderAssign) \
    LEX(powerAssign) \
    LEX(plus) \
    LEX(minus) \
    LEX(add) \
    LEX(substract) \
    LEX(multiply) \
    LEX(divide) \
    LEX(concatenate) \
    LEX(remainder) \
    LEX(power) \
    LEX(equal) \
    LEX(doubleEqual) \
    LEX(threeWayComparison) \
    LEX(notEqual) \
    LEX(greaterOrEqual) \
    LEX(greater) \
    LEX(lesserOrEqual) \
    LEX(lesser) \
    LEX(leftShift) \
    LEX(rightShift) \
    LEX(and_) \
    LEX(or_) \
    LEX(xor_) \
    LEX(not_) \
    LEX(increment) \
    LEX(decrement) \
    LEX(identifier) \
    LEX(integer) \
    LEX(float_) \
    LEX(boolean) \
    LEX(string_) \
    LEX(null_) \
    LEX(public_) \
    LEX(main_) \
    LEX(type_) \
    LEX(event_) \
    LEX(class_) \
    LEX(enum_) \
    LEX(template_) \
    LEX(new_) \
    LEX(copy) \
    LEX(send) \
    LEX(receive) \
    LEX(intType) \
    LEX(floatType) \
    LEX(boolType) \
    LEX(stringType) \
    LEX(arrayType) \
    LEX(functionType) \
    LEX(taskType) \
    LEX(chanType) \
    LEX(autoType) \
    LEX(if_) \
    LEX(unless) \
    LEX(else_) \
    LEX(switch_) \
    LEX(select) \
    LEX(case_) \
    LEX(while_) \
    LEX(do_) \
    LEX(until) \
    LEX(for_) \
    LEX(loop) \
    LEX(return_) \
    LEX(self) \
    LEX(kill) \
    LEX(killAll) \
    LEX(yield) \
    LEX(break_) \
    LEX(continue_)

#define LEX(x) x,
enum class gr_lexeme_type {
    FOREACH_LEXEME_TYPE
};
#undef LEX

#define LEX(x) case gr_lexeme_type::x: return #x;
constexpr inline const char* to_string(const gr_lexeme_type& value) {
    switch(value) {
        FOREACH_LEXEME_TYPE
    }
}
#undef LEX

#define LEX(x) +1
constexpr inline const char* to_pretty_string(const gr_lexeme_type& value) {
    constexpr gp::array<const char*, 0 + FOREACH_LEXEME_TYPE> names = {
        "[", "]", "(", ")", "{", "}", ".", ";", ":", "::", ",", "@", "&", "as",
        "try", "catch", "raise", "defer", "=", "+=", "-=", "*=", "/=", "~=",
        "%=", "^=", "+", "-", "+", "-", "*", "/", "~", "%", "^", "==", "===",
        "<=>", "!=", ">=", ">", "<=", "<", "<<", ">>", "and", "or", "xor", "not", "++",
        "--", "identifier", "const_int", "const_float", "const_bool",
        "const_str", "null", "pub", "main", "type", "event", "class", "enum",
        "template", "new", "copy", "send", "receive", "int", "float", "bool",
        "string", "array", "func", "task", "chan", "let", "if", "unless",
        "else", "switch", "select", "case", "while", "do", "until", "for", "loop",
        "return", "self", "kill", "killall", "yield", "break", "continue"
    };
    return names[(size_t)value];
}
#undef LEX

struct gr_lexeme;

class gr_lexer {
public:
    using file_loader_t = gp::function<gp::vector<char>(const gp::vector<char>&)>;
    gp::allocator& _allocator;
    file_loader_t file_loader;
private:
    gp::vector<string> _files_to_import, _files_imported, _lines;

    string _file, _text;
    uint64_t _line, _current, _position_of_line, _file_id;

    gp::vector<gr_lexeme> _lexemes;

    char get(ssize_t offset = 0);
    bool advance(bool start_from_current = false);
    void scan_script();
    void scan_number();
    void scan_string();
    void scan_operator();
    void scan_word();
    void scan_file_path();
    void scan_use();
    string convert_path_to_import(string&);

public:

    gr_lexer(gp::allocator& alloc, file_loader_t& loader)
    : _allocator(alloc)
    , file_loader(loader)
    , _files_to_import(_allocator)
    , _files_imported(_allocator)
    , _lines(_allocator)
    , _file(_allocator)
    , _text(_allocator)
    , _lexemes(_allocator)
    {}

    const gp::vector<gr_lexeme>& lexemes() {
        return _lexemes;
    }

    void scan_file(gp::vector<char>& file_name);

    const string& get_line(const gr_lexeme&) const;
    const string& get_file(const gr_lexeme&) const;
    const string& get_file(const size_t&) const;
};

struct gr_lexeme {
    const gr_lexer& lexer;
    size_t _file_id;
    size_t _line, _column, _text_length = 1;
    
    gr_lexeme_type type;
    bool 
        is_literal,
        is_operator,
        is_keyword,
        is_type;
    int ivalue;
    float fvalue;
    bool bvalue;
    string svalue;

    gr_lexeme(const gr_lexer& v)
    : lexer(v)
    , svalue(v._allocator)
    {}

    const string& get_line() const {
        return lexer.get_line(*this);
    }

    const string& get_file() {
        return lexer.get_file(*this);
    }
};

inline char gr_lexer::get(ssize_t offset) {
    const uint position = ssize_t(_current) + offset;
    gp_config::assertion(!(position < 0 || position >= _text.size()), "Unexpected end of script");
    return _text[position];
}

inline const string& gr_lexer::get_line(const gr_lexeme& lex) const {
    gp_config::assertion(!(lex._file_id >= _files_imported.size()), "Lexeme file id out of bounds");
    // TODO: Implement this
    return _files_imported[lex._file_id];
}

inline const string& gr_lexer::get_file(const gr_lexeme& lex) const {
    gp_config::assertion(!(lex._file_id >= _files_imported.size()), "Lexeme file id out of bounds");
    return _files_imported[lex._file_id];
}

inline const string& gr_lexer::get_file(const size_t& file_id) const {
    gp_config::assertion(!(file_id >= _files_imported.size()), "File id out of bounds");
    return _files_imported[file_id];
}

inline bool gr_lexer::advance(bool start_from_current) {
    if(!start_from_current) {
        _current++;
    }

    if(_current >= _text.size()) {
        return false;
    }

    char symbol = _text[_current];

    whileLoop: while(symbol <= 0x20 || symbol == '/' || symbol == '#') {
        if(_current >= _text.size()) {
            return false;
        }

        symbol = _text[_current];

        if(symbol == '\n') {
            _position_of_line = _current;
            _line++;
        }
        else if(symbol == '#')
        {
            do {
                if(_current >= _text.size()) return false;
                _current++;
            } while (_text[_current] != '\n');
            _position_of_line = _current;
            _line++;
        }
        else if(symbol == '/')
        {
            if((_current + 1) >= _text.size()) {
                return false;
            }

            switch(_text[_current + 1]) {
                case '/': {
                    do {
                        if(_current >= _text.size()) {
                            return false;
                        }
                    } while(_current < _text.size() && _text[_current] != '\n');
                    _position_of_line = _current;
                    _line++;
                }break;
                case '*': {
                    for(;;) {
                        if((_current + 1) >= _text.size()) {
                            _current++;
                            return false;
                        }

                        if(_text[_current] == '\n') {
                            _position_of_line = _current;
                            _line++;
                        }

                        if(_text[_current] == '*' && _text[_current + 1] == '/') {
                            _current++;
                            break;
                        }
                        
                        _current++;
                    }
                }break;
                default:
                    // Goto honorable
                    goto whileLoop;
            }
        }

        _current++;

        if(_current >= _text.size()) {
            return false;
        }

        symbol = _text[_current];
    }
    return true;
}

inline void gr_lexer::scan_script() {
    advance(true);

    constexpr static auto is_operator = [](char v) {
        if(v == '!') return true;
        if(v >= '#' && v <='&') return true;
        if(v >= '(' && v <='-') return true;
        if(v == '/') return true;
        if(v >= ':' && v <='@') return true;
        if(v >= '[' && v <='^') return true;
        if(v >= '{' && v <='~') return true;
        return false;
    };

    do {
        if (_current >= _text.size())
            break;
        auto c = get();
        if(is_digit(c)) scan_number();
        else if(c ==  '.') {
            if (get(1) >= '0' && get(1) <= '9') 
                scan_number();
            else
                scan_operator();
        }
        else if(is_operator(c)) scan_operator();
        else if(c == '\"') scan_string();
        else scan_word();
    }while (advance());
}

inline void gr_lexer::scan_number(){
    gr_lexeme lex = gr_lexeme(*this);
    lex.is_literal = true;

    bool isFloat;
    string buffer(_allocator);
    for (;;) {
        char symbol = get();

        if (symbol >= '0' && symbol <= '9')
            buffer.push_back(symbol);
        else if (symbol == '_') {
            // Do nothing, only cosmetic (e.g. 1_000_000).
        }
        else if (symbol == '.') {
            if (isFloat)
                break;
            isFloat = true;
            buffer.push_back(symbol);
        }
        else if (symbol == 'f') {
            isFloat = true;
            break;
        }
        else {
            if (_current)
                _current--;
            break;
        }

        _current++;

        if (_current >= _text.size())
            break;
    }
}

inline void gr_lexer::scan_string(){
    gr_lexeme lex = gr_lexeme(*this);
    lex.type = gr_lexeme_type::string_;
    lex.is_literal = true;

    gp_config::assertion(get() != '\"',"Expected \'\"\' at the beginning of the string.");
    _current++;

    string buffer(_allocator);
    bool escape = false;
    bool wasEscape = false;
    for (;;) {
        gp_config::assertion(_current >= _text.size(),"Missing \'\"\' character.");
        char symbol = get();

        if (symbol == '\n') {
            _position_of_line = _current;
            _line++;
        }
        else if (symbol == '\"' && (!wasEscape))
            break;
        else if (symbol == '\\' && (!wasEscape)) {
            escape = true;
        }

        if (!escape) {
            if (!wasEscape) {
                    buffer.push_back(symbol);
            }
            else {
                if (symbol == 'n')
                    buffer.push_back('\n');
                else
                    buffer.push_back(symbol);
            }
        }
        wasEscape = escape;
        escape = false;

        _current++;
    }

    lex._text_length = size_t(buffer.size() + 2u);
    lex.svalue = buffer;
    _lexemes.push_back(lex);
}

inline void gr_lexer::scan_operator(){
    gr_lexeme lex = gr_lexeme(*this);
    lex.is_operator = true;

    switch (get()) {
    case '{':
        lex.type = gr_lexeme_type::leftCurlyBrace;
        break;
    case '}':
        lex.type = gr_lexeme_type::rightCurlyBrace;
        break;
    case '(':
        lex.type = gr_lexeme_type::leftParenthesis;
        break;
    case ')':
        lex.type = gr_lexeme_type::rightParenthesis;
        break;
    case '[':
        lex.type = gr_lexeme_type::leftBracket;
        break;
    case ']':
        lex.type = gr_lexeme_type::rightBracket;
        break;
    case '.':
        lex.type = gr_lexeme_type::period;
        break;
    case ';':
        lex.type = gr_lexeme_type::semicolon;
        break;
    case ':':
        lex.type = gr_lexeme_type::colon;
        if (_current + 1 >= _text.size())
            break;
        if (get(1) == ':') {
            lex.type = gr_lexeme_type::doubleColon;
            lex._text_length = 2;
            _current++;
        }
        break;
    case ',':
        lex.type = gr_lexeme_type::comma;
        break;
    case '^':
        lex.type = gr_lexeme_type::power;
        if (_current + 1 >= _text.size())
            break;
        if (get(1) == '=') {
            lex.type = gr_lexeme_type::powerAssign;
            lex._text_length = 2;
            _current++;
        }
        break;
    case '@':
        lex.type = gr_lexeme_type::at;
        break;
    case '&':
        lex.type = gr_lexeme_type::pointer;
        break;
    case '~':
        lex.type = gr_lexeme_type::concatenate;
        if (_current + 1 >= _text.size())
            break;
        if (get(1) == '=') {
            lex.type = gr_lexeme_type::concatenateAssign;
            lex._text_length = 2;
            _current++;
        }
        break;
    case '+':
        lex.type = gr_lexeme_type::add;
        if (_current + 1 >= _text.size())
            break;
        switch (get(1)) {
        case '=':
            lex.type = gr_lexeme_type::addAssign;
            lex._text_length = 2;
            _current++;
            break;
        case '+':
            lex.type = gr_lexeme_type::increment;
            lex._text_length = 2;
            _current++;
            break;
        default:
            break;
        }
        break;
    case '-':
        lex.type = gr_lexeme_type::substract;
        if (_current + 1 >= _text.size())
            break;
        switch (get(1)) {
        case '=':
            lex.type = gr_lexeme_type::substractAssign;
            lex._text_length = 2;
            _current++;
            break;
        case '-':
            lex.type = gr_lexeme_type::decrement;
            lex._text_length = 2;
            _current++;
            break;
        default:
            break;
        }
        break;
    case '*':
        lex.type = gr_lexeme_type::multiply;
        if (_current + 1 >= _text.size())
            break;
        if (get(1) == '=') {
            lex.type = gr_lexeme_type::multiplyAssign;
            lex._text_length = 2;
            _current++;
        }
        break;
    case '/':
        lex.type = gr_lexeme_type::divide;
        if (_current + 1 >= _text.size())
            break;
        if (get(1) == '=') {
            lex.type = gr_lexeme_type::divideAssign;
            lex._text_length = 2;
            _current++;
        }
        break;
    case '%':
        lex.type = gr_lexeme_type::remainder;
        if (_current + 1 >= _text.size())
            break;
        if (get(1) == '=') {
            lex.type = gr_lexeme_type::remainderAssign;
            lex._text_length = 2;
            _current++;
        }
        break;
    case '=':
        lex.type = gr_lexeme_type::assign;
        if (_current + 1 >= _text.size())
            break;
        if (get(1) == '=') {
            lex.type = gr_lexeme_type::equal;
            lex._text_length = 2;
            _current++;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '=') {
                lex.type = gr_lexeme_type::doubleEqual;
                lex._text_length = 3;
                _current++;
            }
        }
        break;
    case '<':
        lex.type = gr_lexeme_type::lesser;
        if (_current + 1 >= _text.size())
            break;
        if (get(1) == '=') {
            lex.type = gr_lexeme_type::lesserOrEqual;
            lex._text_length = 2;
            _current++;
            if (_current + 1 >= _text.size())
                break;
            if (get(1) == '>') {
                lex.type = gr_lexeme_type::threeWayComparison;
                lex._text_length = 3;
                _current++;
            }
        }
        else if (get(1) == '-') {
            lex.type = gr_lexeme_type::send;
            lex._text_length = 2;
            _current++;
        }
        else if (get(1) == '<') {
            lex.type = gr_lexeme_type::leftShift;
            lex._text_length = 2;
            _current++;
        }
        break;
    case '>':
        lex.type = gr_lexeme_type::greater;
        if (_current + 1 >= _text.size())
            break;
        if (get(1) == '=') {
            lex.type = gr_lexeme_type::greaterOrEqual;
            lex._text_length = 2;
            _current++;
        }
        else if (get(1) == '>') {
            lex.type = gr_lexeme_type::rightShift;
            lex._text_length = 2;
            _current++;
        }
        break;
    case '!':
        lex.type = gr_lexeme_type::not_;
        if (_current + 1 >= _text.size())
            break;
        if (get(1) == '=') {
            lex.type = gr_lexeme_type::notEqual;
            lex._text_length = 2;
            _current++;
        }
        break;
    default:
        gp_config::assertion(false, "GrLexer: invalid operator");
    }

    _lexemes.push_back(lex);
}

namespace _hidden {
    bool operator==(const gp::vector<char>& lhs, const char* rhs) {
        for(size_t index = 0; index < lhs.size() && rhs[index] != 0; index++){
            if(lhs[index] != rhs[index]) return false;
        }
        return true;
    }
}

inline void gr_lexer::scan_word(){
    gr_lexeme lex = gr_lexeme(*this);
    lex.is_keyword = true;

    string symbol_buffer(_allocator);
    for (;;) {
        if (_current >= _text.size())
            break;

        char symbol = get();
        if (symbol == '!' || symbol == '?') {
            symbol_buffer.push_back(symbol);
            _current++;
            break;
        }
        if (symbol <= '&' || (symbol >= '(' && symbol <= '/') || (symbol >= ':'
                && symbol <= '@') || (symbol >= '[' && symbol <= '^')
                || (symbol >= '{' && symbol <= 0x7F))
            break;

        symbol_buffer.push_back(symbol);
        _current++;
    }
    _current--;

    lex._text_length = symbol_buffer.size();

    using namespace _hidden;

    if(symbol_buffer == "use"){
        scan_use();
        return;
    }
    else if(symbol_buffer == "pub"){
        lex.type = gr_lexeme_type::public_;
    }
    else if(symbol_buffer == "main"){
        lex.type = gr_lexeme_type::main_;
    }
    else if(symbol_buffer == "type"){
        lex.type = gr_lexeme_type::type_;
    }
    else if(symbol_buffer == "event"){
        lex.type = gr_lexeme_type::event_;
    }
    else if(symbol_buffer == "class"){
        lex.type = gr_lexeme_type::class_;
    }
    else if(symbol_buffer == "enum"){
        lex.type = gr_lexeme_type::enum_;
    }
    else if(symbol_buffer == "template"){
        lex.type = gr_lexeme_type::template_;
    }
    else if(symbol_buffer == "if"){
        lex.type = gr_lexeme_type::if_;
    }
    else if(symbol_buffer == "unless"){
        lex.type = gr_lexeme_type::unless;
    }
    else if(symbol_buffer == "else"){
        lex.type = gr_lexeme_type::else_;
    }
    else if(symbol_buffer == "switch"){
        lex.type = gr_lexeme_type::switch_;
    }
    else if(symbol_buffer == "select"){
        lex.type = gr_lexeme_type::select;
    }
    else if(symbol_buffer == "case"){
        lex.type = gr_lexeme_type::case_;
    }
    else if(symbol_buffer == "while"){
        lex.type = gr_lexeme_type::while_;
    }
    else if(symbol_buffer == "do"){
        lex.type = gr_lexeme_type::do_;
    }
    else if(symbol_buffer == "until"){
        lex.type = gr_lexeme_type::until;
    }
    else if(symbol_buffer == "for"){
        lex.type = gr_lexeme_type::for_;
    }
    else if(symbol_buffer == "loop"){
        lex.type = gr_lexeme_type::loop;
    }
    else if(symbol_buffer == "return"){
        lex.type = gr_lexeme_type::return_;
    }
    else if(symbol_buffer == "self"){
        lex.type = gr_lexeme_type::self;
    }
    else if(symbol_buffer == "kill"){
        lex.type = gr_lexeme_type::kill;
    }
    else if(symbol_buffer == "killall"){
        lex.type = gr_lexeme_type::killAll;
    }
    else if(symbol_buffer == "yield"){
        lex.type = gr_lexeme_type::yield;
    }
    else if(symbol_buffer == "break"){
        lex.type = gr_lexeme_type::break_;
    }
    else if(symbol_buffer == "continue"){
        lex.type = gr_lexeme_type::continue_;
    }
    else if(symbol_buffer == "as"){
        lex.type = gr_lexeme_type::as;
    }
    else if(symbol_buffer == "try"){
        lex.type = gr_lexeme_type::try_;
    }
    else if(symbol_buffer == "catch"){
        lex.type = gr_lexeme_type::catch_;
    }
    else if(symbol_buffer == "raise"){
        lex.type = gr_lexeme_type::raise_;
    }
    else if(symbol_buffer == "defer"){
        lex.type = gr_lexeme_type::defer;
    }
    else if(symbol_buffer == "task"){
        lex.type = gr_lexeme_type::taskType;
        lex.is_type = true;
    }
    else if(symbol_buffer == "func"){
        lex.type = gr_lexeme_type::functionType;
        lex.is_type = true;
    }
    else if(symbol_buffer == "int"){
        lex.type = gr_lexeme_type::intType;
        lex.is_type = true;
    }
    else if(symbol_buffer == "float"){
        lex.type = gr_lexeme_type::floatType;
        lex.is_type = true;
    }
    else if(symbol_buffer == "bool"){
        lex.type = gr_lexeme_type::boolType;
        lex.is_type = true;
    }
    else if(symbol_buffer == "string"){
        lex.type = gr_lexeme_type::stringType;
        lex.is_type = true;
    }
    else if(symbol_buffer == "array"){
        lex.type = gr_lexeme_type::arrayType;
        lex.is_type = true;
    }
    else if(symbol_buffer == "chan"){
        lex.type = gr_lexeme_type::chanType;
        lex.is_type = true;
    }
    else if(symbol_buffer == "new"){
        lex.type = gr_lexeme_type::new_;
        lex.is_type = false;
    }
    else if(symbol_buffer == "let"){
        lex.type = gr_lexeme_type::autoType;
        lex.is_type = false;
    }
    else if(symbol_buffer == "true"){
        lex.type = gr_lexeme_type::boolean;
        lex.is_keyword = false;
        lex.is_literal = true;
        lex.bvalue = true;
    }
    else if(symbol_buffer == "false"){
        lex.type = gr_lexeme_type::boolean;
        lex.is_keyword = false;
        lex.is_literal = true;
        lex.bvalue = false;
    }
    else if(symbol_buffer == "null"){
        lex.type = gr_lexeme_type::null_;
        lex.is_keyword = false;
        lex.is_literal = true;
    }
    else if(symbol_buffer == "not"){
        lex.type = gr_lexeme_type::not_;
        lex.is_keyword = false;
        lex.is_operator = true;
    }
    else if(symbol_buffer == "and"){
        lex.type = gr_lexeme_type::and_;
        lex.is_keyword = false;
        lex.is_operator = true;
    }
    else if(symbol_buffer == "or"){
        lex.type = gr_lexeme_type::or_;
        lex.is_keyword = false;
        lex.is_operator = true;
    }
    else if(symbol_buffer == "xor"){
        lex.type = gr_lexeme_type::xor_;
        lex.is_keyword = false;
        lex.is_operator = true;
    } else {
        lex.is_keyword = false;
        lex.type = gr_lexeme_type::identifier;
        lex.svalue = symbol_buffer;
    }

    _lexemes.push_back(lex);
}

inline string gr_lexer::convert_path_to_import(string& path) {
    return path;
}

inline void gr_lexer::scan_file(gp::vector<char>& file_name){
    _files_to_import.push_back(file_name);

    while (_files_to_import.size()) {
        _file = _files_to_import[_files_to_import.size()-1];
        _files_imported.push_back(_file);
        _text = file_loader(file_name);
        _files_to_import.pop_back();

        _line = 0u;
        _current = 0u;
        _lines = gp::vector<string>(_allocator);

        gp::vector<char> tmp(_allocator);
        for(char c : _text) {
            if(c == '\n') {
                _lines.push_back(tmp);
                tmp = gp::vector<char>(_allocator);
            } else {
                tmp.push_back(c);
            }
        }

        scan_script();

        _file_id++;
    }
}

inline void gr_lexer::scan_file_path(){
    gp_config::assertion(get() != '\"', "Expected \'\"\' at the beginning of the import.");
    _current++;

    string buffer(_allocator);
    for (;;) {
        gp_config::assertion(_current >= _text.size(), "Missing \'\"\' character.");
        char symbol = get();
        if (symbol == '\n') {
            _position_of_line = _current;
            _line++;
        }
        else if (symbol == '\"')
            break;

        buffer.push_back(symbol);
        _current++;
    }
    buffer = convert_path_to_import(buffer);

    for(auto& file : _files_imported) {
        if(file == buffer) return;
    }
    for(auto& file : _files_to_import) {
        if(file == buffer) return;
    }

    _files_to_import.push_back(buffer);
}

inline void gr_lexer::scan_use(){
    advance();

    // Multiple files import.
    if (get() == '{') {
        advance();
        bool isFirst = true;
        for (;;) {
            if (isFirst)
                isFirst = false;
            else if (get() == '\"')
                advance();
            else
                gp_config::assertion(false, "Missing \'}\' after import list.");
            // EOF
            gp_config::assertion(_current >= _text.size(), "Missing \'}\' after import list.");
            // End of the import list.
            if (get() == '}')
                break;
            // Scan
            scan_file_path();
        }
    }
    else {
        scan_file_path();
    }
}