package ast

import "../token"
import "core:bytes"

THIRTY_TWO_KILOBYTES := 262144

Node :: union {
	Program,
	Statement,
	Expression,
}

Program :: struct {
	statements: []Statement,
}

Statement :: union {
	Let_Statement,
    Return_Statement,
}

Let_Statement :: struct {
	token: token.Token,
	name:  Identifier,
	value: Expression,
}

Return_Statement :: struct {
    token: token.Token,
    return_value: Expression,
}

Expression_Statement :: struct {
    token: token.Token,
    expression: Expression,
}

Expression :: union {
	Identifier,
}

Identifier :: struct {
	token: token.Token,
	value: string,
}


token_literal :: proc(node: Node) -> (literal: string) {
	switch n in node {
	case Program:
		if len(n.statements) > 0 {
			stmt: Node = n.statements[0]
			literal = token_literal(stmt)
		}
	case Statement:
		switch s in n {
		case Let_Statement:
			literal = token.literal(s.token)
        case Return_Statement:
            literal = token.literal(s.token)
        case Expression_Statement:
            literal = token.literal(s.token)
		}
	case Expression:
		switch e in n {
		case Identifier:
			literal = token.literal(e.token)
		}
	}
	return literal
}

node_to_string :: proc(node: Node) -> string {
    out: bytes.Buffer
    bytes.buffer_init_allocator(&out, 4, THIRTY_TWO_KILOBYTES, context.temp_allocator)

	switch n in node {
	case Program:
        for stmt in n {
            bytes.buffer_write_string(&out, node_to_string(n))
        }
	case Statement:
		switch s in n {
		case Let_Statement:
			bytes.buffer_write_string(&out, token.literal(s.token) + " ")
			bytes.buffer_write_string(&out, node_to_string(s.name))
			bytes.buffer_write_string(&out, " = ")
            if s.value != nil {
                bytes.buffer_write_string(&out, node_to_string(s.value))
            }
            bytes.buffer_write_string(&out, ";")
        case Return_Statement:
			bytes.buffer_write_string(&out, token.literal(s.token) + " ")
            if s.return_value != nil {
                bytes.buffer_write_string(&out, node_to_string(s.return_value))
            }
        case Expression_Statement:
            if s.expression != nil {
                bytes.buffer_write_string(&out, node_to_string(s.expression))
            }
		}
	case Expression:
		switch e in n {
		case Identifier:
			literal = token.literal(e.token)
		}
	}

	return bytes.buffer_to_string(&out)
}