/**
 * Copyright 2013 (c) Anna Schumaker.
 */
extern "C" {
#include <core/collection.h>
#include <core/history.h>
}
#include <core/deck.h>
#include <core/file.h>

static std::list<struct queue *> queue_deck;
static struct file deck_file;


static unsigned int __tempq_index(struct queue *queue)
{
	unsigned int i = 0;
	std::list<struct queue *>::iterator it;

	for (it = queue_deck.begin(); it != queue_deck.end(); it++) {
		if (*it == queue)
			return i;
		i++;
	}

	return queue_deck.size();
}


void tempq_init(struct queue_ops *ops)
{
	unsigned int flags, count, j, id;
	unsigned int num, i;
	struct queue *queue;

	file_init(&deck_file, "deck", 1);
	if (!file_open(&deck_file, OPEN_READ))
		return;
	if (file_version(&deck_file) < 1)
		return;

	file_readf(&deck_file, "%u", &num);
	for (i = 0; i < num; i++) {
		file_readf(&deck_file, "%u %u", &flags, &count);
		queue = tempq_alloc(NULL, flags);
		for (j = 0; j < count; j++) {
			file_readf(&deck_file, "%u", &id);
			queue_add(queue, track_get(id));
		}
		queue_deck.back()->q_ops = ops;
	}
	file_close(&deck_file);
}

void tempq_deinit()
{
	while (queue_deck.size() > 0) {
		queue_deinit(*queue_deck.begin());
		delete *queue_deck.begin();
		queue_deck.erase(queue_deck.begin());
	}
}

void tempq_save(struct queue *queue, enum queue_flags flag)
{
	std::list<struct queue *>::iterator it;
	unsigned int i;

	if (!file_open(&deck_file, OPEN_WRITE))
		return;

	file_writef(&deck_file, "%zu\n", queue_deck.size());
	for (it = queue_deck.begin(); it != queue_deck.end(); it++) {
		file_writef(&deck_file, "%u %zu", (*it)->q_flags, queue_size(*it));
		for (i = 0; i < queue_size(*it); i++) {
			file_writef(&deck_file, " %u",
				    queue_at(*it, i)->tr_dbe.dbe_index);
		}
		file_writef(&deck_file, "\n");
	}

	file_close(&deck_file);
}

struct queue *tempq_alloc(struct queue_ops *ops, unsigned int flags)
{
	struct queue *queue = new struct queue;

	queue_deck.push_back(queue);
	queue_init(queue, flags | Q_ENABLED | Q_SAVE_FLAGS | Q_SAVE_SORT, ops);
	tempq_save(queue, Q_ENABLED);
	return queue;
}

void tempq_free(struct queue *queue)
{
	std::list<struct queue *>::iterator it;

	for (it = queue_deck.begin(); it != queue_deck.end(); it++) {
		if (*it == queue) {
			queue_deck.erase(it);
			tempq_save(queue, Q_ENABLED);
			queue_deinit(queue);
			delete queue;
			return;
		}
	}
	return;
}

struct queue *tempq_get(unsigned int index)
{
	std::list<struct queue *>::iterator it;
	unsigned int i;

	it = queue_deck.begin();
	for (i = 0; i < queue_deck.size(); i++) {
		if (i == index)
			return *it;
		it++;
	}
	return NULL;
}

void tempq_move(struct queue *queue, unsigned int index)
{
	unsigned int old_pos = __tempq_index(queue);
	std::list<struct queue *>::iterator it_old = queue_deck.begin();
	std::list<struct queue *>::iterator it_new = queue_deck.begin();

	for (unsigned int i = 0; i < queue_deck.size(); i++) {
		if (i < old_pos)
			it_old++;

		if (i < index)
			it_new++;
	}

	if (index > old_pos)
		it_new++;

	queue_deck.splice(it_new, queue_deck, it_old);
	tempq_save(queue, Q_ENABLED);
}

struct track *tempq_next()
{
	struct track *track = NULL;
	std::list<struct queue *>::iterator it;

	for (it = queue_deck.begin(); it != queue_deck.end(); it++) {
		if (queue_has_flag(*it, Q_ENABLED) == false)
			continue;

		track = queue_next(*it);
		if (queue_size(*it) == 0)
			tempq_free(*it);
		break;
	}

	return track;
}

unsigned int tempq_count()
{
	return queue_deck.size();
}