#include "tbl_qcmd.h"

tble_exec *tbl_exec_c()
{
	MVAR_ALLOC_STRC(ret,tble_exec,{
		return NULL;});
	return ret;
}


tbl_exec *tbl_exec_list_c(int size)
{
	MVAR_ALLOC_STRC(ret,tbl_exec,{
		return NULL;});

	ret->id = uniq_id();
	ret->size = 0;
	ret->max_size = size;

	MVAR_ALLOC_ARR(cmd,tble_exec*,size,{
		free(ret);
		return NULL;
	})

	ret->cmd = cmd;

	return ret;
}

//TODO check if command allready excists
int tbl_exec_add(tbl_exec *tbl, tble_exec *cmd)
{
	if (tbl == NULL || cmd == NULL)
	{
		return -1;
	}

	tbl->cmd[tbl->size] = cmd;
	if (tbl->size+1<tbl->max_size)
	{
		tbl->size += 1;
	} else 
	{
		return -1;
	}

	return 0;
}

int tbl_exec_in_s(tbl_exec *tbl, char *cmd)
{
	return -1;
}

tble_exec *tbl_exec_search_cmd(tbl_exec *tbl, tble_qcmd *cmd)
{
	tble_exec *ret = NULL;
	tble_exec *cur_exec = NULL;
	int i;

	if ((tbl == NULL)||(cmd == NULL))
	{
		PERM();
		return NULL;
	}

	if (tbl->id != cmd->tid) 
	{
		PERM();
		return NULL;
	}

	for (i=0;i<tbl->max_size;i++)
	{
		cur_exec = tbl->cmd[i];
		//command match
		if ((strncmp(cur_exec->cmd, cmd->cmd, strlen(cmd->cmd)) == 0) && 
		    (strlen(cur_exec->cmd) == strlen(cmd->cmd)))
		// command id and exec id match
		if (cur_exec->id == cmd->tidx)
		{
			ret = cur_exec;
			break;
		}
	}

	return ret;
}


int tbl_exec_print(tble_exec *tble, int flags)
{
	if (tble == NULL)
	{
		return -1;
	}

	if (flags&TBL_PF_EXEC_ID)
	{
		printf("ID:[%d] ", tble->id);
	}

	if (flags&TBL_PF_EXEC_NAME)
	{
		printf("NAME:[%s] ", tble->name);
	}

	if (flags&TBL_PF_EXEC_CMD)
	{
		printf("CMD:[%s] ", tble->cmd);
	}

	if (flags&TBL_PF_EXEC_TYPE)
	{
		printf("TYPE:[%d] ", tble->type);
	}

	printf("\n");

	return 0;
}

int tbl_exec_print_tbl(tbl_exec *tbl, int flags)
{
	int i;
	tble_exec *el=NULL;

	if (tbl == NULL)
	{
		return -1;
	}

	for (i=0; i<tbl->size; i++)
	{
		el = tbl->cmd[i];
		if (el != NULL)
		{
			printf(">%02d< ",i);
			tbl_exec_print(el, flags);
		}
	}
	return 0;
}

tble_qcmd *tbl_qcmd_cmd_c()
{
	MVAR_ALLOC_STRC(ret,tble_qcmd,{
		return NULL;});
	return ret;
}


tbl_qcmd* tbl_qcmd_c(int size)
{
	MVAR_ALLOC_STRC(ret,tbl_qcmd,{
		return NULL;});

	ret->id = uniq_id();
	ret->size = 0;
	ret->max_size = size;

	//alloc array of (tble_qcmd*) pointers
	MVAR_ALLOC_ARR(cmd,tble_qcmd*,size,{
		free(ret);
		return NULL;
	})

	ret->cmd = cmd;

	return ret;
}


int tbl_qcmd_exec(tbl_qcmd *tcmd, tbl_exec *texec)
{
	int ret=-1;
	int i,j;

	if (tcmd == NULL)
	{
		PERM();
		return -1;
	}

	if (texec == NULL)
	{
		PERM();
		return -1;
	}

	//EFFICIENT CODE MATE
	//search for commands that are in NONE state
	for (i=0; i<tcmd->size; i++)
	{
		tble_qcmd *tc = tcmd->cmd[i];
		if (tc->state == QCMD_INIT)
		for (j=0;j<texec->size;j++)
		{
			tble_exec *e = texec->cmd[j];
			if (strncmp(e->cmd, tc->cmd, strlen(e->cmd)) == 0)
			{
				tc->tid   = texec->id;  //save table id
				tc->tidx  = e->id;      //set executor id
				tc->state = QCMD_READY; //change state, that we ready to be executed
			}
		}
	}

	return 0;
}


int tbl_qcmd_add(tbl_qcmd *tbl, tble_qcmd *cmd)
{
	if (tbl == NULL || cmd == NULL)
		return -1;
	cmd->id = uniq_id();
	//all command that are just added will be in zero state
	//should match to some executot then can change state
	cmd->state = QCMD_INIT;
	tbl->cmd[tbl->size] = cmd;
	if (tbl->size+1<tbl->max_size)
	{
		tbl->size += 1;
	} else 
	{
		return -1;
	}

	return 0;
}


int tbl_qcmd_chk(tbl_qcmd *tbl)
{
	int ret=-1;
	int i;

	if (tbl == NULL)
	{
		return -1;
	}

	for (i=0;i<tbl->max_size;i++)
	{
		//if command in some state like segfaulted or 
		// finished running then lets check
		if ((tbl->cmd[i]->state == QCMD_TIMEOUT)||
		    (tbl->cmd[i]->state == QCMD_DONE))
		{
			return i;
		}
	}

	return ret;
}

//delete but dont free from list?
int tbl_qcmd_del(tbl_qcmd *tbl, int idx)
{
	int ret=-1;
	tble_qcmd *replace_cmd=NULL;

	if (tbl == NULL || idx < 0)
	{
		return -1;
	}

	if (idx >= tbl->size)
	{
		return -1;
	}

	if (tbl->size == 1)
	{
		tbl->size = 0;
		return 0;
	}

	//if last idx = size then will overwrite itself and decrease command counter
	replace_cmd = tbl->cmd[tbl->size];
	tbl->size -= 1;
	tbl->cmd[idx] = replace_cmd;

	//looks like no errors
	ret = 0;

	return ret;
}

int tbl_qcmd_resp(tbl_qcmd *tbl, tble_cmd_resp *resp)
{
	int ret = -1;
	tble_qcmd *single_cmd=NULL;

	int i;

	if ((tbl == NULL) || (resp == NULL))
	{
		return -1;
	}

	for (i=0;i<tbl->size;i++)
	{
		single_cmd = tbl->cmd[i];
		if ((single_cmd->id == resp->id))
		{
			return i;
		}
	}

	return ret;
}

tble_cmd_param* tbl_cmd_param(tble_qcmd *cmd)
{
	if (cmd == NULL)
	{
		return NULL;
	}

	if (cmd->state != QCMD_READY)
	{
		PERM();
		return NULL;
	}


	MVAR_ALLOC_STRC(ret,tble_cmd_param,{
		PERM();
		return NULL;});

	ret->id = uniq_id();
	ret->qid = cmd->id;
	ret->cmd = alloc_new_str(cmd->cmd);
	ret->param = alloc_new_str(cmd->param);
	ret->out_q = cmd->out_q;

	return ret;
}

int tbl_cmd_param_free(tble_cmd_param *param)
{
	if (param == NULL)
	{
		return -1;
	}

	free(param->cmd);
	free(param->param);
	free(param);

	return 0;
}

int tbl_cmd_param_print(tble_cmd_param *param)
{
	if (param == NULL)
		return -1;
	
	printf("ID:[%d] ",    param->id);
	printf("QID:[%d] ",   param->qid);
	printf("OUT_Q:[%d] ", param->out_q);
	printf("CMD:[%s] ",   param->cmd);
	printf("PARAM:[%s] ", param->param);
	printf("\n");

	return 0;
}

tble_cmd_resp* tbl_cmd_resp_c(tble_cmd_param *param)
{
	if (param == NULL)
	{
		PERM();
		return NULL;
	}

	MVAR_ALLOC_STRC(ret, tble_cmd_resp,
	{
		PERM();
		return NULL;
	});

	ret->id = uniq_id();
	ret->qid = param->qid;

	return ret;
}

int tbl_cmd_resp_free(tble_cmd_resp *resp)
{
	if (resp == NULL)
	{
		return -1;
	}



	return 0;
}

int tbl_cmd_resp_print(tble_cmd_resp *resp)
{
	if (resp == NULL)
		return -1;

	printf("ID:[%d] ",       resp->id);
	printf("QID:[%d] ",      resp->qid);
	printf("TYPE:[%d] ",     resp->type);
	printf("RET_CODE:[%d] ", resp->ret_code);
	printf("RESP:[%s] ",     resp->resp);
	printf("\n");

	return 0;
}

int tbl_qcmd_print_cmd(tble_qcmd *tbl, int flags)
{
	if (tbl == NULL)
	{
		return -1;
	}

	if (flags&TBL_PF_QCMD_ID)
	{
		printf("ID:[%d] ",tbl->id);
	}
	if (flags&TBL_PF_QCMD_CID)
	{
		printf("CID:[%d] ",tbl->cid);
	}
	if (flags&TBL_PF_QCMD_TIMESTAMP)
	{
		printf("TIMESTAMP:[%d] ", tbl->timestamp);
	}
	if (flags&TBL_PF_QCMD_STATE)
	{
		printf("STATE:[%d] ", tbl->state);
	}
	if (flags&TBL_PF_QCMD_TIMEOUT)
	{
		printf("TIMEOUT:[%d] ", tbl->timeout);
	}
	if (flags&TBL_PF_QCMD_CMD)
	{
		printf("CMD:[%s] ", tbl->cmd);
	}
	if (flags&TBL_PF_QCMD_PARAM)
	{
		printf("PARAM:[%s] ", tbl->param);
	}
	if (flags&TBL_PF_QCMD_OUT_Q)
	{
		printf("OUT_Q:[%d] ", tbl->out_q);
	}
	if (flags&TBL_PF_QCMD_IN_Q)
	{
		printf("IN_Q:[%d] ", tbl->in_q);
	}
	if (flags&TBL_PF_QCMD_TID)
	{
		printf("TID:[%d] ", tbl->tid);
	}
	if (flags&TBL_PF_QCMD_TIDX)
	{
		printf("TIDX:[%d] ", tbl->tidx);
	}
	printf("\n");

	return 0;
}

int tbl_qcmd_print_tbl(tbl_qcmd *tbl, int flags)
{
	int i = -1;
	tble_qcmd *el = NULL;

	if (tbl == NULL)
	{
		PERM();
		return -1;
	}

	if (tbl->cmd == NULL)
	{
		PERM();
		return -1;
	}

	for (i=0; i<tbl->size; i++)
	{
		el = tbl->cmd[i];
		printf(">%02d< ", i);
		tbl_qcmd_print_cmd(el, flags);
	}

	return 0;
}


int tbl_qcmd_destroy_cmd(tble_qcmd *tbl)
{
	return 0;
}


int tbl_qcmd_destroy_table(tbl_qcmd *tbl)
{
	return 0;
}