# pragma once

#include "../src/utils.h"


// Stage 1

typedef enum {
    PLUS,
    MINUS,
    MULT,
DIV,
} BinOp;

typedef enum {
    ARITHM_INT_LIT,
    ARITHM_BINOP,
} ArithmNodeKind;

typedef struct ArithmNode ArithmNode;
struct ArithmNode {
    ArithmNodeKind kind;
    union {
        int lit_val;
        IntVec open_fds;
        struct {
            BinOp op;
            ArithmNode* left;
            ArithmNode* right;
        } binop;
    } as;
};
DECLARE_VEC(ArithmNode, ArithmNodeVec)


typedef struct {
    ArithmNodeVec nodes;
    ArithmNode* root;
} ArithmAst;
 

typedef enum {
    UN_Q,
    SINGLE_Q,
    DOUBLE_Q,
} QuotationMode;

typedef enum {
    CHUNK_LIT,
    CHUNK_VAR,
    CHUNK_CMDSUB,
    CHUNK_ARITHM,
} ChunkKind;

typedef struct {
    QuotationMode qmode;
    ChunkKind kind;
    union {
        char* lit_str;
        char* varname;
        ArithmAst arithm_expr;
        // TODO: CHUNK_CMDSUB
    } as;
} Chunk;

DECLARE_VEC(Chunk, Word)


typedef enum {
    TOK_WORD,
    TOK_SPEC,
    TOK_SUB_IN,
    TOK_SUB_OUT,
} TokenKind;

typedef enum {
    SPEC_PIPE,
    SPEC_REDIR_W_TRUNC,
    SPEC_REDIR_W_APPEND,
    SPEC_REDIR_R,
    SPEC_EOL,
} SpecialToken;

typedef struct Token Token;
DECLARE_VEC(Token*, TokenPtrVec)

struct Token {
    TokenKind kind;
    union {
        Word word;
        SpecialToken spec;
        TokenPtrVec procsub_toks;
    } as;
};

DECLARE_VEC(Token, TokenVec)

typedef struct {
    TokenVec token_pool;
    TokenPtrVec top_tokens;
} Ast;



// Stage 2


typedef enum {
    REDIR_WRITE_TRUNC,
    REDIR_WRITE_APPEND,
    REDIR_READ,
    REDIR_FDS,
} RedirectKind;

typedef struct {
    RedirectKind kind;
    union {
        char* filename;
        struct{int from; int to;} fds; 
    } as;
} Redirect;

DECLARE_VEC(Redirect, RedirectVec)

typedef struct PlCommand PlCommand;

typedef enum {
    ARG_PS_IN,
    ARG_PS_OUT,
    ARG_LIT,
} ArgKind;

typedef struct {
    ArgKind kind;
    union {
        char* lit_str;
        PlCommand* sub_tree;
    } as;
} Arg;

DECLARE_VEC(Arg, ArgVec)


typedef enum {
    CONN_PIPE,
    CONN_EOL,
} Connector;

struct PlCommand {
    ArgVec args;
    RedirectVec redirects;
    Connector conn;
};

DECLARE_VEC(PlCommand, Pipeline)



// Stage 3

typedef struct {
    int redirected;
    int to;
} FdRedirect;

DECLARE_VEC(FdRedirect, FdRedirectVec)

typedef struct {
    char** args;
    FdRedirectVec redirects;
    int stdin_fd, stdout_fd;
    IntVec open_fds;
} ExecutableCommand;