/*
 * Copyright (c) 2021 Arm Limited.
 *
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
#include "src/runtime/CL/mlgo/MLGOParser.h"
#include "arm_compute/core/Log.h"
#include "src/runtime/CL/mlgo/Utils.h"

#include <sstream>

#define CHECK(parser_expr, valid_var) \
    (parser_expr);                    \
    if(!valid_var)                    \
        return;

#define CHECK_DEFAULT(parser_expr, valid_var, default_val) \
    (parser_expr);                                         \
    if(!valid_var)                                         \
        return default_val;

#ifdef ARM_COMPUTE_LOGGING_ENABLED

#define FAIL_WITH_MSG(valid_var, pos, msg)           \
    std::stringstream ss;                            \
    ss << "MLGOParser Error: " << pos << " " << msg; \
    ARM_COMPUTE_LOG_INFO_MSG_CORE(ss.str().c_str()); \
    valid_var = false;                               \
    return;

#define FAIL_WITH_MSG_DEFAULT(valid_var, default_val, pos, msg) \
    std::stringstream ss;                                       \
    ss << "MLGOParser Error: " << pos << " " << msg;            \
    ARM_COMPUTE_LOG_INFO_MSG_CORE(ss.str().c_str());            \
    valid_var = false;                                          \
    return default_val;

#define LOG_TOKEN_POS(tokens, pos_var) \
    const auto pos_var = tokens.current_pos();

#else // ARM_COMPUTE_LOGGING_ENABLED

#define FAIL_WITH_MSG(valid_var, pos, msg) \
    valid_var = false;                     \
    return;

#define FAIL_WITH_MSG_DEFAULT(valid_var, default_val, pos, msg) \
    valid_var = false;                                          \
    return default_val;

#define LOG_TOKEN_POS(tokens, pos_var)

#endif // ARM_COMPUTE_LOGGING_ENABLED
namespace
{
void ltrim(std::string &str)
{
    str.erase(str.begin(), std::find_if(str.begin(), str.end(), [](char ch)
    {
        return !std::isspace(ch);
    }));
}

void rtrim(std::string &str)
{
    str.erase(std::find_if(str.rbegin(), str.rend(), [](char ch)
    {
        return !std::isspace(ch);
    }).base(),
    str.end());
}

void trim(std::string &str)
{
    ltrim(str);
    rtrim(str);
}
} // namespace

namespace arm_compute
{
namespace mlgo
{
namespace parser
{
enum class ComparatorType
{
    Enum,
    Num,
    Var
};

TokenStream::TokenStream(std::istream &s, const std::string &delims)
    : _delims{ delims }, _istream{ s }, _tokens{}, _lookahead_pos{}
{
    read();
}

TokenStream::operator bool() const
{
    ARM_COMPUTE_ERROR_ON_MSG(_tokens.empty(), "TokenStream can never be empty");
    return !reached_end();
}

Token TokenStream::take()
{
    ARM_COMPUTE_ERROR_ON_MSG(_tokens.empty(), "TokenStream can never be empty");
    Token t = _tokens.front();
    _tokens.pop_front();
    if(_tokens.empty())
    {
        read();
    }
    return t;
}
Token TokenStream::peek(size_t i)
{
    ARM_COMPUTE_ERROR_ON_MSG(_tokens.empty(), "TokenStream can never be empty");
    ARM_COMPUTE_ERROR_ON_MSG(i >= max_look_ahead, "TokenStream: Exceeding max look ahead");
    // NOTE: If i exceeds the stream (_istream.eof()), read() automatically appends a End token at the end
    while(_istream && _tokens.size() <= i)
    {
        read();
    }
    size_t ind = std::min(i, _tokens.size() - 1);
    return _tokens[ind];
}

void advance(CharPosition &pos, char ch)
{
    if(ch == '\n')
    {
        pos.ln += 1;
        pos.col = 0;
    }
    else
    {
        pos.col += 1;
    }
}
void rewind(CharPosition &pos)
{
    pos.col -= 1;
}
void TokenStream::read()
{
    char ch;
    // Skip any leading space and delim characters
    do
    {
        // Reached eof
        if(!_istream.get(ch))
        {
            if(!reached_end())
            {
                _tokens.emplace_back(TokenType::End, "", _lookahead_pos);
            }
            return;
        }
        advance(_lookahead_pos, ch);
    }
    while(std::isspace(ch) || is_delim(ch));
    // Read chars until we hit a delim or eof
    auto orig_pos = _lookahead_pos;
    auto tok      = recognize_tok(ch);
    rewind(orig_pos);
    tok.pos = orig_pos;
    // Trim leading and trailing white spaces
    trim(tok.value);
    _tokens.push_back(tok);
}

Token TokenStream::recognize_tok(char ch)
{
    if(ch == '[')
    {
        return Token{ TokenType::L_List, "", _lookahead_pos };
    }
    else if(ch == ']')
    {
        return Token{ TokenType::R_List, "", _lookahead_pos };
    }
    else if(ch == '.')
    {
        return float_after_dp_st(std::string{ ch });
    }
    else if(std::isdigit(ch))
    {
        return num_st(std::string{ ch });
    }
    else
    {
        return text_st(std::string{ ch });
    }
}

Token TokenStream::num_st(std::string value)
{
    char ch{};
    while(_istream.get(ch))
    {
        advance(_lookahead_pos, ch);
        if(ch == '.')
        {
            return float_after_dp_st(value + ch);
        }
        else if(!std::isdigit(ch))
        {
            if(!is_delim(ch) && !std::isspace(ch))
            {
                rewind(_lookahead_pos);
                _istream.unget();
            }
            break;
        }
        value += ch;
    }
    return Token{ TokenType::Int, value, _lookahead_pos };
}

Token TokenStream::float_after_dp_st(std::string value)
{
    char ch{};
    while(_istream.get(ch))
    {
        advance(_lookahead_pos, ch);
        if(!std::isdigit(ch))
        {
            if(!is_delim(ch) && !std::isspace(ch))
            {
                rewind(_lookahead_pos);
                _istream.unget();
            }
            break;
        }
        value += ch;
    }
    return Token{ TokenType::Float, value, _lookahead_pos };
}

Token TokenStream::text_st(std::string value)
{
    char ch{};
    while(_istream.get(ch))
    {
        advance(_lookahead_pos, ch);
        if(is_delim(ch))
        {
            break;
        }
        if(ch == '[' || ch == ']')
        {
            rewind(_lookahead_pos);
            _istream.unget();
            break;
        }
        value += ch;
    }
    return Token{ TokenType::Text, value, _lookahead_pos };
}

bool TokenStream::reached_end() const
{
    return _tokens.size() == 1 && _tokens.front().type == TokenType::End;
}

bool TokenStream::is_delim(char ch) const
{
    return _delims.find(ch) != std::string::npos;
}

void end(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    auto tok = in.take();
    if(tok.type != TokenType::End)
    {
        FAIL_WITH_MSG(valid, pos, "Unexpected token at the end of stream");
    }
}

bool bool_val(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    auto tok = in.take();
    if(tok.type != TokenType::Int)
    {
        FAIL_WITH_MSG_DEFAULT(valid, false, pos, "Expect bool or int token");
    }
    bool val{};
    std::stringstream(tok.value) >> val;
    return val;
}

int int_val(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    auto tok = in.take();
    if(tok.type != TokenType::Int)
    {
        FAIL_WITH_MSG_DEFAULT(valid, -1, pos, "Expect int token");
    }
    int val{};
    std::stringstream(tok.value) >> val;
    return val;
}

unsigned int uint_val(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    int val = CHECK_DEFAULT(int_val(in, valid), valid, 0);
    if(val < 0)
    {
        FAIL_WITH_MSG_DEFAULT(valid, 0, pos, "Expect unsigned int token");
    }
    return static_cast<unsigned int>(val);
}

float float_val(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    auto tok = in.take();
    if(tok.type != TokenType::Float)
    {
        FAIL_WITH_MSG_DEFAULT(valid, 0.f, pos, "Expect float token");
    }
    float val{};
    std::stringstream(tok.value) >> val;
    return val;
}

std::string text_val(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    auto tok = in.take();
    if(tok.type != TokenType::Text || tok.value.empty())
    {
        FAIL_WITH_MSG_DEFAULT(valid, "", pos, "Expect a non-empty text token");
    }
    return tok.value;
}

bool accept_text(TokenStream &in, const std::string &c_str, bool take = true)
{
    auto tok = in.peek();
    if(tok.type == TokenType::Text && tok.value == c_str)
    {
        if(take)
        {
            in.take();
        }
        return true;
    }
    return false;
}

void expect_text(TokenStream &in, const std::string &str, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    if(!accept_text(in, str))
    {
        FAIL_WITH_MSG(valid, pos, std::string("Expect text token: ") + str);
    }
}

bool accept_l_list(TokenStream &in)
{
    auto tok = in.peek();
    if(tok.type == TokenType::L_List)
    {
        in.take();
        return true;
    }
    return false;
}

void expect_l_list(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    if(!accept_l_list(in))
    {
        FAIL_WITH_MSG(valid, pos, "Expect '['");
    }
}

bool accept_r_list(TokenStream &in)
{
    auto tok = in.peek();
    if(tok.type == TokenType::R_List)
    {
        in.take();
        return true;
    }
    return false;
}

void expect_r_list(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    if(!accept_r_list(in))
    {
        FAIL_WITH_MSG(valid, pos, "Expect ']'");
    }
}

ConditionalOp conditional_op(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    if(accept_text(in, "<="))
    {
        return ConditionalOp::LE;
    }
    else if(accept_text(in, ">="))
    {
        return ConditionalOp::GE;
    }
    else if(accept_text(in, "=="))
    {
        return ConditionalOp::EQ;
    }
    else if(accept_text(in, "<"))
    {
        return ConditionalOp::LT;
    }
    else if(accept_text(in, ">"))
    {
        return ConditionalOp::GT;
    }
    else
    {
        FAIL_WITH_MSG_DEFAULT(valid, ConditionalOp::EQ, pos, "Expect conditional op");
    }
}

void gemm_version(TokenStream &in, bool &valid)
{
    CHECK(expect_text(in, "gemm-version", valid), valid);
    CHECK(expect_l_list(in, valid), valid);
    CHECK(uint_val(in, valid), valid);
    CHECK(uint_val(in, valid), valid);
    CHECK(uint_val(in, valid), valid);
    CHECK(expect_r_list(in, valid), valid);
}

void ip_type(TokenStream &in, bool &valid)
{
    CHECK(expect_text(in, "ip-type", valid), valid);
    LOG_TOKEN_POS(in, pos);
    if(accept_text(in, "gpu"))
    {
        ;
    }
    else if(accept_text(in, "cpu"))
    {
        ;
    }
    else
    {
        FAIL_WITH_MSG(valid, pos, "Expect ip type");
    }
}

void header(TokenStream &in, bool &valid)
{
    CHECK(expect_text(in, "<header>", valid), valid);
    CHECK(gemm_version(in, valid), valid);
    CHECK(ip_type(in, valid), valid);
    CHECK(expect_text(in, "</header>", valid), valid);
}

DataType data_type(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    if(accept_text(in, "f16"))
    {
        return DataType::F16;
    }
    else if(accept_text(in, "f32"))
    {
        return DataType::F32;
    }
    else if(accept_text(in, "qasymm8"))
    {
        return DataType::QASYMM8;
    }
    else
    {
        FAIL_WITH_MSG_DEFAULT(valid, DataType::QASYMM8, pos, "Expect data type");
    }
}

ComparatorType comparator_type(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    if(accept_text(in, "var"))
    {
        return ComparatorType::Var;
    }
    else if(accept_text(in, "num"))
    {
        return ComparatorType::Num;
    }
    else if(accept_text(in, "enum"))
    {
        return ComparatorType::Enum;
    }
    else
    {
        FAIL_WITH_MSG_DEFAULT(valid, ComparatorType::Num, pos, "Expect comparator type");
    }
}

HeuristicType heuristic_type(TokenStream &in, bool &valid, bool take = true)
{
    LOG_TOKEN_POS(in, pos);
    if(accept_text(in, "gemm-type", take))
    {
        return HeuristicType::GEMM_Type;
    }
    else if(accept_text(in, "gemm-config-native", take))
    {
        return HeuristicType::GEMM_Config_Native;
    }
    else if(accept_text(in, "gemm-config-reshaped-only-rhs", take))
    {
        return HeuristicType::GEMM_Config_Reshaped_Only_RHS;
    }
    else if(accept_text(in, "gemm-config-reshaped", take))
    {
        return HeuristicType::GEMM_Config_Reshaped;
    }
    else
    {
        FAIL_WITH_MSG_DEFAULT(valid, HeuristicType::GEMM_Config_Reshaped, pos, "Expect heuristic type");
    }
}

void expect_heuristic_type(TokenStream &in, HeuristicType expected_ht, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    auto ht = CHECK(heuristic_type(in, valid, false), valid);
    if(ht != expected_ht)
    {
        FAIL_WITH_MSG(valid, pos, "Unexpected heuristic type");
    }
    CHECK(heuristic_type(in, valid, true), valid);
}

GEMMType gemm_type(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    if(accept_text(in, "native"))
    {
        return GEMMType::NATIVE;
    }
    else if(accept_text(in, "reshaped-only-rhs"))
    {
        return GEMMType::RESHAPED_ONLY_RHS;
    }
    else if(accept_text(in, "reshaped"))
    {
        return GEMMType::RESHAPED;
    }
    else
    {
        FAIL_WITH_MSG_DEFAULT(valid, GEMMType::RESHAPED_ONLY_RHS, pos, "Expect gemm type");
    }
}

GEMMConfigNative gemm_config_native(TokenStream &in, bool &valid)
{
    const auto invalid_val = GEMMConfigNative{};
    CHECK_DEFAULT(expect_l_list(in, valid), valid, invalid_val);
    const auto m0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto n0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto k0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    CHECK_DEFAULT(expect_r_list(in, valid), valid, invalid_val);
    return GEMMConfigNative{ m0, n0, k0 };
}

GEMMConfigReshapedOnlyRHS gemm_config_reshaped_only_rhs(TokenStream &in, bool &valid)
{
    const auto invalid_val = GEMMConfigReshapedOnlyRHS{};
    CHECK_DEFAULT(expect_l_list(in, valid), valid, invalid_val);
    const auto m0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto n0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto k0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto h0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto ir = CHECK_DEFAULT(bool_val(in, valid), valid, invalid_val);
    const auto tr = CHECK_DEFAULT(bool_val(in, valid), valid, invalid_val);
    const auto ex = CHECK_DEFAULT(bool_val(in, valid), valid, invalid_val);
    CHECK_DEFAULT(expect_r_list(in, valid), valid, invalid_val);
    return GEMMConfigReshapedOnlyRHS{ m0, n0, k0, h0, ir, tr, ex };
}

GEMMConfigReshaped gemm_config_reshaped(TokenStream &in, bool &valid)
{
    const auto invalid_val = GEMMConfigReshaped{};
    CHECK_DEFAULT(expect_l_list(in, valid), valid, invalid_val);
    const auto m0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto n0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto k0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto v0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto h0 = CHECK_DEFAULT(uint_val(in, valid), valid, invalid_val);
    const auto il = CHECK_DEFAULT(bool_val(in, valid), valid, invalid_val);
    const auto ir = CHECK_DEFAULT(bool_val(in, valid), valid, invalid_val);
    const auto tr = CHECK_DEFAULT(bool_val(in, valid), valid, invalid_val);
    const auto ex = CHECK_DEFAULT(bool_val(in, valid), valid, invalid_val);
    CHECK_DEFAULT(expect_r_list(in, valid), valid, invalid_val);
    return GEMMConfigReshaped{ m0, n0, k0, v0, h0, il, ir, tr, ex };
}

void gpu_priority(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    if(accept_text(in, "best-performance"))
    {
        ;
    }
    else if(accept_text(in, "best-memory-usage"))
    {
        ;
    }
    else
    {
        FAIL_WITH_MSG(valid, pos, "Expect gpu priority");
    }
}

void gpu_behavior(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    if(accept_text(in, "static"))
    {
        ;
    }
    else if(accept_text(in, "dynamic"))
    {
        ;
    }
    else
    {
        FAIL_WITH_MSG(valid, pos, "Expect ip type");
    }
}

void free_vars(TokenStream &in, bool &valid)
{
    CHECK(expect_l_list(in, valid), valid);
    while(!accept_r_list(in))
    {
        CHECK(text_val(in, valid), valid);
    }
}

void heuristics_table_entry(TokenStream &in, MLGOHeuristics &h, bool &valid)
{
    const auto id = CHECK(uint_val(in, valid), valid);
    const auto ip = CHECK(text_val(in, valid), valid);
    CHECK(uint_val(in, valid), valid); // Num cores
    const auto dt = CHECK(data_type(in, valid), valid);
    CHECK(gpu_priority(in, valid), valid);
    CHECK(gpu_behavior(in, valid), valid);
    const auto ht = CHECK(heuristic_type(in, valid), valid);
    CHECK(free_vars(in, valid), valid);
    HeuristicTree t(id, ht, ip, dt);
    valid = CHECK(h.add_heuristic_tree(std::move(t)), valid);
}

void heuristics_table(TokenStream &in, MLGOHeuristics &h, bool &valid)
{
    CHECK(expect_text(in, "<heuristics-table>", valid), valid);
    while(!accept_text(in, "</heuristics-table>"))
    {
        CHECK(heuristics_table_entry(in, h, valid), valid);
    }
}

Condition condition(TokenStream &in, bool &valid)
{
    LOG_TOKEN_POS(in, pos);
    // NOTE: Only simplified Conditions are accepted, which means the lhs comparator type is fixed to Var and that of
    // the rhs is fixed to Num (float)
    const auto invalid_val = Condition{};
    const auto l_t         = CHECK_DEFAULT(comparator_type(in, valid), valid, invalid_val);
    const auto l_v         = CHECK_DEFAULT(text_val(in, valid), valid, invalid_val);
    const auto c_o         = CHECK_DEFAULT(conditional_op(in, valid), valid, invalid_val);
    const auto r_t         = CHECK_DEFAULT(comparator_type(in, valid), valid, invalid_val);
    const auto r_v         = CHECK_DEFAULT(float_val(in, valid), valid, invalid_val);
    if(l_t != ComparatorType::Var || r_t != ComparatorType::Num)
    {
        FAIL_WITH_MSG_DEFAULT(valid, invalid_val, pos, "Only accept LHS type to be Var (string) and RHS type to be Num (float)");
    }
    return Condition{ l_v, c_o, r_v };
}

void heuristic_tree(TokenStream &in, MLGOHeuristics &h, bool &valid)
{
    CHECK(expect_text(in, "<heuristic", valid), valid);
    const auto tree_id = CHECK(uint_val(in, valid), valid);
    CHECK(expect_text(in, ">", valid), valid);
    HeuristicTree *t = nullptr;
    std::tie(valid, t) = CHECK(h.get_heuristic_tree(tree_id), valid);
    const HeuristicType t_heuristic_type = std::get<0>(t->index());
    while(!accept_text(in, "</heuristic>"))
    {
        LOG_TOKEN_POS(in, pos);
        if(accept_text(in, "b"))
        {
            // Branch node
            const auto id   = CHECK(uint_val(in, valid), valid);
            const auto cond = CHECK(condition(in, valid), valid);
            const auto t_id = CHECK(uint_val(in, valid), valid);
            const auto f_id = CHECK(uint_val(in, valid), valid);
            valid           = CHECK(t->add_branch(id, cond, t_id, f_id), valid);
        }
        else if(accept_text(in, "l"))
        {
            // Leaf node
            const auto id = CHECK(uint_val(in, valid), valid);
            // NOTE: Heuristic type within each tree appears to be redundant (same information can be obtained from the
            // heuristic table). For now it remains as a step for validation.
            LOG_TOKEN_POS(in, pos);
            CHECK(expect_heuristic_type(in, t_heuristic_type, valid), valid);
            switch(t_heuristic_type)
            {
                case HeuristicType::GEMM_Type:
                {
                    const auto g_type = CHECK(gemm_type(in, valid), valid);
                    valid             = CHECK(t->add_leaf(id, g_type), valid);
                    break;
                }
                case HeuristicType::GEMM_Config_Native:
                {
                    const auto g_c = CHECK(gemm_config_native(in, valid), valid);
                    valid          = CHECK(t->add_leaf(id, g_c), valid);
                    break;
                }
                case HeuristicType::GEMM_Config_Reshaped_Only_RHS:
                {
                    const auto g_c = CHECK(gemm_config_reshaped_only_rhs(in, valid), valid);
                    valid          = CHECK(t->add_leaf(id, g_c), valid);
                    break;
                }
                case HeuristicType::GEMM_Config_Reshaped:
                {
                    const auto g_c = CHECK(gemm_config_reshaped(in, valid), valid);
                    valid          = CHECK(t->add_leaf(id, g_c), valid);
                    break;
                }
                default:
                {
                    FAIL_WITH_MSG(valid, pos, "Unexpected heuristic type");
                }
            }
        }
        else
        {
            FAIL_WITH_MSG(valid, pos, "Expect tree node type");
        }
    }
    // Perform semantic checks in the middle of parsing so that it can fail fast should there be any invalidities
    valid = CHECK(h.check_heuristic_tree(tree_id), valid);
}

MLGOHeuristics mlgo(TokenStream &in, bool &valid)
{
    MLGOHeuristics h;
    CHECK_DEFAULT(header(in, valid), valid, h);
    CHECK_DEFAULT(heuristics_table(in, h, valid), valid, h);
    while(accept_text(in, "<heuristic", false))
    {
        CHECK_DEFAULT(heuristic_tree(in, h, valid), valid, h);
    }
    CHECK_DEFAULT(end(in, valid), valid, h);
    valid = CHECK_DEFAULT(h.check_all(), valid, h);
    return h;
}

std::pair<bool, MLGOHeuristics> parse_mlgo(std::istream &in)
{
    auto tokens = TokenStream(in);
    bool valid  = true;
    auto h      = mlgo(tokens, valid);
    return std::make_pair(std::move(valid), std::move(h));
}
} // namespace parser
} // namespace mlgo
} // namespace arm_compute

#undef CHECK
#undef CHECK_DEFAULT
#undef FAIL_WITH_MSG
#undef FAIL_WITH_MSG_DEFAULT