// Copyright 2021 xensik. All rights reserved.
//
// Use of this source code is governed by a GNU GPLv3 license
// that can be found in the LICENSE file.

#pragma once

namespace xsk::gsc::ast
{

enum class kind
{
    null,
    expr_true,
    expr_false,
    expr_integer,
    expr_float,
    expr_vector,
    expr_color,
    expr_string,
    expr_istring,
    expr_path,
    expr_identifier,
    expr_animtree,
    expr_animation,
    expr_level,
    expr_anim,
    expr_self,
    expr_game,
    expr_undefined,
    expr_empty_array,
    expr_thisthread,
    expr_paren,
    expr_size,
    expr_field,
    expr_array,
    expr_reference,
    expr_istrue,
    expr_isdefined,
    expr_arguments,
    expr_parameters,
    expr_add_array,
    expr_pointer,
    expr_function,
    expr_method,
    expr_call,
    expr_complement,
    expr_not,
    expr_add,
    expr_sub,
    expr_mul,
    expr_div,
    expr_mod,
    expr_shift_left,
    expr_shift_right,
    expr_bitwise_or,
    expr_bitwise_and,
    expr_bitwise_exor,
    expr_equality,
    expr_inequality,
    expr_less_equal,
    expr_greater_equal,
    expr_less,
    expr_greater,
    expr_or,
    expr_and,
    expr_ternary,
    expr_increment,
    expr_decrement,
    expr_assign_equal,
    expr_assign_add,
    expr_assign_sub,
    expr_assign_mul,
    expr_assign_div,
    expr_assign_mod,
    expr_assign_shift_left,
    expr_assign_shift_right,
    expr_assign_bitwise_or,
    expr_assign_bitwise_and,
    expr_assign_bitwise_exor,
    stmt_list,
    stmt_expr,
    stmt_call,
    stmt_assign,
    stmt_endon,
    stmt_notify,
    stmt_wait,
    stmt_waittill,
    stmt_waittillmatch,
    stmt_waittillframeend,
    stmt_waitframe,
    stmt_if,
    stmt_ifelse,
    stmt_while,
    stmt_dowhile,
    stmt_for,
    stmt_foreach,
    stmt_switch,
    stmt_case,
    stmt_default,
    stmt_break,
    stmt_continue,
    stmt_return,
    stmt_breakpoint,
    stmt_prof_begin,
    stmt_prof_end,
    decl_thread,
    decl_constant,
    decl_usingtree,
    decl_dev_begin,
    decl_dev_end,
    include,
    program,
// DECOMPILER
    asm_loc,
    asm_jump,
    asm_jump_back,
    asm_jump_cond,
    asm_jump_true_expr,
    asm_jump_false_expr,
    asm_switch,
    asm_endswitch,
    asm_prescriptcall,
    asm_voidcodepos,
    asm_create,
    asm_access,
    asm_remove,
    asm_clear,
};

struct node;
struct expr_true;
struct expr_false;
struct expr_integer;
struct expr_float;
struct expr_vector;
struct expr_color;
struct expr_string;
struct expr_istring;
struct expr_path;
struct expr_identifier;
struct expr_animtree;
struct expr_animation;
struct expr_level;
struct expr_anim;
struct expr_self;
struct expr_game;
struct expr_undefined;
struct expr_empty_array;
struct expr_thisthread;
struct expr_paren;
struct expr_size;
struct expr_field;
struct expr_array;
struct expr_reference;
struct expr_istrue;
struct expr_isdefined;
struct expr_arguments;
struct expr_parameters;
struct expr_add_array;
struct expr_pointer;
struct expr_function;
struct expr_method;
struct expr_call;
struct expr_complement;
struct expr_not;
struct expr_binary;
struct expr_add;
struct expr_sub;
struct expr_mul;
struct expr_div;
struct expr_mod;
struct expr_shift_left;
struct expr_shift_right;
struct expr_bitwise_or;
struct expr_bitwise_and;
struct expr_bitwise_exor;
struct expr_equality;
struct expr_inequality;
struct expr_less_equal;
struct expr_greater_equal;
struct expr_less;
struct expr_greater;
struct expr_or;
struct expr_and;
struct expr_ternary;
struct expr_increment;
struct expr_decrement;
struct expr_assign;
struct expr_assign_equal;
struct expr_assign_add;
struct expr_assign_sub;
struct expr_assign_mul;
struct expr_assign_div;
struct expr_assign_mod;
struct expr_assign_shift_left;
struct expr_assign_shift_right;
struct expr_assign_bitwise_or;
struct expr_assign_bitwise_and;
struct expr_assign_bitwise_exor;
struct stmt_list;
struct stmt_expr;
struct stmt_call;
struct stmt_assign;
struct stmt_endon;
struct stmt_notify;
struct stmt_wait;
struct stmt_waittill;
struct stmt_waittillmatch;
struct stmt_waittillframeend;
struct stmt_waitframe;
struct stmt_if;
struct stmt_ifelse;
struct stmt_while;
struct stmt_dowhile;
struct stmt_for;
struct stmt_foreach;
struct stmt_switch;
struct stmt_case;
struct stmt_default;
struct stmt_break;
struct stmt_continue;
struct stmt_return;
struct stmt_breakpoint;
struct stmt_prof_begin;
struct stmt_prof_end;
struct decl_thread;
struct decl_constant;
struct decl_usingtree;
struct decl_dev_begin;
struct decl_dev_end;
struct include;
struct program;
struct asm_loc;
struct asm_jump;
struct asm_jump_back;
struct asm_jump_cond;
struct asm_jump_false_expr;
struct asm_jump_true_expr;
struct asm_switch;
struct asm_endswitch;
struct asm_create;
struct asm_access;
struct asm_remove;
struct asm_clear;

union call
{
    enum class type { local, far, builtin };
    enum class mode { normal, thread, childthread, builtin };

    std::unique_ptr<node> as_node;
    std::unique_ptr<expr_pointer> as_pointer;
    std::unique_ptr<expr_function> as_function;

    call();
    call(std::unique_ptr<node> value);
    call(call&& value);
    call(const call&) = delete;
    call& operator=(const call&) = delete;
    ~call();
    friend bool operator==(const call& lhs, kind rhs);
    auto loc() const -> location;
    auto kind() const -> ast::kind;
    auto print() const -> std::string;
};

union expr
{
    std::unique_ptr<node> as_node;
    std::unique_ptr<expr_true> as_true;
    std::unique_ptr<expr_false> as_false;
    std::unique_ptr<expr_integer> as_integer;
    std::unique_ptr<expr_float> as_float;
    std::unique_ptr<expr_vector> as_vector;
    std::unique_ptr<expr_color> as_color;
    std::unique_ptr<expr_string> as_string;
    std::unique_ptr<expr_istring> as_istring;
    std::unique_ptr<expr_path> as_path;
    std::unique_ptr<expr_identifier> as_identifier;
    std::unique_ptr<expr_animtree> as_animtree;
    std::unique_ptr<expr_animation> as_animation;
    std::unique_ptr<expr_level> as_level;
    std::unique_ptr<expr_anim> as_anim;
    std::unique_ptr<expr_self> as_self;
    std::unique_ptr<expr_game> as_game;
    std::unique_ptr<expr_undefined> as_undefined;
    std::unique_ptr<expr_empty_array> as_empty_array;
    std::unique_ptr<expr_thisthread> as_thisthread;
    std::unique_ptr<expr_paren> as_paren;
    std::unique_ptr<expr_size> as_size;
    std::unique_ptr<expr_field> as_field;
    std::unique_ptr<expr_array> as_array;
    std::unique_ptr<expr_reference> as_reference;
    std::unique_ptr<expr_istrue> as_istrue;
    std::unique_ptr<expr_isdefined> as_isdefined;
    std::unique_ptr<expr_arguments> as_arguments;
    std::unique_ptr<expr_parameters> as_parameters;
    std::unique_ptr<expr_add_array> as_add_array;
    std::unique_ptr<expr_pointer> as_pointer;
    std::unique_ptr<expr_function> as_function;
    std::unique_ptr<expr_method> as_method;
    std::unique_ptr<expr_call> as_call;
    std::unique_ptr<expr_complement> as_complement;
    std::unique_ptr<expr_not> as_not;
    std::unique_ptr<expr_binary> as_binary;
    std::unique_ptr<expr_add> as_add;
    std::unique_ptr<expr_sub> as_sub;
    std::unique_ptr<expr_mul> as_mul;
    std::unique_ptr<expr_div> as_div;
    std::unique_ptr<expr_mod> as_mod;
    std::unique_ptr<expr_shift_left> as_shift_left;
    std::unique_ptr<expr_shift_right> as_shift_right;
    std::unique_ptr<expr_bitwise_or> as_bitwise_or;
    std::unique_ptr<expr_bitwise_and> as_bitwise_and;
    std::unique_ptr<expr_bitwise_exor> as_bitwise_exor;
    std::unique_ptr<expr_equality> as_equality;
    std::unique_ptr<expr_inequality> as_inequality;
    std::unique_ptr<expr_less_equal> as_less_equal;
    std::unique_ptr<expr_greater_equal> as_greater_equal;
    std::unique_ptr<expr_less> as_less;
    std::unique_ptr<expr_greater> as_greater;
    std::unique_ptr<expr_or> as_or;
    std::unique_ptr<expr_and> as_and;
    std::unique_ptr<expr_ternary> as_ternary;
    std::unique_ptr<expr_increment> as_increment;
    std::unique_ptr<expr_decrement> as_decrement;
    std::unique_ptr<expr_assign> as_assign;
    std::unique_ptr<expr_assign_equal> as_assign_equal;
    std::unique_ptr<expr_assign_add> as_assign_add;
    std::unique_ptr<expr_assign_sub> as_assign_sub;
    std::unique_ptr<expr_assign_mul> as_assign_mul;
    std::unique_ptr<expr_assign_div> as_assign_div;
    std::unique_ptr<expr_assign_mod> as_assign_mod;
    std::unique_ptr<expr_assign_shift_left> as_assign_shift_left;
    std::unique_ptr<expr_assign_shift_right> as_assign_shift_right;
    std::unique_ptr<expr_assign_bitwise_or> as_assign_bw_or;
    std::unique_ptr<expr_assign_bitwise_and> as_assign_bw_and;
    std::unique_ptr<expr_assign_bitwise_exor> as_assign_bw_exor;
    std::unique_ptr<asm_create> as_asm_create;
    std::unique_ptr<asm_access> as_asm_access;

    expr();
    expr(std::unique_ptr<node> value);
    expr(expr&& value);
    expr& operator=(expr&& value);
    expr(const expr&) = delete;
    expr& operator=(const expr&) = delete;
    ~expr();
    friend bool operator!=(const expr& lhs, kind rhs);
    friend bool operator==(const expr& lhs, kind rhs);
    friend bool operator==(const expr& lhs, const expr& rhs);
    auto loc() const -> location;
    auto kind() const -> ast::kind;
    auto print() const -> std::string;
};

union stmt
{
    std::unique_ptr<node> as_node;
    std::unique_ptr<stmt_list> as_list;
    std::unique_ptr<stmt_expr> as_expr;
    std::unique_ptr<stmt_call> as_call;
    std::unique_ptr<stmt_assign> as_assign;
    std::unique_ptr<stmt_endon> as_endon;
    std::unique_ptr<stmt_notify> as_notify;
    std::unique_ptr<stmt_wait> as_wait;
    std::unique_ptr<stmt_waittill> as_waittill;
    std::unique_ptr<stmt_waittillmatch> as_waittillmatch;
    std::unique_ptr<stmt_waittillframeend> as_waittillframeend;
    std::unique_ptr<stmt_waitframe> as_waitframe;
    std::unique_ptr<stmt_if> as_if;
    std::unique_ptr<stmt_ifelse> as_ifelse;
    std::unique_ptr<stmt_while> as_while;
    std::unique_ptr<stmt_dowhile> as_dowhile;
    std::unique_ptr<stmt_for> as_for;
    std::unique_ptr<stmt_foreach> as_foreach;
    std::unique_ptr<stmt_switch> as_switch;
    std::unique_ptr<stmt_case> as_case;
    std::unique_ptr<stmt_default> as_default;
    std::unique_ptr<stmt_break> as_break;
    std::unique_ptr<stmt_continue> as_continue;
    std::unique_ptr<stmt_return> as_return;
    std::unique_ptr<stmt_breakpoint> as_breakpoint;
    std::unique_ptr<stmt_prof_begin> as_prof_begin;
    std::unique_ptr<stmt_prof_end> as_prof_end;
    std::unique_ptr<asm_loc> as_loc;
    std::unique_ptr<asm_jump_cond> as_cond;
    std::unique_ptr<asm_jump> as_jump;
    std::unique_ptr<asm_jump_back> as_jump_back;
    std::unique_ptr<asm_switch> as_asm_switch;
    std::unique_ptr<asm_endswitch> as_asm_endswitch;
    std::unique_ptr<asm_create> as_asm_create;
    std::unique_ptr<asm_access> as_asm_access;
    std::unique_ptr<asm_remove> as_asm_remove;
    std::unique_ptr<asm_clear> as_asm_clear;

    stmt();
    stmt(std::unique_ptr<node> value);
    stmt(stmt&& value);
    stmt& operator=(stmt&& value);
    stmt(const stmt&) = delete;
    stmt& operator=(const stmt&) = delete;
    ~stmt();
    friend bool operator==(const stmt& lhs, kind rhs);
    auto loc() const -> location;
    auto kind() const -> ast::kind;
    auto print() const -> std::string;
};

union decl
{
    std::unique_ptr<node> as_node;
    std::unique_ptr<decl_dev_begin> as_dev_begin;
    std::unique_ptr<decl_dev_end> as_dev_end;
    std::unique_ptr<decl_usingtree> as_usingtree;
    std::unique_ptr<decl_constant> as_constant;
    std::unique_ptr<decl_thread> as_thread;

    decl();
    decl(std::unique_ptr<node> value);
    decl(decl&& value);
    decl& operator=(decl&& value);
    decl(const decl&) = delete;
    decl& operator=(const decl&) = delete;
    ~decl();
    friend bool operator==(const decl& lhs, kind rhs);
    auto loc() const -> location;
    auto kind() const -> ast::kind;
    auto print() const -> std::string;
};

struct node
{
    using ptr = std::unique_ptr<node>;

private:
    kind kind_;
    location loc_;

public:
    node() : kind_(kind::null) {}
    node(const location& loc) : kind_(kind::null), loc_(loc) {}
    node(kind type) : kind_(type) {}
    node(kind type, const location& loc) : kind_(type), loc_(loc) {}

    virtual ~node() = default;
    virtual auto print() const -> std::string { return ""; };
    friend bool operator==(const node& n, kind k);
    friend bool operator==(const node& lhs, const node& rhs);

    auto kind() -> kind { return kind_; }
    auto loc() -> location& { return loc_; }

    auto is_special_stmt() -> bool;
    auto is_special_stmt_noif() -> bool;
    auto is_binary() -> bool;
    auto precedence() -> std::uint8_t;

protected:
    static std::uint32_t indent_;
    static void reset_indentation();
    static std::string indented(std::uint32_t indent); 
};

struct expr_true : public node
{
    using ptr = std::unique_ptr<expr_true>;

    expr_true();
    expr_true(const location& loc);
    auto print() const -> std::string override;
    friend bool operator==(const expr_true&, const expr_true&);
};

struct expr_false : public node
{
    using ptr = std::unique_ptr<expr_false>;

    expr_false();
    expr_false(const location& loc);
    auto print() const -> std::string override;
    friend bool operator==(const expr_false&, const expr_false&);
};

struct expr_integer : public node
{
    using ptr = std::unique_ptr<expr_integer>;

    std::string value;

    expr_integer(const std::string& value);
    expr_integer(const location& loc, const std::string& value);
    auto print() const -> std::string override;
    friend bool operator==(const expr_integer& lhs, const expr_integer& rhs);
};

struct expr_float : public node
{
    using ptr = std::unique_ptr<expr_float>;

    std::string value;

    expr_float(const std::string& value);
    expr_float(const location& loc, const std::string& value);
    auto print() const -> std::string override;
    friend bool operator==(const expr_float& lhs, const expr_float& rhs);
};

struct expr_vector : public node
{
    using ptr = std::unique_ptr<expr_vector>;

    expr x;
    expr y;
    expr z;

    expr_vector(expr x, expr y, expr z);
    expr_vector(const location& loc, expr x, expr y, expr z);
    auto print() const -> std::string override;
    friend bool operator==(const expr_vector& lhs, const expr_vector& rhs);
};

struct expr_color : public node
{
    using ptr = std::unique_ptr<expr_color>;

    std::string value;

    expr_color(const std::string& value);
    expr_color(const location& loc, const std::string& value);
    auto print() const -> std::string override;
    friend bool operator==(const expr_color& lhs, const expr_color& rhs);
};

struct expr_string : public node
{
    using ptr = std::unique_ptr<expr_string>;

    std::string value;

    expr_string(const std::string& value);
    expr_string(const location& loc, const std::string& value);
    auto print() const -> std::string override;
    friend bool operator==(const expr_string& lhs, const expr_string& rhs);
};

struct expr_istring : public node
{
    using ptr = std::unique_ptr<expr_istring>;

    std::string value;

    expr_istring(const std::string& value);
    expr_istring(const location& loc, const std::string& value);
    auto print() const -> std::string override;
    friend bool operator==(const expr_istring& lhs, const expr_istring& rhs);
};

struct expr_path : public node
{
    using ptr = std::unique_ptr<expr_path>;

    std::string value;

    expr_path();
    expr_path(const std::string& value);
    expr_path(const location& loc);
    expr_path(const location& loc, const std::string& value);
    auto print() const -> std::string override;
    friend bool operator==(const expr_path& lhs, const expr_path& rhs);
};

struct expr_identifier : public node
{
    using ptr = std::unique_ptr<expr_identifier>;

    std::string value;

    expr_identifier(const std::string& value);
    expr_identifier(const location& loc, const std::string& value);
    auto print() const -> std::string override;
    friend bool operator==(const expr_identifier& lhs, const expr_identifier& rhs);
};

struct expr_animtree : public node
{
    using ptr = std::unique_ptr<expr_animtree>;

    expr_animtree();
    expr_animtree(const location& loc);
    auto print() const -> std::string override;
    friend bool operator==(const expr_animtree& lhs, const expr_animtree& rhs);
};

struct expr_animation : public node
{
    using ptr = std::unique_ptr<expr_animation>;

    std::string value;

    expr_animation(const std::string& value);
    expr_animation(const location& loc, const std::string& value);
    auto print() const -> std::string override;
    friend bool operator==(const expr_animation& lhs, const expr_animation& rhs);
};

struct expr_level : public node
{
    using ptr = std::unique_ptr<expr_level>;

    expr_level();
    expr_level(const location& loc);
    auto print() const -> std::string override;
    friend bool operator==(const expr_level& lhs, const expr_level& rhs);
};

struct expr_anim : public node
{
    using ptr = std::unique_ptr<expr_anim>;

    expr_anim();
    expr_anim(const location& loc);
    auto print() const -> std::string override;
    friend bool operator==(const expr_anim& lhs, const expr_anim& rhs);
};

struct expr_self : public node
{
    using ptr = std::unique_ptr<expr_self>;

    expr_self();
    expr_self(const location& loc);
    auto print() const -> std::string override;
    friend bool operator==(const expr_self& lhs, const expr_self& rhs);
};

struct expr_game : public node
{
    using ptr = std::unique_ptr<expr_game>;

    expr_game();
    expr_game(const location& loc);
    auto print() const -> std::string override;
    friend bool operator==(const expr_game& lhs, const expr_game& rhs);
};

struct expr_undefined : public node
{
    using ptr = std::unique_ptr<expr_undefined>;

    expr_undefined();
    expr_undefined(const location& loc);
    auto print() const -> std::string override;
    friend bool operator==(const expr_undefined& lhs, const expr_undefined& rhs);
};

struct expr_empty_array : public node
{
    using ptr = std::unique_ptr<expr_empty_array>;

    expr_empty_array();
    expr_empty_array(const location& loc);
    auto print() const -> std::string override;
    friend bool operator==(const expr_empty_array& lhs, const expr_empty_array& rhs);
};

struct expr_thisthread : public node
{
    using ptr = std::unique_ptr<expr_thisthread>;

    expr_thisthread();
    expr_thisthread(const location& loc);
    auto print() const -> std::string override;
    friend bool operator==(const expr_thisthread& lhs, const expr_thisthread& rhs);
};

struct expr_paren : public node
{
    using ptr = std::unique_ptr<expr_paren>;

    expr child;

    expr_paren(expr expr);
    expr_paren(const location& loc, expr expr);
    auto print() const -> std::string override;
    friend bool operator==(const expr_paren& lhs, const expr_paren& rhs);
};

struct expr_size : public node
{
    using ptr = std::unique_ptr<expr_size>;

    expr obj;

    expr_size(expr obj);
    expr_size(const location& loc, expr obj);
    auto print() const -> std::string override;
    friend bool operator==(const expr_size& lhs, const expr_size& rhs);
};

struct expr_field : public node
{
    using ptr = std::unique_ptr<expr_field>;

    expr obj;
    expr_identifier::ptr field;

    expr_field(expr obj, expr_identifier::ptr field);
    expr_field(const location& loc, expr obj, expr_identifier::ptr field);
    auto print() const -> std::string override;
    friend bool operator==(const expr_field& lhs, const expr_field& rhs);
};

struct expr_array : public node
{
    using ptr = std::unique_ptr<expr_array>;

    expr obj;
    expr key;

    expr_array(expr obj, expr key);
    expr_array(const location& loc, expr obj, expr key);
    auto print() const -> std::string override;
    friend bool operator==(const expr_array& lhs, const expr_array& rhs);
};

struct expr_reference : public node
{
    using ptr = std::unique_ptr<expr_reference>;

    expr_path::ptr path;
    expr_identifier::ptr name;

    expr_reference(expr_path::ptr path, expr_identifier::ptr name);
    expr_reference(const location& loc, expr_path::ptr path, expr_identifier::ptr name);
    auto print() const -> std::string override;
};

struct expr_istrue : public node
{
    using ptr = std::unique_ptr<expr_istrue>;

    ast::expr expr;

    expr_istrue(ast::expr expr);
    expr_istrue(const location& loc, ast::expr expr);
    auto print() const -> std::string override;
};

struct expr_isdefined : public node
{
    using ptr = std::unique_ptr<expr_isdefined>;

    ast::expr expr;

    expr_isdefined(ast::expr expr);
    expr_isdefined(const location& loc, ast::expr expr);
    auto print() const -> std::string override;
};

struct expr_arguments : public node
{
    using ptr = std::unique_ptr<expr_arguments>;

    std::vector<expr> list;

    expr_arguments();
    expr_arguments(const location& loc);
    auto print() const -> std::string override;
};

struct expr_parameters : public node
{
    using ptr = std::unique_ptr<expr_parameters>;

    std::vector<expr_identifier::ptr> list;

    expr_parameters();
    expr_parameters(const location& loc);
    auto print() const -> std::string override;
};

struct expr_add_array : public node
{
    using ptr = std::unique_ptr<expr_add_array>;

    expr_arguments::ptr args;

    expr_add_array(expr_arguments::ptr args);
    expr_add_array(const location& loc, expr_arguments::ptr args);
    auto print() const -> std::string override;
};

struct expr_pointer : public node
{
    using ptr = std::unique_ptr<expr_pointer>;

    expr func;
    expr_arguments::ptr args;
    call::mode mode;

    expr_pointer(expr func, expr_arguments::ptr args, call::mode mode);
    expr_pointer(const location& loc, expr func, expr_arguments::ptr args, call::mode mode);
    auto print() const -> std::string override;
};

struct expr_function : public node
{
    using ptr = std::unique_ptr<expr_function>;

    expr_path::ptr path;
    expr_identifier::ptr name;
    expr_arguments::ptr args;
    call::mode mode;

    expr_function(expr_path::ptr path, expr_identifier::ptr name, expr_arguments::ptr args, call::mode mode);
    expr_function(const location& loc, expr_path::ptr path, expr_identifier::ptr name, expr_arguments::ptr args, call::mode mode);
    auto print() const -> std::string override;
};

struct expr_method : public node
{
    using ptr = std::unique_ptr<expr_method>;

    expr obj;
    ast::call call;

    expr_method(expr obj, ast::call call);
    expr_method(const location& loc, expr obj, ast::call call);
    auto print() const -> std::string override;
};

struct expr_call : public node
{
    using ptr = std::unique_ptr<expr_call>;

    ast::call call;

    expr_call(ast::call call);
    expr_call(const location& loc, ast::call call);
    auto print() const -> std::string override;
};

struct expr_complement : public node
{
    using ptr = std::unique_ptr<expr_complement>;

    expr rvalue;

    expr_complement(expr rvalue);
    expr_complement(const location& loc, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_not : public node
{
    using ptr = std::unique_ptr<expr_not>;

    expr rvalue;

    expr_not(expr rvalue);
    expr_not(const location& loc, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_binary : public node
{
    using ptr = std::unique_ptr<expr_binary>;

    expr lvalue;
    expr rvalue;

    expr_binary(ast::kind kind, expr lvalue, expr rvalue);
    expr_binary(ast::kind kind, const location& loc, expr lvalue, expr rvalue);
    virtual auto print() const -> std::string = 0;
};

struct expr_add : public expr_binary
{
    using ptr = std::unique_ptr<expr_add>;

    expr_add(expr lvalue, expr rvalue);
    expr_add(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_sub : public expr_binary
{
    using ptr = std::unique_ptr<expr_sub>;

    expr_sub(expr lvalue, expr rvalue);
    expr_sub(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_mul : public expr_binary
{
    using ptr = std::unique_ptr<expr_mul>;

    expr_mul(expr lvalue, expr rvalue);
    expr_mul(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_div : public expr_binary
{
    using ptr = std::unique_ptr<expr_div>;

    expr_div(expr lvalue, expr rvalue);
    expr_div(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_mod : public expr_binary
{
    using ptr = std::unique_ptr<expr_mod>;

    expr_mod(expr lvalue, expr rvalue);
    expr_mod(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_shift_left : public expr_binary
{
    using ptr = std::unique_ptr<expr_shift_left>;

    expr_shift_left(expr lvalue, expr rvalue);
    expr_shift_left(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_shift_right : public expr_binary
{
    using ptr = std::unique_ptr<expr_shift_right>;

    expr_shift_right(expr lvalue, expr rvalue);
    expr_shift_right(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_bitwise_or : public expr_binary
{
    using ptr = std::unique_ptr<expr_bitwise_or>;

    expr_bitwise_or(expr lvalue, expr rvalue);
    expr_bitwise_or(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_bitwise_and : public expr_binary
{
    using ptr = std::unique_ptr<expr_bitwise_and>;

    expr_bitwise_and(expr lvalue, expr rvalue);
    expr_bitwise_and(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_bitwise_exor : public expr_binary
{
    using ptr = std::unique_ptr<expr_bitwise_exor>;

    expr_bitwise_exor(expr lvalue, expr rvalue);
    expr_bitwise_exor(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_equality : public expr_binary
{
    using ptr = std::unique_ptr<expr_equality>;

    expr_equality(expr lvalue, expr rvalue);
    expr_equality(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_inequality : public expr_binary
{
    using ptr = std::unique_ptr<expr_inequality>;

    expr_inequality(expr lvalue, expr rvalue);
    expr_inequality(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_less_equal : public expr_binary
{
    using ptr = std::unique_ptr<expr_less_equal>;

    expr_less_equal(expr lvalue, expr rvalue);
    expr_less_equal(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_greater_equal : public expr_binary
{
    using ptr = std::unique_ptr<expr_greater_equal>;

    expr_greater_equal(expr lvalue, expr rvalue);
    expr_greater_equal(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_less : public expr_binary
{
    using ptr = std::unique_ptr<expr_less>;

    expr_less(expr lvalue, expr rvalue);
    expr_less(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_greater : public expr_binary
{
    using ptr = std::unique_ptr<expr_greater>;

    expr_greater(expr lvalue, expr rvalue);
    expr_greater(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_or : public expr_binary
{
    using ptr = std::unique_ptr<expr_or>;

    expr_or(expr lvalue, expr rvalue);
    expr_or(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_and : public expr_binary
{
    using ptr = std::unique_ptr<expr_and>;

    expr_and(expr lvalue, expr rvalue);
    expr_and(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_ternary : public node
{
    using ptr = std::unique_ptr<expr_ternary>;

    expr test;
    expr true_expr;
    expr false_expr;

    expr_ternary(expr test, expr true_expr, expr false_expr);
    expr_ternary(const location& loc, expr test, expr true_expr, expr false_expr);
    auto print() const -> std::string override;
};

struct expr_increment : node
{
    using ptr = std::unique_ptr<expr_increment>;

    expr lvalue;
    bool prefix;

    expr_increment(expr lvalue, bool prefix);
    expr_increment(const location& loc, expr lvalue, bool prefix);
    auto print() const -> std::string override;
};

struct expr_decrement : node
{
    using ptr = std::unique_ptr<expr_decrement>;

    expr lvalue;
    bool prefix;

    expr_decrement(expr lvalue, bool prefix);
    expr_decrement(const location& loc, expr lvalue, bool prefix);
    auto print() const -> std::string override;
};

struct expr_assign : public node
{
    using ptr = std::unique_ptr<expr_assign>;

    expr lvalue;
    expr rvalue;

    expr_assign(ast::kind kind, expr lvalue, expr rvalue);
    expr_assign(ast::kind kind, const location& loc, expr lvalue, expr rvalue);
    virtual auto print() const -> std::string = 0;
};

struct expr_assign_equal : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_equal>;

    expr_assign_equal(expr lvalue, expr rvalue);
    expr_assign_equal(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_assign_add : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_add>;

    expr_assign_add(expr lvalue, expr rvalue);
    expr_assign_add(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_assign_sub : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_sub>;

    expr_assign_sub(expr lvalue, expr rvalue);
    expr_assign_sub(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_assign_mul : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_mul>;

    expr_assign_mul(expr lvalue, expr rvalue);
    expr_assign_mul(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_assign_div : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_div>;

    expr_assign_div(expr lvalue, expr rvalue);
    expr_assign_div(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_assign_mod : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_mod>;

    expr_assign_mod(expr lvalue, expr rvalue);
    expr_assign_mod(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_assign_shift_left : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_shift_left>;

    expr_assign_shift_left(expr lvalue, expr rvalue);
    expr_assign_shift_left(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_assign_shift_right : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_shift_right>;

    expr_assign_shift_right(expr lvalue, expr rvalue);
    expr_assign_shift_right(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_assign_bitwise_or : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_bitwise_or>;

    expr_assign_bitwise_or(expr lvalue, expr rvalue);
    expr_assign_bitwise_or(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_assign_bitwise_and : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_bitwise_and>;

    expr_assign_bitwise_and(expr lvalue, expr rvalue);
    expr_assign_bitwise_and(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct expr_assign_bitwise_exor : public expr_assign
{
    using ptr = std::unique_ptr<expr_assign_bitwise_exor>;

    expr_assign_bitwise_exor(expr lvalue, expr rvalue);
    expr_assign_bitwise_exor(const location& loc, expr lvalue, expr rvalue);
    auto print() const -> std::string override;
};

struct stmt_list : public node
{
    using ptr = std::unique_ptr<stmt_list>;

    std::vector<stmt> list;
    bool is_case = false;
    bool is_expr = false;

    stmt_list();
    stmt_list(const location& loc);
    auto print() const -> std::string override;
};

struct stmt_expr : public node
{
    using ptr = std::unique_ptr<stmt_expr>;

    ast::expr expr;

    stmt_expr(ast::expr expr);
    stmt_expr(const location& loc, ast::expr expr);
    auto print() const -> std::string override;
};

struct stmt_call : public node
{
    using ptr = std::unique_ptr<stmt_call>;

    ast::expr expr;

    stmt_call(ast::expr expr);
    stmt_call(const location& loc, ast::expr expr);
    auto print() const -> std::string override;
};

struct stmt_assign : public node
{
    using ptr = std::unique_ptr<stmt_assign>;

    ast::expr expr;

    stmt_assign(ast::expr expr);
    stmt_assign(const location& loc, ast::expr expr);
    auto print() const -> std::string override;
};

struct stmt_endon : public node
{
    using ptr = std::unique_ptr<stmt_endon>;

    expr obj;
    expr event;

    stmt_endon(expr obj, expr event);
    stmt_endon(const location& loc, expr obj, expr event);
    auto print() const -> std::string override;
};

struct stmt_notify : public node
{
    using ptr = std::unique_ptr<stmt_notify>;

    expr obj;
    expr event;
    expr_arguments::ptr args;

    stmt_notify(expr obj, expr event, expr_arguments::ptr args);
    stmt_notify(const location& loc, expr obj, expr event, expr_arguments::ptr args);
    auto print() const -> std::string override;
};

struct stmt_wait : public node
{
    using ptr = std::unique_ptr<stmt_wait>;

    expr time;

    stmt_wait(expr time);
    stmt_wait(const location& loc, expr time);
    auto print() const -> std::string override;
};

struct stmt_waittill : public node
{
    using ptr = std::unique_ptr<stmt_waittill>;

    expr obj;
    expr event;
    expr_arguments::ptr args;

    stmt_waittill(expr obj, expr event, expr_arguments::ptr params);
    stmt_waittill(const location& loc, expr obj, expr event, expr_arguments::ptr args);
    auto print() const -> std::string override;
};

struct stmt_waittillmatch : public node
{
    using ptr = std::unique_ptr<stmt_waittillmatch>;

    expr obj;
    expr event;
    expr_arguments::ptr args;

    stmt_waittillmatch(expr obj, expr event, expr_arguments::ptr args);
    stmt_waittillmatch(const location& loc, expr obj, expr expr, expr_arguments::ptr args);
    auto print() const -> std::string override;
};

struct stmt_waittillframeend : public node
{
    using ptr = std::unique_ptr<stmt_waittillframeend>;

    stmt_waittillframeend();
    stmt_waittillframeend(const location& loc);

    auto print() const -> std::string override;
};

struct stmt_waitframe : public node
{
    using ptr = std::unique_ptr<stmt_waitframe>;

    stmt_waitframe();
    stmt_waitframe(const location& loc);
    auto print() const -> std::string override;
};

struct stmt_if : public node
{
    using ptr = std::unique_ptr<stmt_if>;

    expr test;
    ast::stmt stmt;
    block::ptr blk;

    stmt_if(expr test, ast::stmt stmt);
    stmt_if(const location& loc, expr test, ast::stmt stmt);
    auto print() const -> std::string override;
};

struct stmt_ifelse : public node
{
    using ptr = std::unique_ptr<stmt_ifelse>;

    expr test;
    stmt stmt_if;
    stmt stmt_else;
    block::ptr blk_if;
    block::ptr blk_else;

    stmt_ifelse(expr test, stmt stmt_if, stmt stmt_else);
    stmt_ifelse(const location& loc, expr test, stmt stmt_if, stmt stmt_else);
    auto print() const -> std::string override;
};

struct stmt_while : public node
{
    using ptr = std::unique_ptr<stmt_while>;

    expr test;
    ast::stmt stmt;
    block::ptr blk;

    stmt_while(expr test, ast::stmt stmt);
    stmt_while(const location& loc, expr test, ast::stmt stmt);
    auto print() const -> std::string override;
};

struct stmt_dowhile : public node
{
    using ptr = std::unique_ptr<stmt_dowhile>;

    expr test;
    ast::stmt stmt;
    block::ptr blk;

    stmt_dowhile(expr test, ast::stmt stmt);
    stmt_dowhile(const location& loc, expr test, ast::stmt stmt);
    auto print() const -> std::string override;
};

struct stmt_for : public node
{
    using ptr = std::unique_ptr<stmt_for>;

    ast::stmt init;
    ast::expr test;
    ast::stmt iter;
    ast::stmt stmt;
    block::ptr blk;
    block::ptr blk_iter;
    std::vector<std::string> vars;

    stmt_for(ast::stmt init, expr test, ast::stmt iter, ast::stmt stmt);
    stmt_for(const location& loc, ast::stmt init, expr test, ast::stmt iter, ast::stmt stmt);
    auto print() const -> std::string override;
};

struct stmt_foreach : public node
{
    using ptr = std::unique_ptr<stmt_foreach>;

    ast::expr array_expr;
    ast::expr value_expr;
    ast::expr key_expr;
    ast::expr array;
    ast::stmt pre_expr;
    ast::expr cond_expr;
    ast::stmt post_expr;
    ast::stmt stmt0;
    ast::stmt stmt;
    block::ptr ctx;
    block::ptr ctx_post;
    bool use_key;
    std::vector<std::string> vars;

    stmt_foreach(const location& loc, ast::stmt stmt, bool use_key);
    stmt_foreach(ast::expr element, ast::expr container, ast::stmt stmt);
    stmt_foreach(ast::expr key, ast::expr element, ast::expr container, ast::stmt stmt);
    stmt_foreach(const location& loc, ast::expr element, ast::expr container, ast::stmt stmt);
    stmt_foreach(const location& loc, ast::expr key, ast::expr element, ast::expr container, ast::stmt stmt);
    auto print() const -> std::string override;
};

struct stmt_switch : public node
{
    using ptr = std::unique_ptr<stmt_switch>;

    expr test;
    stmt_list::ptr stmt;
    block::ptr ctx;

    stmt_switch(expr test, stmt_list::ptr stmt);
    stmt_switch(const location& loc, expr test, stmt_list::ptr stmt);
    auto print() const -> std::string override;
};

struct stmt_case : public node
{
    using ptr = std::unique_ptr<stmt_case>;

    expr label;
    stmt_list::ptr stmt;
    block::ptr blk;

    stmt_case(expr label);
    stmt_case(const location& loc, expr label);
    stmt_case(const location& loc, expr label, stmt_list::ptr stmt);
    auto print() const -> std::string override;
};

struct stmt_default : public node
{
    using ptr = std::unique_ptr<stmt_default>;

    stmt_list::ptr stmt;
    block::ptr blk;

    stmt_default();
    stmt_default(const location& loc);
    stmt_default(const location& loc, stmt_list::ptr stmt);
    auto print() const -> std::string override;
};

struct stmt_break : public node
{
    using ptr = std::unique_ptr<stmt_break>;

    stmt_break();
    stmt_break(const location& loc);
    auto print() const -> std::string override;
};

struct stmt_continue : public node
{
    using ptr = std::unique_ptr<stmt_continue>;

    stmt_continue();
    stmt_continue(const location& loc);
    auto print() const -> std::string override;
};

struct stmt_return : public node
{
    using ptr = std::unique_ptr<stmt_return>;

    ast::expr expr;

    stmt_return(ast::expr expr);
    stmt_return(const location& loc, ast::expr expr);

    auto print() const -> std::string override;
};

struct stmt_breakpoint : public node
{
    using ptr = std::unique_ptr<stmt_breakpoint>;

    stmt_breakpoint();
    stmt_breakpoint(const location& loc);
    auto print() const -> std::string override;
};

struct stmt_prof_begin : public node
{
    using ptr = std::unique_ptr<stmt_prof_begin>;

    expr_arguments::ptr args;

    stmt_prof_begin(expr_arguments::ptr args);
    stmt_prof_begin(const location& loc, expr_arguments::ptr args);
    auto print() const -> std::string override;
};

struct stmt_prof_end : public node
{
    using ptr = std::unique_ptr<stmt_prof_end>;

    expr_arguments::ptr args;

    stmt_prof_end(expr_arguments::ptr args);
    stmt_prof_end(const location& loc, expr_arguments::ptr args);
    auto print() const -> std::string override;
};

struct decl_thread : public node
{
    using ptr = std::unique_ptr<decl_thread>;

    expr_identifier::ptr name;
    expr_parameters::ptr params;
    stmt_list::ptr stmt;

    decl_thread(expr_identifier::ptr name, expr_parameters::ptr params, stmt_list::ptr stmt);
    decl_thread(const location& loc, expr_identifier::ptr name, expr_parameters::ptr params, stmt_list::ptr stmt);
    auto print() const -> std::string override;
};

struct decl_constant : public node
{
    using ptr = std::unique_ptr<decl_constant>;

    expr_identifier::ptr name;
    expr value;

    decl_constant(expr_identifier::ptr name, expr value);
    decl_constant(const location& loc, expr_identifier::ptr name, expr value);
    auto print() const -> std::string override;
};

struct decl_usingtree : public node
{
    using ptr = std::unique_ptr<decl_usingtree>;

    expr_string::ptr name;

    decl_usingtree(expr_string::ptr name);
    decl_usingtree(const location& loc, expr_string::ptr name);
    auto print() const -> std::string override;
};

struct decl_dev_begin : public node
{
    using ptr = std::unique_ptr<decl_dev_begin>;

    decl_dev_begin();
    decl_dev_begin(const location& loc);
    auto print() const -> std::string override;
};

struct decl_dev_end : public node
{
    using ptr = std::unique_ptr<decl_dev_end>;

    decl_dev_end();
    decl_dev_end(const location& loc);
    auto print() const -> std::string override;
};

struct include : public node
{
    using ptr = std::unique_ptr<include>;

    expr_path::ptr path;

    include(expr_path::ptr path);
    include(const location& loc, expr_path::ptr path);
    auto print() const -> std::string override;
};

struct program : public node
{
    using ptr = std::unique_ptr<program>;

    std::vector<include::ptr> includes;
    std::vector<decl> declarations;

    program();
    program(const location& loc);
    auto print() const -> std::string override;
};

struct asm_loc : public node
{
    using ptr = std::unique_ptr<asm_loc>;

    std::string value;

    asm_loc(const std::string& value);
    asm_loc(const location& loc, const std::string& value);
    auto print() const -> std::string override;
};

struct asm_jump : public node
{
    using ptr = std::unique_ptr<asm_jump>;

    std::string value;

    asm_jump(const std::string& value);
    asm_jump(const location& loc, const std::string& value);
    auto print() const -> std::string override;
};

struct asm_jump_back : public node
{
    using ptr = std::unique_ptr<asm_jump_back>;

    std::string value;

    asm_jump_back(const std::string& value);
    asm_jump_back(const location& loc, const std::string& value);
    auto print() const -> std::string override;
};

struct asm_jump_cond : public node
{
    using ptr = std::unique_ptr<asm_jump_cond>;

    std::string value;
    ast::expr expr;

    asm_jump_cond(ast::expr expr, const std::string& value);
    asm_jump_cond(const location& loc, ast::expr expr, const std::string& value);
    auto print() const -> std::string override;
};

struct asm_jump_true_expr : public node
{
    using ptr = std::unique_ptr<asm_jump_true_expr>;

    ast::expr expr;
    std::string value;

    asm_jump_true_expr(ast::expr expr, const std::string& value);
    asm_jump_true_expr(const location& loc, ast::expr expr, const std::string& value);
    auto print() const -> std::string override;
};

struct asm_jump_false_expr : public node
{
    using ptr = std::unique_ptr<asm_jump_false_expr>;

    ast::expr expr;
    std::string value;

    asm_jump_false_expr(ast::expr expr, const std::string& value);
    asm_jump_false_expr(const location& loc, ast::expr expr, const std::string& value);
    auto print() const -> std::string override;
};

struct asm_switch : public node
{
    using ptr = std::unique_ptr<asm_switch>;

    ast::expr expr;
    std::string value;

    asm_switch(ast::expr expr, const std::string& value);
    asm_switch(const location& loc, ast::expr expr, const std::string& value);
    auto print() const -> std::string override;
};

struct asm_endswitch : public node
{
    using ptr = std::unique_ptr<asm_endswitch>;

    std::vector<std::string> data;
    std::string count;

    asm_endswitch(std::vector<std::string> data, const std::string& count);
    asm_endswitch(const location& loc, std::vector<std::string> data, const std::string& count);
    auto print() const -> std::string override;
};

struct asm_prescriptcall : public node
{
    using ptr = std::unique_ptr<asm_prescriptcall>;

    asm_prescriptcall();
    asm_prescriptcall(const location& loc);
    auto print() const -> std::string override;
};

struct asm_voidcodepos : public node
{
    using ptr = std::unique_ptr<asm_voidcodepos>;

    asm_voidcodepos();
    asm_voidcodepos(const location& loc);
    auto print() const -> std::string override;
};

struct asm_create : public node
{
    using ptr = std::unique_ptr<asm_create>;

    std::string index;
    std::vector<std::string> vars;

    asm_create(const std::string& index);
    asm_create(const location& loc, const std::string& index);
    auto print() const -> std::string override;
};

struct asm_access : public node
{
    using ptr = std::unique_ptr<asm_access>;

    std::string index;

    asm_access(const std::string& index);
    asm_access(const location& loc, const std::string& index);
    auto print() const -> std::string override;
};

struct asm_remove : public node
{
    using ptr = std::unique_ptr<asm_remove>;

    std::string index;

    asm_remove(const std::string& index);
    asm_remove(const location& loc, const std::string& index);
    auto print() const -> std::string override;
};

struct asm_clear : public node
{
    using ptr = std::unique_ptr<asm_clear>;

    std::string index;

    asm_clear(const std::string& index);
    asm_clear(const location& loc, const std::string& index);
    auto print() const -> std::string override;
};

} // namespace xsk::gsc::ast