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

#include "bnodelist.h"

Bnode* CreateBnode (long id, long livello, long id_figlio, ProblemData *pPD)
{
  int i;

  Bnode *pta = (Bnode *) malloc(sizeof(Bnode));
  pta->id = id;
  pta->livello = livello;
  pta->id_figlio = id_figlio;

  // Inizializza le informazioni locali del problema
  ...

  // Set to zero the branching information
  pta->branch.numfigli = 0;
  ...

  pta->prev = NULL;
  pta->next = NULL;

  return pta;
}

Bnodelist CreateBnodelist ()
{
  Bnodelist L = (Bnodelist) malloc(sizeof(Bnode));
  if (L == NULL)
  {
    printf("Insufficient memory to allocate the list!\n");
    exit(EXIT_MEMORY);
  }
  L->next = L;
  L->prev = L;
  return L;
}

void DestroyBnodelist (Bnodelist *pL)
{
  Bnodepos p;
  for (p = primolista(*pL); !listavuota(*pL); canclista(&p));
  free(*pL);
  *pL = NULL;
}


Bnodepos primolista (Bnodelist L)
{
  Bnodepos p = L->next;
  return p;
}

Bnodepos ultimolista (Bnodelist L)
{
  Bnodepos p = L->prev;
  return p;
}


boolean finelista (Bnodepos p, Bnodelist L)
{
  boolean b = (p == L);
  return b;
}

boolean listavuota (Bnodelist L)
{
  boolean b = (L->next == L) && (L->prev == L);
  return b;
}

Bnodepos succlista (Bnodepos p, Bnodelist L)
{
  Bnodepos q = p->next;
  return q;
}

Bnodepos preclista (Bnodepos p, Bnodelist L)
{
  Bnodepos q = p->prev;
  return q;
}

// CONCETTUALMENTE IMPROPRIO: LA CREATE DOVREBBE RIMANERE NASCOSTA ALL'UTENTE,
// E QUESTA FUNZIONE DOVREBBE RICEVERE UN Bnodeinfo, CHIAMARE LA CREATE
// E INSERIRE IL NUOVO OGGETTO NELLA LISTA.
// PERO' NON TUTTI I NODI CREATI VANNO INSERITI, PER CUI FORSE MEGLIO PROCEDERE COSI'.
void inslista (Bnode *Node, Bnodepos p, Bnodelist L)
{
  Node->prev = p->prev;
  Node->next = p;
  p->prev->next = Node;
  p->prev = Node;
}

void canclista (Bnodepos *pp)
{
  Bnodepos q;
  q = *pp;
  q->prev->next = q->next;
  q->next->prev = q->prev;
  *pp = q->next;
  free(q);
}


// ANCHE QUESTO E' UN PO' IMPROPRIO: PROBABILMENTE, BISOGNEREBBE
// NON ESTRARRE IL NODO, MA COPIARNE LE INFORMAZIONI IN UNA VARIABILE
// DI USCITA. POI, ELIMINARE IL NODO CON canclista.
Bnode *estraelista (Bnodepos *pp, Bnodelist L)
{
  Bnode *q;
  q = *pp;
  q->prev->next = q->next;
  q->next->prev = q->prev;
  *pp = q->next;

  return q;
}


void DestroyBnode (Bnode **pNode)
{
  // Deallocazione delle strutture dinamiche contenute nelle struct BnodeInfo e branch
  ...

  free(*pNode);
  *pNode = NULL;
}