/*
 * group.c
 *
 * Functionality to add, remove, and manage group members in Cutlass
 *
 * Copyright (c) 2004 Todd MacDermid <tmacd@synacklabs.net>
 *
 */

#include <cutlass.h>

#include <stdlib.h>
#include <string.h>

group_t *
cutlass_group_create(cutlass_t *cut_handle, char *group_name, 
		     cutlass_private_key *group_key)
{
  group_t *new_group;
  struct member_node *new_node;

  if(NULL == cut_handle) {
    cutlass_sysmsg(NULL, CUT_ERROR, 
		   "cutlass_group_create: Passed NULL cut_handle\n");
    return(NULL);
  }

  if(NULL == group_name) {
    cutlass_sysmsg(cut_handle, CUT_ERROR, 
		   "cutlass_group_create: Passed NULL group name\n");
    return(NULL);
  }

  new_group = calloc(1, sizeof(group_t));
  if(NULL == new_group) {
    cutlass_sysmsg(cut_handle, CUT_ERROR, 
		   "cutlass_group_create: Memory allocation error\n");
    return(NULL);
  }

  new_node = calloc(1, sizeof(struct member_node));
  if(NULL == new_node) {
    cutlass_sysmsg(cut_handle, CUT_ERROR, 
		   "cutlass_group_create: Memory allocation error\n");
    free(new_group);
    return(NULL);
  }

  /* Turn key into group_id */

  if(NULL == group_key) { 
    /* generate new group key */
  }

  strncpy(new_group->group_name, group_name, CUTLASS_NAME_LEN);
  new_group->group_name[CUTLASS_NAME_LEN - 1] = 0;
  new_group->admin = 1;
  new_group->members = new_node;
  new_node->next = NULL;
  memcpy(new_node->member_id, cut_handle->id, CUT_ID_LEN);
  new_node->admin = 1;

  pthread_mutex_init(&(new_group->group_mutex), NULL);

  if(hashtable_group_add(cut_handle, new_group) < 0) {
    cutlass_sysmsg(cut_handle, CUT_ERROR, 
		   "cutlass_group_create: Error adding to hashtable\n");
    free(new_group);
    return(NULL);
  }

  return(new_group);
}

/*
 * cutlass_group_add adds an existing connection to a group. If the caller
 * is the administrator for the group, it then issues add messages to all
 * current group participants, as well.
 */

int
cutlass_group_add(cutlass_t *cut_handle, group_t *group, conn_t *conn)
{
  struct member_node *new_node;

  if(NULL == cut_handle) {
    cutlass_sysmsg(NULL, CUT_ERROR, 
		   "cutlass_group_create: Passed NULL cut_handle\n");
    return(-1);
  }

  if(NULL == group) {
    cutlass_sysmsg(cut_handle, CUT_ERROR, 
		   "cutlass_group_create: Passed NULL group handle\n");
    return(-1);
  }

  if(NULL == conn) {
    cutlass_sysmsg(cut_handle, CUT_ERROR, 
		   "cutlass_group_create: Passed NULL group handle\n");
    return(-1);
  }

  new_node = calloc(1, sizeof(struct member_node));
  if(NULL == new_node) {
    cutlass_sysmsg(cut_handle, CUT_ERROR, 
		   "cutlass_group_add: Memory allocation error\n");
    return(-1);
  }
  
  memcpy(new_node->member_id, conn->fingerprint, CUT_ID_LEN);

  pthread_mutex_lock(&(group->group_mutex));
  new_node->next = group->members;
  group->members = new_node;
  pthread_mutex_unlock(&(group->group_mutex));

  return(0);
}

void
cutlass_group_destroy(cutlass_t *cut_handle, group_t *group)
{
  struct member_node *walk_node;
  struct member_node *free_node;
 
  if((cut_handle == NULL) || (group == NULL)) {
    cutlass_sysmsg(cut_handle, CUT_ERROR, 
		   "cutlass_group_destroy: Passed a NULL handle\n");
    return;
  }
  
  hashtable_group_del(cut_handle, group->group_id);
  
  pthread_mutex_lock(&(group->group_mutex));
  walk_node = free_node = group->members;
  while(walk_node != NULL) {
    walk_node = walk_node->next;
    free(free_node);
    free_node = walk_node;
  }
  
  /* Below may be dangerous? Double check, maybe housekeeping should wipe */

  free(group);
}

int
group_unpack(cutlass_t *cut_handle, uint8_t *clear_packet, 
	     struct cutlass_group_hdr *group_hdr)
{
  uint8_t *packet_loc;

  packet_loc = clear_packet;

  group_hdr->code = *packet_loc;
  packet_loc++;
  group_hdr->sequence = ntohs(*((uint16_t *)packet_loc));
  packet_loc += 2;
  memcpy(group_hdr->group_id, packet_loc, CUT_ID_LEN);

  return(0);
}

int
group_pack(cutlass_t *cut_handle, uint8_t *clear_packet, 
	     struct cutlass_group_hdr *group_hdr)
{
  uint8_t *packet_loc;
  
  packet_loc = clear_packet;

  *packet_loc = group_hdr->code;
  packet_loc++;
  *((uint16_t *)packet_loc) = htons(group_hdr->sequence);
  packet_loc += 2;
  memcpy(packet_loc, group_hdr->group_id, CUT_ID_LEN);

  return(0);
}


int
cutlass_group_ack(cutlass_t *cut_handle, group_t *group, conn_t *conn)
{
  

  return(0);
}

int
cutlass_group_ack_parse(cutlass_t *cut_handle, conn_t *conn, 
			uint8_t *clear_packet)
{
  struct cutlass_group_hdr group_hdr;

  group_unpack(cut_handle, clear_packet, &group_hdr);
  return(0);
}

int
cutlass_group_invite_send(cutlass_t *cut_handle, group_t *group, conn_t *conn)
{
  struct cutlass_group_hdr group_hdr;

  group_hdr.code = GROUP_CODE_INVITE;
  group_hdr.sequence = group->sequence++;
  

  return(0);
}

int
cutlass_group_invite_parse(cutlass_t *cut_handle, group_t *group, conn_t *conn)
{

  return(0);
}


int
cutlass_group_invite(cutlass_t *cut_handle, group_t *group, conn_t *conn)
{

  

  return(0);
}

int
cutlass_group_kick(cutlass_t *cut_handle, group_t *group, conn_t *conn)
{

  return(0);
}

int
cutlass_group_ban(cutlass_t *cut_handle, group_t *group, conn_t *conn)
{

  return(0);
}

int
cutlass_group_join(cutlass_t *cut_handle, conn_t *conn, uint8_t *group_id)
{

  return(0);
}

int
cutlass_group_leave(cutlass_t *cut_handle, group_t *group)
{

  return(0);
}

int
cutlass_group_invite_accept(cutlass_t *cut_handle, group_t *group)
{

  return(0);
}

int
cutlass_group_invite_reject(cutlass_t *cut_handle, group_t *group)
{

  return(0);
}