#include "token.h"
#include "slice.h"
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>

Token *
token_create(Slice slice, unsigned int type)
{
	Token *token = malloc(sizeof(Token));
	if (token == NULL) {
		perror("token_create:malloc");
		return NULL;
	}
	token->slice = slice;
	token->type = type;
	token->prev = NULL;
	token->next = NULL;
	return token;
}

void
token_destroy(Token *token)
{
	while (token != NULL) {
		Token *next = token->next;
		if (token->type == TOK_GROUP) {
			token_destroy(token->group.tokens);
			token_destroy(token->group.scope);
		}
		free(token);
		token = next;
	}
}

Token *
token_append(Token **list, Token *elem)
{
	if (*list == NULL) {
		*list = elem;
		return *list;
	}

	Token *end = token_last(*list);
	end->next = elem;
	elem->prev = end;
	return *list;
}

Token *
token_prepend(Token **list, Token *elem)
{
	elem->next = *list;
	if (*list)
		(*list)->prev = elem;
	*list = elem;
	return *list;
}

void
token_delete(Token **list, Token *elem)
{
	token_extract(list, elem);
	free(elem);
}

Token *
token_extract(Token **list, Token *elem)
{
	if (elem->prev != NULL)
		elem->prev->next = elem->next;
	if (elem->next != NULL)
		elem->next->prev = elem->prev;
	if (*list == elem)
		*list = elem->next;
	elem->prev = NULL;
	elem->next = NULL;
	return elem;
}

Token *
token_search(Token *list, unsigned int type)
{
	while (list != NULL) {
		if (list->type == type)
			return list;
		list = list->next;
	}
	return NULL;
}

Token *
token_search_closing(Token *list, unsigned int type, unsigned int opn)
{
	int count = 0;
	while (list != NULL) {
		if (list->type == opn)
			count += 1;
		if (list->type == type) {
			count -= 1;
			if (count <= 0)
				return list;
		}
		list = list->next;
	}
	return NULL;
}

Token *
token_print(Token *token, int recurse, int depth)
{
	Token *tok = token;
	while (token != NULL) {
		for (int i = 0; i < depth * 2; i++)
			putchar(' ');
		if (token->type == TOK_GROUP) {
			printf("type: TOK_GROUP  group.type: %c\n",
			       token->group.type);
			if (token->group.scope != NULL)
				token_print(token->group.scope, 1, depth);
			token_print(token->group.tokens, 1, depth + 1);
		} else {
			printf("type: %c  slice: ", token->type);
			slice_print(token->slice);
		}
		if (!recurse)
			return tok;
		token = token->next;
	}
	return tok;
}

int
token_isgroup(Token *token, unsigned int type)
{
	return (token->type == TOK_GROUP && token->group.type == type);
}

int
token_len(Token *token)
{
	int len = 0;
	while (token != NULL) {
		len += 1;
		token = token->next;
	}
	return len;
}

Token *
token_last(Token *token)
{
	if (token == NULL)
		return NULL;
	while (token->next != NULL)
		token = token->next;
	return token;
}