// Copyright (c) 2014 Alex Diener. All rights reserved.

#include "watertowerclassic/LevelSetModel.h"
#include <stdlib.h>
#include <string.h>

#define SUPERCLASS StemObject

LevelSetModel * LevelSetModel_create(const char * name) {
	stemobject_create_implementation(LevelSetModel, init, name)
}

LevelSetModel * LevelSetModel_copy(LevelSetModel * self) {
	stemobject_copy_implementation(LevelSetModel, initCopy)
}

static void sharedInit(LevelSetModel * self) {
	call_super(init, self);
	self->dispose = LevelSetModel_dispose;
}

#if defined(STEM_PLATFORM_win32) || defined(STEM_PLATFORM_win64)
static char * strndup(const char * s1, size_t n) {
	size_t len = 0;
	char * s2;
	
	while (len < n && s1[len] != 0) {
		len++;
	}
	s2 = malloc(len + 1);
	memcpy(s2, s1, len);
	s2[len] = 0;
	return s2;
}
#endif

bool LevelSetModel_init(LevelSetModel * self, const char * name) {
	sharedInit(self);
	self->levelCount = 0;
	self->levels = NULL;
	self->name = strndup(name, LEVEL_SET_NAME_MAX);
	return true;
}

bool LevelSetModel_initCopy(LevelSetModel * self, LevelSetModel * copy) {
	unsigned int levelIndex;
	
	sharedInit(self);
	self->levelCount = copy->levelCount;
	self->levels = malloc(sizeof(LevelModel *) * self->levelCount);
	self->name = strndup(copy->name, LEVEL_SET_NAME_MAX);
	
	for (levelIndex = 0; levelIndex < self->levelCount; levelIndex++) {
		self->levels[levelIndex] = LevelModel_copy(copy->levels[levelIndex]);
	}
	
	return true;
}

void LevelSetModel_dispose(LevelSetModel * self) {
	unsigned int levelIndex;
	
	for (levelIndex = 0; levelIndex < self->levelCount; levelIndex++) {
		self->levels[levelIndex]->dispose(self->levels[levelIndex]);
	}
	free(self->levels);
	free(self->name);
	call_super(dispose, self);
}

LevelModel * LevelSetModel_copyLevelAtIndex(LevelSetModel * self, unsigned int index) {
	if (index >= self->levelCount) {
		return NULL;
	}
	return LevelModel_copy(self->levels[index]);
}

void LevelSetModel_swapLevels(LevelSetModel * self, unsigned int index1, unsigned int index2) {
	LevelModel * level;
	
	if (index1 >= self->levelCount || index2 >= self->levelCount) {
		return;
	}
	level = self->levels[index1];
	self->levels[index1] = self->levels[index2];
	self->levels[index2] = level;
}

void LevelSetModel_addLevelAtIndex(LevelSetModel * self, LevelModel * newLevel, unsigned int index) {
	unsigned int index2;
	
	if (self->levelCount >= LEVEL_COUNT_MAX) {
		return;
	}
	self->levels = realloc(self->levels, sizeof(LevelModel *) * (self->levelCount + 1));
	for (index2 = self->levelCount; index2 > index; index2--) {
		self->levels[index2] = self->levels[index2 - 1];
	}
	self->levels[index] = newLevel;
	self->levelCount++;
}

void LevelSetModel_deleteLevelAtIndex(LevelSetModel * self, unsigned int index) {
	if (index >= self->levelCount || self->levelCount < 2) {
		return;
	}
	LevelModel_dispose(self->levels[index]);
	self->levelCount--;
	for (; index < self->levelCount; index++) {
		self->levels[index] = self->levels[index + 1];
	}
}