#include "sbfisico.h"
#include "superblq.h"
#include "errores.h"

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

/* Dependencias del sistema */
/* Ejemplo de compilación condicional */

#ifdef __MSDOS__

#include <io.h>
#include <sys/stat.h>
#define PERMISOS_DISCO (S_IREAD|S_IWRITE)
#define MODO (O_RDWR|O_BINARY)

#define TRUNCATE chsize

#else

#include <unistd.h>
#define PERMISOS_DISCO  0644
#define MODO O_RDWR

#define TRUNCATE ftruncate

#endif



/* En algún sitio había que declararla */

enum Errores Error_SF=ERR_OK;
#define ErrorSF Error_SF



/* Variables internas del módulo */

static int Disco = -1;
static WORD TamBloqueFisico = 0;
static DWORD NumBloquesFisicos = 0;



/* Instalación de un disco */

int InstalaDisco (const char* nombre_fichero,WORD tam_bloque,DWORD num_bloques)
{
	struct Superbloque bl;
	DWORD tam_total = tam_bloque*num_bloques;
	int err;
	int fd;

	Error_SF = 0;
	if (   tam_total<=0 || tam_total>MAX_TAMDISCO
	    || tam_bloque>MAX_TAMBLOQUE )
	{
	  Error_SF = ERR_RANGO;
	  return -1;
	}

#ifdef __MSDOS__
	_fmode=O_BINARY;
#endif

	/* Crea el fichero */
	fd = creat (nombre_fichero,PERMISOS_DISCO);

	if ( fd==-1 )
	{
	  switch(errno)
	  {
	    case EACCES:
	      ErrorSF=ERR_DISCO;
	     break;
	    default:
	      ErrorSF = ERR_DISCO;
	     break;
	  }
	  return -1;
	}

	err=TRUNCATE (fd,tam_total);

	if (err==-1)
	{
	  ErrorSF=ERR_DISCO;
	  return -1;
	}

	/* Escribe los datos del superbloque */
	strcpy(bl.magico,MAGICO);
	bl.tam_bloque_fisico = tam_bloque;
	bl.num_bloques_fisicos = num_bloques;
	bl.bytes_bloque_datos = 0;
	write(fd,&bl,sizeof(struct Superbloque));


	close(fd);
	return 0;

}  /* InstalaDisco */



/* Monta un disco para su uso */
/* se ignora el parámetro nbloques_cache */

int MontaDisco ( const char* nombre_fichero, int nbloques_cache )
{
	struct Superbloque bl;

	Error_SF = 0;
	if (Disco!=-1) close(Disco);

	Disco = open(nombre_fichero,MODO);

	if ( Disco==-1 )
	{
	  switch (errno)
	  {
	    case EACCES:
	      Error_SF=ERR_DISCO;
	    case ENOENT:
	      Error_SF=ERR_NOEXISTE;
	    default:
	      Error_SF=ERR_DISCO;
	  }
	  return -1;
	}

	/* Lee información del bloque cero */

	read (Disco,&bl,sizeof(struct Superbloque));

	if ( strcmp(bl.magico,MAGICO) )
	{
	  Error_SF=ERR_FORMATO;
	  return -1;
	}
	TamBloqueFisico = bl.tam_bloque_fisico;
	NumBloquesFisicos = bl.num_bloques_fisicos;

	return 0;

}  /* MontaDisco */




int DesmontaDisco (void)
{
	if (Disco==-1)
	{
	  Error_SF=ERR_INACTIVO;
	  return -1;
	}
	close(Disco);
	return Error_SF=0;
}




/* Acceso a un bloque físico (lectura o escritura) */

enum { LECTURA, ESCRITURA };

static int AccedeBloqueFisico ( DWORD nbloque, void* bufer,
				enum ModoAccesoFisico modo )
{
#ifdef DEBUG
	printf("[%s:%d] ",modo==ACCESO_FISICO_LECTURA?"R":"W",nbloque);
#endif
	if ( Disco==-1 )
	{ ErrorSF=ERR_INACTIVO; return -1; }
	if ( nbloque>=NumBloquesFisicos )
	{ ErrorSF=ERR_RANGO; return -1; }

	lseek (Disco,nbloque*TamBloqueFisico,SEEK_SET);
	switch (modo)
	{
	   case ACCESO_FISICO_ESCRITURA:
	     return write ( Disco,bufer,TamBloqueFisico ) ==TamBloqueFisico;
	   case ACCESO_FISICO_LECTURA:
	     return read ( Disco,bufer,TamBloqueFisico ) ==TamBloqueFisico;
	   default:
	     return -1;
	}
}

int LeeBloqueFisico ( DWORD nbloque, void* bufer )
{ return AccedeBloqueFisico(nbloque,bufer,LECTURA); }

int EscribeBloqueFisico ( DWORD nbloque, void* bufer )
{ return AccedeBloqueFisico(nbloque,bufer,ESCRITURA); }



/* Acceso al superbloque */

int LeeSuperbloque (struct Superbloque* bloque)
{
   int result=0;
   char* bufer = malloc(TamBloqueFisico);
   result=LeeBloqueFisico(0,bufer);
   memcpy(bloque,bufer,sizeof(struct Superbloque));
   free(bufer);
   return result;
}

int EscribeSuperbloque (const struct Superbloque* bloque)
{
   int result=0;
   char* bufer = malloc(TamBloqueFisico);
   memcpy(bufer,bloque,sizeof(struct Superbloque));
   result=EscribeBloqueFisico(0,bufer);
   free(bufer);
   return result;
}

void InformeCache(void)
{
}