#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

#include "ast.h"

static void ast_print_dot_recursive(struct ast *node, FILE *out)
{
    if (!node)
        return;

    switch (node->type)
    {
    case AST_IF:
    {
        struct ast_if *if_data = ast_get_if(node);
        fprintf(out, "  node%p [label=\"IF\"];\n", (void *)node);

        if (if_data->condition)
        {
            fprintf(out, "  node%p -> node%p;\n", (void *)node,
                    (void *)if_data->condition);
            fprintf(out, "  node%p [fillcolor=\"lightyellow\", style=\"filled\"];\n",
                    (void *)if_data->condition);
            ast_print_dot_recursive(if_data->condition, out);

            if (if_data->then_clause)
            {
                fprintf(out, "  node%p -> node%p [label=\"true\"];\n",
                        (void *)if_data->condition, (void *)if_data->then_clause);
                ast_print_dot_recursive(if_data->then_clause, out);
            }

            if (if_data->else_clause)
            {
                fprintf(out, "  node%p -> node%p [label=\"false\"];\n",
                        (void *)if_data->condition, (void *)if_data->else_clause);
                ast_print_dot_recursive(if_data->else_clause, out);
            }
        }
        break;
    }
    case AST_CMD:
    {
        struct ast_cmd *cmd_data = ast_get_cmd(node);
        fprintf(out, "  node%p [label=\"", (void *)node);
        struct list *l = cmd_data->cmd;
        while (l)
        {
            fprintf(out, "%s", (char *)l->data);
            if (l->next)
                fprintf(out, " ");
            l = l->next;
        }
        fprintf(out, "\"];\n");
        break;
    }
    case AST_END:
        fprintf(out, "  node%p [label=\"END\"];\n", (void *)node);
        break;
    default:
        break;
    }
}

void ast_print_dot(struct ast *ast)
{
    // Always print to stdout so the user can see it in the terminal
    printf("digraph AST {\n");
    if (ast)
    {
        ast_print_dot_recursive(ast, stdout);
    }
    printf("}\n");

    if (!ast)
        return;

    FILE *dot_pipe = popen("dot -Tsvg -o ast.svg", "w");
    if (!dot_pipe)
    {
        return;
    }

    fprintf(dot_pipe, "digraph AST {\n");
    ast_print_dot_recursive(ast, dot_pipe);
    fprintf(dot_pipe, "}\n");
    pclose(dot_pipe);

    system("open ast.svg");
}

bool ast_is_if(struct ast *node)
{
    assert(node != NULL);
    return node->type == AST_IF;
}

bool ast_is_cmd(struct ast *node)
{
    assert(node != NULL);
    return node->type == AST_CMD;
}

struct ast_if *ast_get_if(struct ast *node)
{
    assert(node != NULL);
    assert(node->type == AST_IF);
    return (struct ast_if *)node->data;
}

struct ast_cmd *ast_get_cmd(struct ast *node)
{
    assert(node != NULL);
    assert(node->type == AST_CMD);
    return (struct ast_cmd *)node->data;
}

static struct ast *ast_create(enum ast_type type, void *data)
{
    struct ast *node = malloc(sizeof(struct ast));
    if (!node)
        return NULL;

    node->type = type;
    node->data = data;

    return node;
}

struct ast *ast_create_if(struct ast *condition, struct ast *then_clause,
                          struct ast *else_clause)
{
    struct ast_if *if_data = malloc(sizeof(struct ast_if));
    if (!if_data)
        return NULL;

    if_data->condition = condition;
    if_data->then_clause = then_clause;
    if_data->else_clause = else_clause;

    return ast_create(AST_IF, if_data);
}

struct ast *ast_create_cmd(struct list *cmd)
{
    struct ast_cmd *cmd_data = malloc(sizeof(struct ast_cmd));
    if (!cmd_data)
        return NULL;

    cmd_data->cmd = cmd;

    return ast_create(AST_CMD, cmd_data);
}