/*
 * Copyright (C) 2002-2007 The Warp Rogue Team
 * Part of the Warp Rogue Project
 *
 * This software is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License.
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY.
 *
 * See the license.txt file for more details.
 */

/*
 * Module Name: Career
 * Description: -
 */

#define Uses_Ui
#define Uses_Util
#define Uses_DataFile
#define Uses_ProgramManager
#define Uses_Object
#define Uses_Stats
#define Uses_Perks
#define Uses_Faction
#define Uses_Inventory
#include "mheader.h"

#include "career.h"


#define N_CAREER_TYPES			2

#define CAREER_BOX_BUFFER_SIZE		32

#define CAREER_TYPE_NAME_SIZE		16



#if defined(DEBUG)

static void		career_validate(const CAREER *);

#endif

static void *		career_new(void);
static void		career_free(void *);





/*
 * career type names
 */
static const char	CareerTypeName[N_CAREER_TYPES]
				[CAREER_TYPE_NAME_SIZE] = {

	"Basic",
	"Advanced"

};



/*
 * the career box
 */
static BOX  *		CareerBox = NULL;

/*
 * direct link to career data for fast accesss
 */
static void **		Career;




/*
 * career template (default values)
 */
static const CAREER CareerTemplate = {

	/* NAME */ "",  /* COLOUR */ C_DEFAULT, /* DESCRIPTION */ "",
	/* TYPE */ CAREER_TYPE_BASIC,
	/* MAX STAT ADVANCE */ {0, 0, 0, 0, 0, 0, 0, 0, 0},
	/* PERKS */ {false,false,false,false,false,false,
	false,false,false,false,false,false,false,false,false,false,
	false,false,false,false,false,false,false,false,false,false,
	false,false,false,false,false,false,false,false,false,false,
	false,false,false,false,false,false,false,false,false},
	/* TRAPPINGS */ NULL, /* EXITS */ {"", "", "", "", ""}

};



/*
 * Career module init
 */
void career_init(void)
{

	CareerBox = box_new(career_new, career_free,
		CAREER_BOX_BUFFER_SIZE
	);
}



/*
 * Career module clean up
 */
void career_clean_up(void)
{

	if (CareerBox != NULL) {

		box_free(CareerBox);

		return;
	}
}



/*
 * adds a career to the career box
 */
CAREER * career_box_new_career(void)
{

	return box_new_item(CareerBox);
}



/*
 * optimizes the career box
 */
void career_box_optimize(void)
{

	box_optimize(CareerBox);

	Career = CareerBox->item;
}



/*
 * sets a character's career
 */
void career_set(CHARACTER *character, CAREER_INDEX career_index)
{
	const CAREER *career;

	career = get_career_pointer(career_index);

	character->career = career_index;

	character->colour = career->colour;
}



/*
 * returns a career pointer
 */
CAREER * get_career_pointer(CAREER_INDEX career_index)
{

	if (career_index == CAREER_NIL) {

		return NULL;
	}

	return Career[career_index];
}



/*
 * returns the number of available careers
 */
N_CAREERS get_n_careers(void)
{

	return CareerBox->current_size;
}



/*
 * checks whether a character has completed his current career or not
 */
bool career_completed(const CHARACTER *character)
{
	STAT i;
	CAREER *career;

	career = get_career_pointer(character->career);

	for (i = 0; i < MAX_STATS; i++) {

		if (character->stat[i].advance <
			career->max_stat_advance[i]) {

			return false;
		}
	}

	return true;
}



/*
 * the "Career" screen
 */
void career_screen(const CAREER *career)
{

	command_bar_set(1, CM_EXIT);

	render_career_screen(career);

	update_screen();

	command_bar_get_command();
}



/*
 * hands out the trappings of a career to the passed character
 */
void career_give_trappings(CHARACTER *character)
{
	const CAREER *career;
	OBJECT *object;
	LIST_NODE *node;

	career = get_career_pointer(character->career);

	for (node = career->trappings->head;
		node != NULL;
		node = node->next) {

		object = object_clone((OBJECT *)node->data);

		inventory_add(character, object);
	}
}



/*
 * name -> career index
 */
CAREER_INDEX name_to_career_index(const char *name)
{
	CAREER_INDEX i;

	for (i = 0; i < CareerBox->current_size; i++) {
		const CAREER *career;

		career = Career[i];

		if (strings_equal(name, career->name)) {

			return i;
		}
	}

	die("*** CORE ERROR *** invalid career: %s", name);

	return 0;
}



/*
 * returns the name of a career type
 */
const char * career_type_name(CAREER_TYPE career_type)
{

	return CareerTypeName[career_type];
}



/*
 * name -> career type
 */
CAREER_TYPE name_to_career_type(const char *name)
{
	CAREER_TYPE i;

	for (i = 0; i < N_CAREER_TYPES; i++) {

		if (strings_equal(name, CareerTypeName[i])) {

			return i;
		}
	}

	die("*** CORE ERROR *** invalid career type: %s", name);

	return 0;
}


#if defined(DEBUG)

/*
 * validates the content of the career box
 */
void career_box_validate(void)
{
	CAREER_INDEX i;

	for (i = 0; i < CareerBox->current_size; i++) {
		const CAREER *career;

		career = Career[i];

		career_validate(career);
	}
}

#endif


#if defined(DEBUG)

/*
 * validates a career
 */
static void career_validate(const CAREER *career)
{
	CAREER_EXIT_INDEX i;

	for (i = 0; i < MAX_CAREER_EXITS; i++) {

		if (is_empty_string(career->exit[i])) {

			break;
		}

		name_to_career_index(career->exit[i]);
	}
}

#endif



/*
 * allocs a career
 */
static void * career_new(void)
{
	CAREER *career;

	career = checked_malloc(sizeof *career);

	*career = CareerTemplate;

	career->trappings = list_new();

	return career;
}



/*
 * frees a career
 */
static void career_free(void *data)
{
	CAREER *career;

	career = (CAREER *)data;

	list_free_with(career->trappings,
		object_destroy
	);

	free(career);
}