/**************************************************************************
*  Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer,        *
*  Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe.   *
*                                                                         *
*  Merc Diku Mud improvements copyright (C) 1992, 1993 by Michael         *
*  Chastain, Michael Quan, and Mitchell Tse.                              *
*                                                                         *
*  In order to use any part of this Merc Diku Mud, you must comply with   *
*  both the original Diku license in 'license.doc' as well the Merc       *
*  license in 'license.txt'.  In particular, you may not remove either of *
*  these copyright notices.                                               *
*                                                                         *
*  Much time and thought has gone into this software and you are          *
*  benefiting.  We hope that you share your changes too.  What goes       *
*  around, comes around.                                                  *
***************************************************************************
*       ROM 2.4 is copyright 1993-1998 Russ Taylor                        *
*       ROM has been brought to you by the ROM consortium                 *
*           Russ Taylor (rtaylor@hypercube.org)                           *
*           Gabrielle Taylor (gtaylor@hypercube.org)                      *
*           Brian Moore (zump@rom.org)                                    *
*       By using this code, you have agreed to follow the terms of the    *
*       ROM license, in the file Rom24/doc/rom.license                    *
***************************************************************************
*       1stMUD ROM Derivative (c) 2001-2002 by Ryan Jennings              *
*            http://1stmud.dlmud.com/  <r-jenn@shaw.ca>                   *
***************************************************************************/
#include <sys/types.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include "merc.h"
#include "interp.h"
#include "olc.h"
#include "tables.h"

const char *do_fun_name args((DO_FUN * fun));
DO_FUN *do_fun_lookup args((const char *name));

#define CMDEDIT(fun)    bool fun (CHAR_DATA *ch, const char *argument)

CH_CMD(do_cmdcheck)
{
	int i;
	DO_FUN *fun;
	bool found = FALSE;

	if (IS_NULLSTR(argument))
		chprintln(ch, "Syntax: cmdcheck null|missing|<do_fun_name>");
	else if (!str_prefix(argument, "null"))
	{
		chprintln(ch, "NULL commands:");
		for (i = 0; i < maxCommands; i++)
		{
			if (cmd_table[i].do_fun == do_null)
			{
				found = TRUE;
				chprintlnf(ch, "%s", cmd_table[i].name);
			}
		}
		if (!found)
			chprintln(ch, "None.");
	}
	else if (!str_prefix(argument, "missing"))
	{
		int cmd, pos = 0;
		bool any = FALSE;

		chprintln(ch, "Functions missing command entries:");
		for (i = 0; dofun_table[i].fun != NULL; i++)
		{
			found = FALSE;
			for (cmd = 0; cmd < maxCommands; cmd++)
			{
				if (dofun_table[i].fun == cmd_table[cmd].do_fun)
				{
					found = TRUE;
					break;
				}
			}
			if (!found)
			{
				any = TRUE;
				chprintf(ch, "%15s ", dofun_table[i].name);
				if (++pos % 4 == 0)
					chprintln(ch, "");
			}
		}
		if (pos % 4 != 0)
			chprintln(ch, "");
		if (!any)
			chprintln(ch, "None.");
	}
	else if ((fun = do_fun_lookup(argument)) != NULL)
	{
		chprintlnf(ch, "%s commands:", argument);
		for (i = 0; i < maxCommands; i++)
		{
			if (cmd_table[i].do_fun == fun)
			{
				found = TRUE;
				chprintlnf(ch, "%s", cmd_table[i].name);
			}
		}
		if (!found)
			chprintln(ch, "None.");
	}
	return;
}

CMDEDIT(cmdedit_show)
{
	CMD_DATA *pCmd;

	EDIT_CMD(ch, pCmd);

	chprintln(ch, draw_line(NULL, 0));
	chprintlnf(ch, "Name      : %s", pCmd->name);
	chprintlnf(ch, "DoFun     : %s", do_fun_name(pCmd->do_fun));
	chprintlnf(ch, "Position  : %s",
			   flag_string(position_flags, pCmd->position));
	chprintlnf(ch, "Level     : %d", pCmd->level);
	chprintlnf(ch, "Log       : %s", flag_string(log_flags, pCmd->log));
	chprintlnf(ch, "fShow     : %s", !pCmd->show ? "FALSE" : "TRUE");
	chprintln(ch, draw_line(NULL, 0));
	return TRUE;
}

CMDEDIT(cmdedit_create)
{
	int j, i = maxCommands;
	CMD_DATA *pCmd;
	struct cmd_type *new_table;
	char buf[MIL];

	if (!IS_NULLSTR(argument) && command_lookup(argument) == -1)
		sprintf(buf, argument);
	else
		sprintf(buf, "New Command%d", maxCommands + 1);

	maxCommands++;

	alloc_mem(new_table, struct cmd_type, maxCommands + 1);

	if (!new_table)
	{
		chprintln(ch, "Memory Allocation Failed!!! Unable to create command.");
		return FALSE;
	}

	for (j = 0; j < i; j++)
		new_table[j] = cmd_table[j];

	free_mem(cmd_table);
	cmd_table = new_table;

	cmd_table[i].name = str_dup(buf);
	cmd_table[i].do_fun = do_null;
	cmd_table[i].level = 0;
	cmd_table[i].position = POS_DEAD;
	cmd_table[i].show = TRUE;
	cmd_table[i].log = LOG_NORMAL;

	cmd_table[i + 1].name = str_dup("");

	pCmd = &cmd_table[i];
	edit_start(ch, pCmd, ED_CMD);
	chprintln(ch, "Command created.");
	return TRUE;
}

CMDEDIT(cmdedit_dofun)
{
	CMD_DATA *pCmd;
	DO_FUN *fun;

	EDIT_CMD(ch, pCmd);

	if (IS_NULLSTR(argument))
	{
		chprintln(ch, "Syntax: dofun <function>");
		return FALSE;
	}

	if (is_name(argument, "none clear reset"))
	{
		pCmd->do_fun = do_null;
		chprintln(ch, "Function entry reset.");
		return TRUE;
	}

	if ((fun = do_fun_lookup(argument)) == do_null)
	{
		chprintln
			(ch, "That is not a valid function (probably not coded in yet)");
		return FALSE;
	}

	pCmd->do_fun = fun;
	chprintlnf(ch, "%s now points to the %s function.", pCmd->name, argument);
	return TRUE;
}

CMDEDIT(cmdedit_delete)
{
	CMD_DATA *pCmd;

	EDIT_CMD(ch, pCmd);

	if (str_cmp(argument, "confirm"))
	{
		chprintln
			(ch,
			 "Typing 'delete confirm' again will permanetely remove this command!");
		return FALSE;
	}
	else

	{
		int i, j = 0, c;
		struct cmd_type *new_table;

		alloc_mem(new_table, struct cmd_type, maxCommands + 1);

		if (!new_table)
		{
			chprintln
				(ch, "Memory Allocation error!!! Unable to delete command.");
			return FALSE;
		}

		c = command_lookup(pCmd->name);

		for (i = 0; i < maxCommands; i++)
			if (i != c)
				new_table[j++] = cmd_table[i];

		free_mem(cmd_table);
		cmd_table = new_table;
		maxCommands--;

		pCmd = &cmd_table[0];
		edit_start(ch, pCmd, ED_CMD);
		chprintln(ch, "Command deleted.");
	}

	return TRUE;
}

CMDEDIT(cmdedit_rearrange)
{
	CMD_DATA *pCmd;
	int x;
	int i, c;
	CMD_DATA *new_table;
	bool found = FALSE;

	EDIT_CMD(ch, pCmd);

	if (IS_NULLSTR(argument))
	{
		chprintln(ch, "Syntax: cmdedit rearrange <command to place before>");
		return FALSE;
	}

	if ((x = command_lookup(argument)) == -1)
	{
		chprintln(ch, "That is not a command.");
		return FALSE;
	}

	c = command_lookup(pCmd->name);

	if (x == c)
	{
		chprintln(ch, "Can't rearrange the same command.");
		return FALSE;
	}

	if (c < x)
	{
		chprintlnf(ch, "Error: command %s is already above %s.",
				   cmd_table[c].name, cmd_table[x].name);
		return FALSE;
	}

	alloc_mem(new_table, struct cmd_type, maxCommands);

	if (!new_table)
	{
		chprintln(ch, "Memory Allocation error!!! Unable to delete command.");
		return FALSE;
	}

	for (i = 0; i < maxCommands; i++)
	{
		if (found)
		{
			new_table[i] = cmd_table[i - 1];
			continue;
		}
		if (i + 1 == x)
		{
			new_table[i] = cmd_table[c];
			i++;
			new_table[i] = cmd_table[i - 1];
			found = TRUE;
			continue;
		}
		new_table[i] = cmd_table[i];
	}
	free_mem(cmd_table);
	cmd_table = new_table;

	chprintln(ch, "Command moved.");

	return TRUE;
}