/* New Clan System Written For Asgardian Nightmare
 * by Skyntil(Gabe Volker)
 */

#include "include.h"

CLN_DATA *cln_lookup(char *argument);
CLN_DATA *new_cln(void);
void free_cln(CLN_DATA *clan);
MBR_DATA *new_mbr(void);
bool remove_member(char *argument, CLN_DATA *cln);
void add_member(char *argument, CLN_DATA *clan);
void show_clans(CHAR_DATA *ch, char *argument);
void free_mbr(MBR_DATA *mbr);
MBR_DATA *mbr_lookup(char *argument, CLN_DATA *clan);
bool add_clan(char *argument);
bool remove_clan(char *argument);

CLN_DATA *cln_list;   // The Clan List
CLN_DATA *cln_first;  // First Clan

/* Think of it like this
 *  CLAN1 -> CLAN2 -> CLAN3 -> NULL(end)
 *   |        |        |
 *  MBR1     MBR1     MBR1
 *   |        |        |
 *  MBR2     MBR2     MBR2
 *   |        |        |
 *  NULL(end)NULL(end)NULL(end)
 */

CLN_DATA *cln_data_free;

CLN_DATA *new_cln(void)
{
 CLN_DATA *nclan;

 if (cln_data_free == NULL) 
  nclan = alloc_mem(sizeof(*nclan));
 else 
 { 
   nclan = cln_data_free; 
   cln_data_free = cln_data_free->next; 
 } 

 nclan->next = NULL;
 nclan->name = str_dup("");
 nclan->members = 0;
 nclan->member_first = NULL;
 nclan->member_list = new_mbr();
 nclan->kills = 0;
 nclan->deaths = 0;
 nclan->atwar = 0;

 VALIDATE(nclan); 
 
 return nclan; 
}

void free_cln(CLN_DATA *clan)
{
 MBR_DATA *remove_mbr;

 if (!IS_VALID(clan))
     return; 
 
 if(clan->member_list == NULL || clan->member_first == NULL)
 {
  clan->next = cln_data_free;
  cln_data_free = clan; 
  INVALIDATE(clan);
  return;
 }
 else  // With Members
 {
  for(remove_mbr = clan->member_first; remove_mbr != NULL; remove_mbr = remove_mbr->next)
    free_mbr(remove_mbr);
  free_mbr(clan->member_first);
  clan->next = cln_data_free;
  cln_data_free = clan; 
  INVALIDATE(clan);
  return;
 }
 return;
}

MBR_DATA *mbr_data_free;

MBR_DATA *new_mbr(void)
{
 MBR_DATA *nmbr;

 if (mbr_data_free == NULL) 
  nmbr = alloc_mem(sizeof(*nmbr));
 else 
 { 
   nmbr = mbr_data_free; 
   mbr_data_free = mbr_data_free->next; 
 } 

 nmbr->next = NULL;
 nmbr->name = str_dup("");

 VALIDATE(nmbr); 
 
 return nmbr; 
}

void free_mbr(MBR_DATA *mbr)
{
    if (!IS_VALID(mbr)) 
        return; 
 
    mbr->next = mbr_data_free; 
    mbr_data_free = mbr; 
    INVALIDATE(mbr); 
}

bool add_clan( char *argument)
{
 CLN_DATA *new_clan;

 new_clan = new_cln();
 new_clan->name = str_dup(argument);

 // Check if First Clan
 if(cln_list == NULL || cln_first == NULL)
 {
   cln_list = new_clan; // Put into position
   cln_first = cln_list; // Make it the first
 }
 else
 {
   cln_list->next = new_clan; // Point to new node
   /* CLN_LIST -> NEW_CLAN */
   cln_list = new_clan; // Set cln_list to current position.
   /* OLD_NODE -> CLN_LIST */
 }

 return TRUE;
}

bool remove_clan(char *argument)
{
 CLN_DATA *cln_find, *cln_found;

 if((cln_found = cln_lookup(argument)) == NULL)
  return FALSE;

 if(cln_found == cln_first)
 {
  /* CLN_FND -> NEXT
   *       Cut found out and release it
   * NEXT
   */

  cln_first = cln_first->next; // Assign first to next
  free_cln(cln_found);
  return TRUE;
 }
 else if(cln_found->next == NULL) // Last
 {
  /* CLN_FIND -> CLN_FOUND -> NULL
   *       Cut found out and release it
   * CLN_FIND -> NULL
   */

  for(cln_find = cln_first; cln_find != NULL; cln_find = cln_find->next)
  {
   if(cln_find->next == cln_found)
   break;
  }

  cln_list = cln_find; // Assign End pointer to new last
  cln_list->next = NULL; // Don't point to something thats gone
  free_cln(cln_found);
  return TRUE;
 }
 else // Not the first clan
 {

 /* CLN_FIND -> CLN_FOUND -> NEXT
  *         Cut found out and release it
  * CLN_FIND -> NEXT
  */

  for(cln_find = cln_first; cln_find != NULL; cln_find = cln_find->next)
  {
   if(cln_find->next == cln_found)
   break;
  }

  cln_find->next = cln_found->next; // Assign prev to next
  free_cln(cln_found);
  return TRUE;
 }

 return TRUE;
}

void show_clans(CHAR_DATA *ch, char *argument)
{
 CLN_DATA *clan;
 MBR_DATA *mbr;
 char buf[256],buf2[256];
 int i;

 buf[0] = '\0';
 buf2[0] = '\0';

 if(cln_first == NULL || cln_list == NULL)
 {
  send_to_char("There are no clans loaded.\n\r",ch);
  return;
 }

 for(i = 0; i < 15; i++)
  strcat(buf,"=");
 strcat(buf,"-NCLANS-");
 for(i = 0; i < 15; i++)
  strcat(buf,"=");

 printf_to_char(ch,"\n\r%-30s\n\r",buf);

 for(clan = cln_first; clan != NULL; clan = clan->next)
 {
  sprintf(buf,"| Name: %s |\n\r",clan->name);
  send_to_char(buf,ch);

  if(clan->member_list == NULL || clan->member_first == NULL)
   send_to_char("|  Members: None |\n\r",ch);
  else
  {
   for(mbr = clan->member_first; mbr != NULL; mbr = mbr->next)
   {
    sprintf(buf2,"|  Member: %s |\n\r",mbr->name);
    send_to_char(buf2,ch);
   }
  }
 }

 buf[0] = '\0';

 for(i = 0; i < 38; i++)
  strcat(buf,"=");

 printf_to_char(ch,"%-30s\n\r",buf);

 return;
}

void add_member(char *argument, CLN_DATA *clan)
{
 MBR_DATA *new_mebr;

 new_mebr = new_mbr();
 new_mebr->name = str_dup(argument);

 if(clan->member_list == NULL || clan->member_first == NULL)
 {
   clan->member_list = new_mebr; // Put into position
   clan->member_first = clan->member_list; // Set as First
 }
 else
 {
   clan->member_list->next = new_mebr; // Point to next node
   /* MBR_LIST -> NEW_MBR */
   clan->member_list = new_mebr; // Set cln_list to current position.
   /* OLD_NODE -> MBR_LIST */
 }

 return;
}

bool remove_member(char *argument, CLN_DATA *cln)
{
 MBR_DATA *mbr_find, *mbr_found;

 if((mbr_found = mbr_lookup(argument,cln)) == NULL)
  return FALSE;

 if(mbr_found == cln->member_first)
 {
  /* mbr_FND -> NEXT
   *       Cut found out and release it
   * NEXT
   */

  cln->member_first = mbr_found->next; // Assign first to next
  free_mbr(mbr_found);
  return TRUE;
 }
 else if(mbr_found->next == NULL) // Last
 {
  /* mbr_FIND -> mbr_FOUND -> NULL
   *       Cut found out and release it
   * mbr_FIND -> NULL
   */

  for(mbr_find = cln->member_first; mbr_find != NULL; mbr_find = mbr_find->next)
  {
   if(mbr_find->next == mbr_found)
   break;
  }

  cln->member_list = mbr_find; // Assign End pointer to new last
  cln->member_list->next = NULL; // Don't point to something thats gone
  free_mbr(mbr_found);
  return TRUE;
 }
 else // Not the first clan
 {

 /* mbr_FIND -> mbr_FOUND -> NEXT
  *         Cut found out and release it
  * mbr_FIND -> NEXT
  */

  for(mbr_find = cln->member_first; mbr_find != NULL; mbr_find = mbr_find->next)
  {
   if(mbr_find->next == mbr_found)
   break;
  }

  mbr_find->next = mbr_found->next; // Assign prev to next
  free_mbr(mbr_found);
  return TRUE;
 }

 return TRUE;
}

CLN_DATA *cln_lookup(char *argument)
{
  CLN_DATA *nclan;

  for (nclan = cln_first; nclan != NULL; nclan = nclan->next)
  {
     if (LOWER (argument[0]) == LOWER (nclan->name[0])
          && !str_prefix (argument, nclan->name))
             return nclan;
  }

   return NULL;
}

MBR_DATA *mbr_lookup(char *argument, CLN_DATA *clan)
{
  MBR_DATA *nmbr;

  for (nmbr = clan->member_first; nmbr != NULL; nmbr = nmbr->next)
  {
     if (LOWER (argument[0]) == LOWER (nmbr->name[0])
          && !str_prefix (argument, nmbr->name))
             return nmbr;
  }

   return NULL;
}

void do_nclan(CHAR_DATA *ch, char *argument)
{
 char arg[MSL/10];
 char arg2[MSL/10];
 CLN_DATA *nclan;

 if(IS_NPC(ch))
  return;

 argument = one_argument(argument,arg);

 if(!str_cmp(arg,"show"))
 {
  show_clans(ch,arg);
  return;
 }

 if(!str_cmp(arg,"add"))
 {
  one_argument(argument,arg);
  if(!arg[0])
  {
   send_to_char("You must include a nclan name.\n\r",ch);
   return;
  }
  add_clan(arg);
  printf_to_char(ch,"NCLAN: %s Added.\n\r",arg);
  return;
 }

 if(!str_cmp(arg,"remove"))
 {
  one_argument(argument,arg);
  if(!arg[0])
  {
   send_to_char("You must include a nclan name.\n\r",ch);
   return;
  }
  if(!remove_clan(arg))
  {
   send_to_char("There is no such clan.\n\r",ch);
   return;
  }
  else
  { 
   printf_to_char(ch,"NCLAN: %s Removed.\n\r",arg);
   return;
  }
 }

 if(!str_cmp(arg,"memadd"))
 {
  argument = one_argument(argument,arg);
  one_argument(argument,arg2);
  if(!arg[0])
  {
   send_to_char("You must include a NCLAN name.\n\r",ch);
   return;
  }
  if((nclan = cln_lookup(arg)) == NULL)
  {
   send_to_char("That clan does not exist.\n\r",ch);
   return;
  }
  if(!arg2[0])
  {
   send_to_char("You must include a member name.\n\r",ch);
   return;
  }
  add_member(arg2,nclan);
  printf_to_char(ch,"NCLAN: %s MEMBER: %s Added.\n\r",arg,arg2);
  return;
 }

 if(!str_cmp(arg,"memremove"))
 {
  argument = one_argument(argument,arg);
  one_argument(argument,arg2);
  if(!arg[0])
  {
   send_to_char("You must include a NCLAN name.\n\r",ch);
   return;
  }
  if((nclan = cln_lookup(arg)) == NULL)
  {
   send_to_char("That clan does not exist.\n\r",ch);
   return;
  }
  if(!arg2[0])
  {
   send_to_char("You must include a member name.\n\r",ch);
   return;
  }
  remove_member(arg2,nclan);
  printf_to_char(ch,"NCLAN: %s MEMBER: %s Removed.\n\r",arg,arg2);
  return;
 }

 send_to_char("Nclan [show|add|remove|memadd|memremove]\n\r",ch);
 return;
}