/* ARISA - Chat Commands (Not Admin Ones)
 * Copyright (C) 2003, 2004 Carl Ritson
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include "arisa.h"
#include <stdarg.h>
#include <ctype.h>

/* prototypes */
static int cmd_list(chat_t *c, char **args, int no_args);
static int cmd_get(chat_t *c, char **args, int no_args);
static int cmd_lists(chat_t *c, char **args, int no_args);
static int cmd_chlist(chat_t *c, char **args, int no_args);
static int cmd_stats(chat_t *c, char **args, int no_args);
static int cmd_queues(chat_t *c, char **args, int no_args);
static int cmd_remove(chat_t *c, char **args, int no_args);
static int cmd_help(chat_t *c, char **args, int no_args);
static int cmd_commands(chat_t *c, char **args, int no_args);
static int cmd_exit(chat_t *c, char **args, int no_args);

/* command table */
static struct cmd_t {
	char *name;
	int (*func)(chat_t *, char **args, int no_args);
	int min_args;
	int max_args;
	char *help;
} cmds[] = {
{"ls",	cmd_list,	0,0,
	"ls - displays all the packs in the current packlist"},
{"dir",	cmd_list,	0,0,
	"ls - displays all the packs in the current packlist"},
{"get",		cmd_get,	1,1,
	"get <number> - queue/send a pack from the current packlist"},
{"lists",	cmd_lists,	0,0,
	"lists - displays all available packlists"},
{"chlist",	cmd_chlist,	1,1,
	"chlist <list> - changes current packlist"},
{"stats",	cmd_stats,	0,0,
	"stats - displays send and queue statistics for current packlist"},
{"queues",	cmd_queues,	0,0,
	"queues - displays your present queues"},
{"remove",	cmd_remove,	0,1,
	"remove [<label>] - removes all queues, or a specific queue label"},
{"help",	cmd_help,	0,1,
	"help <command> - displays help associated with a command"},
{"commands",	cmd_commands,	0,0,
	"commands - displays a list of available commands"},
{"exit",	cmd_exit,	0,0,
	"exit - end the chat session"},
{NULL}
};

static void chat_msg(chat_t *c, const char *format, ...) {
	char buffer[512], fmt[512];
	va_list va;

	snprintf(fmt,sizeof(fmt),"%s\n",format);
	
	va_start(va,format);
	vsnprintf(buffer,sizeof(buffer),fmt,va);
	va_end(va);

	pqueue_push_back(&c->msgqueue,xstrdup(buffer));
}

static int cmd_list(chat_t *c, char **args, int no_args) {
	packlist_t *list;
	
	LOCK(c);
	list = c->list.packlist;
	UNLOCK(c);
	if(list == NULL)
		return -1;
	
	LOCK(list);
	if(list->nolist > xtime() || list->deleted != 0) {
		chat_msg(c,"Listing presently disabled for: %s%s%s%s",
			list->name,
			list->nolist_reason != NULL ? " (" : "",
			list->nolist_reason != NULL ? list->nolist_reason : "",
			list->nolist_reason != NULL ? ")" : "");
		UNLOCK(list);
	} else {
		UNLOCK(list);
		packlist_xdl_body(list,&c->msgqueue,COLOUR_IRC,"","\n");
	}
	
	return 0;
}

static int cmd_get(chat_t *c, char **args, int no_args) {
	packlist_t *list;
	char	*p;
	pack_t	*spack;
	send_t	*ssend;
	queue_t *queue;
	int 	pack_no,tmp,retries;

	LOCK(c);
	list = c->list.packlist;
	UNLOCK(c);
	if(list == NULL)
		return -1;
	
	LOCK(list);
	if(list->nosend > xtime() || list->deleted != 0) {
		chat_msg(c,"Packlist %s is presently not accepting new sends or queues%s%s%s.",
			list->name,
			list->nosend_reason != NULL ? " (" : "",
			list->nosend_reason != NULL ? list->nosend_reason : "",
			list->nosend_reason != NULL ? ")" : "");
		UNLOCK(list);
		return 0;
	}

	if(args[0][0] == '#')
		pack_no = atoi(args[0] + 1);
	else
		pack_no = atoi(args[0]);

	if(pack_no < 1 || pack_no > list->no_packs) {
		UNLOCK(list);
		chat_msg(c,"Invalid Pack Number: %s",args[0]);
		return 0;
	}

	spack = pack_clone(list->packs[pack_no - 1]);
	queue = list->queue;
	retries = list->retries;
	UNLOCK(list);
	
	LOCK(c);
	ssend 		= alloc_send();
	ssend->pack	= spack;
	ssend->network	= c->network;
	ssend->host	= xstrdup(c->host);
	ssend->nick	= xstrdup(c->nick);
	ssend->queue	= queue;
	ssend->retries	= retries;
	UNLOCK(c);

	pack_ref(spack);
	tmp = queue_enqueue(queue,ssend,0,&p);
	RLOCK(spack);
	if(tmp == 0) {
		chat_msg(c,"Sending \"%s\".",spack->label);
		RUNLOCK(spack);
	} else if(tmp > 0) {
		chat_msg(c,"You are queued in position %d for \"%s\", to remove this queue type \"remove %s\".",
			tmp,spack->label,spack->label);
		RUNLOCK(spack);
	} else {
		chat_msg(c,"Send of \"%s\" Denied: %s.",
			spack->label,p);
		RUNLOCK(spack);
		free_send(ssend);
	}
	pack_deref(spack);
	
	return 0;
}

static int cmd_lists(chat_t *c, char **args, int no_args) {
	char buffer[512],nick[64],host[192],hostmask[256];
	network_t *net;
	int i,j,pos;
	
	LOCK(c);
	net = c->network;
	xstrncpy(nick,c->nick,sizeof(nick));
	xstrncpy(host,c->host != NULL ? c->host : "",sizeof(host));
	xstrncpy(hostmask,c->hostmask != NULL ? c->hostmask : "",
			sizeof(hostmask));
	UNLOCK(c);

	pos = IMIN(
		snprintf(buffer,sizeof(buffer),
			"You have access to the following packlists: "),
		sizeof(buffer)-1
	);
	
	LOCK(global);
	for(i = 0, j = 0; i < global->no_packlists; ++i) {
		if(packlist_check_access(global->packlists[i],net,
				host[0] != '\0' ? host : NULL,
				hostmask[0] != '\0' ? hostmask : NULL,nick)) {
			LOCK(global->packlists[i]);
			pos += IMIN(
				snprintf(buffer+pos,sizeof(buffer)-pos,
					"%s%s",
					j++ > 0 ? ", " : "",
					global->packlists[i]->name),
				sizeof(buffer)-pos-1
			);
			UNLOCK(global->packlists[i]);
		}
	}
	UNLOCK(global);
	
	chat_msg(c,"%s",buffer);
	return 0;
}

static int cmd_chlist(chat_t *c, char **args, int no_args) {
	char nick[64],host[192],hostmask[256];
	packlist_t *list;
	network_t *net;
	
	list = packlist_find(args[0]);
	if(list == NULL) {
		chat_msg(c,"Invalid List: %s",args[0]);
	} else {
		LOCK(c);
		net = c->network;
		xstrncpy(nick,c->nick,sizeof(nick));
		xstrncpy(host,c->host != NULL ? c->host : "",sizeof(host));
		xstrncpy(hostmask,c->hostmask != NULL ? c->hostmask : "",
				sizeof(hostmask));
		UNLOCK(c);
		if(!packlist_check_access(list,net,
				host[0] != '\0' ? host : NULL,
				hostmask[0] != '\0' ? hostmask : NULL,nick)) {
			chat_msg(c,"Invalid List: %s",args[0]);
		} else {
			LOCK(c);
			c->list.packlist = list;
			UNLOCK(c);
			chat_msg(c,"Current Packlist: %s",args[0]);
		}
	}
	return 0;
}

static int cmd_stats(chat_t *c, char **args, int no_args) {
	packlist_t *list;

	LOCK(c);
	list = c->list.packlist;
	UNLOCK(c);
	if(list == NULL)
		return -1;
	packlist_xdl_head(list,&c->msgqueue,COLOUR_IRC,"","\n",0);
	return 0;
}

static int cmd_queues(chat_t *c, char **args, int no_args) {
	network_t *net;
	char labelbuf[512],nick[32];
	int i,j,count = 0;
	
	LOCK(c);
	net = c->network;
	xstrncpy(nick,c->nick,sizeof(nick));
	UNLOCK(c);
	
	LOCK(global);
	for(i = 0; i < global->no_queues; ++i) {
		queue_t *q =  global->queues[i];
		LOCK(q);
		for(j = 0; j < q->no_qsends; ++j) {
			LOCK(q->qsends[j]);
			if(q->qsends[j]->network == net 
				&& irc_strcasecmp(q->qsends[j]->nick,nick) == 0) {
				RLOCK(q->qsends[j]->pack);
				colourise(COLOUR_IRC,labelbuf,sizeof(labelbuf),
						q->qsends[j]->pack->label);
				chat_msg(c,
					"You are queued for \"%s\", position %d of %d.",
					labelbuf,
					j+1,q->no_qsends);
				RUNLOCK(q->qsends[j]->pack);
				count++;
			}
			UNLOCK(q->qsends[j]);
		}
		UNLOCK(q);
	}
	UNLOCK(global);

	if(count == 0)
		chat_msg(c,"No queues found.");
	return 0;
}

static int cmd_remove(chat_t *c, char **args, int no_args) {
	packlist_t *list;
	network_t *net;
	char nick[32];
	int ret;
	
	LOCK(c);
	list = c->list.packlist;
	net = c->network;
	xstrncpy(nick,c->nick,sizeof(nick));
	UNLOCK(c);
	if(list == NULL)
		return -1;
	
	if(no_args == 1) {
		ret = queue_remove(NULL,NULL,net,nick,NULL,args[0],NULL);
		if(ret <= 0)
			chat_msg(c,"No matching queues found.");
		else
			chat_msg(c,"Removed %d matching queues.",ret);
	} else {
		ret = queue_remove(NULL,NULL,net,nick,NULL,NULL,NULL);
		if(ret == 0)
			chat_msg(c,"No queues found.");
		else
			chat_msg(c,"Removed %d queues.",ret);
	}
	return 0;
}

static int cmd_help(chat_t *c, char **args, int no_args) {
	struct cmd_t *cmd = NULL;
	char tofind[32];
	int i;
	
	if(no_args == 1)
		xstrncpy(tofind,args[0],sizeof(tofind));
	else
		strcpy(tofind,"help");
	
	for(i = 0; cmds[i].name != NULL && cmd == NULL; ++i) {
		if(strcmp(cmds[i].name,tofind) == 0)
			cmd = &cmds[i];
	}
	
	if(cmd == NULL)
		chat_msg(c,"Invalid command: %s",tofind);
	else if(cmd->help == NULL)
		chat_msg(c,"No help available for: %s",tofind);
	else
		chat_msg(c,"%s",cmd->help);
	
	return 0;
}

static int cmd_commands(chat_t *c, char **args, int no_args) {
	char buffer[512];
	int i,pos;
	
	pos = IMIN(
		snprintf(buffer,sizeof(buffer),"Commands Available: "),
		sizeof(buffer)-1
	);
	for(i = 0; cmds[i].name != NULL; ++i) {
		pos += IMIN(
			snprintf(buffer+pos,sizeof(buffer)-pos,"%s%s",
				i > 0 ? ", " : "",
				cmds[i].name),
			sizeof(buffer)-pos-1
		);
	}
	chat_msg(c,"%s",buffer);
	
	return 0;
}	

static int cmd_exit(chat_t *c, char **args, int no_args){
	LOCK(c);
	c->state = STATE_COMPLETE;
	UNLOCK(c);
	return -1;
}

static void welcome(chat_t *chat, const char *listname) {
	chat_msg(chat,"%s",ARISA_VERSION);
	cmd_commands(chat,NULL,0);
	
	if(listname != NULL)
		chat_msg(chat,"Current Pack List: %s",listname);
}

static void chat_log_cmd(chat_t *chat, const char *cmd) {
	char host[96],netname[64],nick[32];
	network_t *net;
	
	LOCK(chat);
	net = chat->network;
	xstrncpy(host,chat->host,sizeof(host));
	xstrncpy(nick,chat->nick,sizeof(nick));
	UNLOCK(chat);
	
	LOCK(net);
	xstrncpy(netname,net->name,sizeof(netname));
	UNLOCK(net);
	
	LOGTP(L_INT,"[%s:%s] (%s), Executes \"%s\"",netname,nick,host,cmd);
}

int chat_list_cmd(chat_t *chat, char *buffer) {
	struct cmd_t *cmd = NULL;
	packlist_t *list;
	char **args;
	int at_cmd_limit = 0;
	int i,j,no_args;
	
	irc_strip_colours(buffer);
	
	LOCK(chat);
	chat->last_contact = xtime();
	chat->list.commands++;
	list = chat->list.packlist;
	i = chat->list.commands;
	UNLOCK(chat);
	
	chat_log_cmd(chat,buffer);
	
	if(list == NULL)
		return 1;
	
	LOCK(list);
	j = list->command_limit;
	UNLOCK(list);
	if(j != 0 && i >= j) {
		LOCK(chat);
		if(i > j)
			chat->state = STATE_COMPLETE;
		else
			chat->state = STATE_COMPLETING;
		UNLOCK(chat);
		if(i > j)
			return -1;
		else
			at_cmd_limit = 1;
	}
	
	for(j = 0; buffer[j] != '\0'; ++j) {
		if(isspace(buffer[j]))
			break;
	}
	
	for(i = 0; cmds[i].name != NULL && cmd == NULL; ++i) {
		if(strncasecmp(cmds[i].name,buffer,j) == 0)
			cmd = &cmds[i];
	}
	
	if(cmd == NULL) {
		chat_msg(chat,"Unknown Command.");
		return 0;
	}
	
	if(cmd->max_args == 0)
		i = cmd->func(chat,NULL,0);
	else {
		for(i = strlen(cmd->name); buffer[i] != '\0' && 
				isspace(buffer[i]); ++i) ;
		memmove(buffer,buffer+i,strlen(buffer+i)+1);
		
		if(cmd->max_args == -1)
			no_args = 0;
		else
			no_args = cmd->max_args+1;
		
		//D("to split: \"%s\" by: %d",buffer,no_args);
		args = split_opt(buffer,buffer,&no_args);
		//D("got: %d args",no_args);
		
		if(cmd->max_args != -1 && no_args > cmd->max_args) {
			chat_msg(chat,"Too many parameters.");
		} else if(no_args < cmd->min_args) {
			chat_msg(chat,"Not enough parameters.");
		} else
			i = cmd->func(chat,args,no_args);
		if(args != NULL)
			xfree(args);
	}
	if(at_cmd_limit && i != -1) {
		chat_msg(chat,"Command Limit Reached.");
		return 1;
	} else
		return i;
}

int chat_list_open(network_t *net, const char *host, const char *hostmask, 
		const char *nick, packlist_t *list) {
	char netname[64],listname[64];
	interface_t *intf;
	chat_t *chat;
	int i;

	if(net == NULL || nick == NULL || list == NULL)
		return -1;
	
	LOCK(net);
	xstrncpy(netname,net->name,sizeof(netname));
	UNLOCK(net);
	
	LOCK(list);
	xstrncpy(listname,list->name,sizeof(listname));
	intf		= list->chat_interface;
	if(list->deleted != 0) {
		UNLOCK(list);
		return -1;
	}
	UNLOCK(list);
	
	if(intf == NULL) {
		LOCK(global);
		for(i = 0; i < global->no_interfaces; ++i) {
			intf = global->interfaces[i];
			LOCK(intf);
			if(intf->deleted == 0 &&
				intf->type == INTERFACE_CHAT && 
				intf->def == 1) {
				UNLOCK(intf);
				break;
			}
			UNLOCK(intf);
			intf = NULL;
		}
		UNLOCK(global);
		if(intf == NULL)
			return -1;
	}

	LOCK(intf);
	if(intf->chat.no_chats >= intf->chat.max_no) {
		UNLOCK(intf);
		return -1;
	}
	chat 			= alloc_chat(CHAT_LIST);
	chat->state		= STATE_QUEUED;
	chat->list.packlist 	= list;
	chat->list.commands	= 0;
	chat->network	 	= net;
	chat->host 		= host != NULL ? xstrdup(host) : NULL;
	chat->hostmask		= hostmask != NULL ? xstrdup(hostmask) : NULL;
	chat->nick 		= xstrdup(nick);
	chat->colour		= COLOUR_IRC;
	welcome(chat,listname);
	PTRARR_ADD(&intf->chat.chats,&intf->chat.no_chats,chat);
	
	LOGP(L_XDC,
		"XDCC LIST of %s Initiated for [%s:%s] using Interface \"%s\"",
			listname,netname,nick,intf->name);
	UNLOCK(intf);

	if(host == NULL) {
		char buffer[256];
		snprintf(buffer,sizeof(buffer),"USERHOST %s",nick);
		irc_send_raw(net,buffer);
	}
	
	return 0;	
}