#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include "arbid.h"

/* como el nodo en memoria, pero con enteros en lugar de punteros */
struct tnodof{
  int tiponodo;
  int variable;
  int umbral;
  int menor, mayorIgual;} ;

int nodosEscritos;

tpnodo nodoalloc ()
{
  return ( (tpnodo) malloc(sizeof(struct tnodo)) );
}

tpnodo creaNodo (int clNodo, int variable, int umbral, tpnodo menor, tpnodo mayorIgual)
{
  tpnodo nnodo ;
  nnodo = nodoalloc ();
  nnodo->tiponodo   = clNodo;
  nnodo->variable   = variable;
  nnodo->umbral     = umbral;
  nnodo->menor      = menor;
  nnodo->mayorIgual = mayorIgual;
  return nnodo ;
}

int escribeRama (int fd, tpnodo rama)
{
  // int pmn, pmy;
  struct tnodof nodof;
  nodof.tiponodo = rama->tiponodo ;
  nodof.variable = rama->variable ;
  nodof.umbral   = rama->umbral ;
  if (rama->tiponodo == nd_segun) {
    nodof.menor      = escribeRama (fd, rama->menor);
    nodof.mayorIgual = escribeRama (fd, rama->mayorIgual);
    }
  else {
    nodof.menor      = 0 ;
    nodof.mayorIgual = 0 ;
    }
  write (fd, & nodof, sizeof(nodof));
  nodosEscritos ++ ;
  return  nodosEscritos - 1 ; 
}

void escribeArbol (char * nomFich, tpnodo arbol)
{
  int fd;
  fd = open (nomFich, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  if (fd < 0) {
    printf ("error en arbid.escribeArbol al intentar abrir %s\n", nomFich);
    exit (1);
    }
  nodosEscritos = 0;
  escribeRama (fd, arbol);
  close (fd);
}

int escribeSeRamaTexto (tpnodo rama)
{
  int pmn, pmy;
  if (rama->tiponodo == nd_segun) {
    pmn    = escribeSeRamaTexto (rama->menor);
    pmy    = escribeSeRamaTexto (rama->mayorIgual);
    printf ("%4d segun  %5d %5d %5d %5d\n",
             nodosEscritos,
             rama->variable, rama->umbral, pmn, pmy);
    }
  else {
    switch (rama->tiponodo) {
      case nd_falso :
        printf ("%4d falso     --    --    --    --\n", nodosEscritos);
        break ;;
      case nd_cierto:
        printf ("%4d cierto    --    --    --    --\n", nodosEscritos);
        break ;;
      case nd_nose  :
        printf ("%4d nose      --    --    --    --\n", nodosEscritos);
        break ;;
      }
    }
  nodosEscritos ++ ;
  return  nodosEscritos - 1 ; 
}

void escribeSeArbolTexto (tpnodo arbol)
{
  nodosEscritos = 0;
  escribeSeRamaTexto (arbol);
}

tpnodo leeRama (int fd, int posicion)
{
  struct tnodof nodof;
  tpnodo nnodo ;
/* situarse en posicion */
  lseek (fd, posicion * sizeof(nodof), SEEK_SET); 
  read (fd, & nodof, sizeof(nodof));
  nnodo = nodoalloc ();
  nnodo->tiponodo   = nodof.tiponodo ;
  nnodo->variable   = nodof.variable ;
  nnodo->umbral     = nodof.umbral ;
  if (nodof.tiponodo == nd_segun) {
    nnodo->menor      = leeRama(fd, nodof.menor);
    nnodo->mayorIgual = leeRama(fd, nodof.mayorIgual);
    }
  else {
    nnodo->menor      = NULL ;
    nnodo->mayorIgual = NULL ;
    }
  return nnodo;
}

tpnodo leeArbol (char * nomFich)
{
  int fd;
  int posicion, tam;
  struct tnodof nodof;
  tpnodo arbol;
  fd = open (nomFich, 0);
  if (fd < 0) {
    printf ("error en arbid.leeArbol al intentar abrir %s\n", nomFich);
    exit (1);
    }
  tam = lseek (fd, 0L, SEEK_END);
  posicion = (tam / sizeof(nodof)) - 1 ;
  arbol = leeRama (fd, posicion);
  close (fd);
  return arbol;
}

void anadeNodoHMenor (tpnodo np, tpnodo nh)
{
  np->menor = nh;
}

void anadeNodoHMayorI (tpnodo np, tpnodo nh)
{
  np->mayorIgual = nh;
}

int evalArbolVector (tpnodo arb, int v[])
{
  switch (arb->tiponodo) {
    case nd_falso   :
      return nd_falso ;
    case nd_cierto  :
      return nd_cierto ;
    case nd_nose    :
      return nd_nose ;
    case nd_segun   :
      if (v[arb->variable] < arb->umbral) 
        return evalArbolVector (arb->menor, v);
      else    /* mayor o igual */
        return evalArbolVector (arb->mayorIgual, v);
    }
  return nd_nose ;  // no llega aqui. para evitar warning
}

void destruyeArbol (tpnodo nodo)
{
  if (nodo->tiponodo == nd_segun) {
    destruyeArbol (nodo->menor);
    destruyeArbol (nodo->mayorIgual);
    }
  free (nodo);
}