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

const int bloqueLogico        = 2; //1 bloque logico hecho por bloques fisicos de 1 bytes cada uno
const int fsInformacion       = 7; //7 bloques logicos, tamano del FS, tamano del disco, inicio del mapa, inicio de los archivos, inicio de los datos, cant archivos actual, cant archivos total
const int archivoAtributos    = 3; //3 bloques logicos
const double archivosPorDisco = 0.40;

char *discoGlobal; //Para poder abrir el archivo del disco

unsigned char crearDisco();
unsigned char particionarDisco(char *ptamanoDisco);
long leerBloque(long pbloque);
unsigned char escribirBloque(long pbloque, long pvalor);
unsigned char actualizarMapaBits(long pbloque, unsigned char pbit);
long consultarEspacioDisponible(long pinicioBloque, long pfinBloque, long pcantidad);
unsigned char crearArchivo(char *pnombre, long ptamano);
void consultarDiscoEstructura();
void consultarSistemaArchivos();
unsigned char montarDisco(char *pnombre);
unsigned char existeDiscoMontado();
void consola();
unsigned char potencia();
unsigned char maximoDisco();

int main(){

   while(1){
      consola();
   }

   /*crearDisco("prueba.txt", "2048");
   particionarDisco("1024");
   consultarSistemaArchivos();

   actualizarMapaBits(600, 0);
   actualizarMapaBits(601, 0);
   actualizarMapaBits(602, 0);

   int result = consultarEspacioDisponible(leerBloque(5), leerBloque(6), 3);

   if(result != -1){
      printf("Hay espacios disponibles en: %d \n", result);
   }
   else{
      printf("No hay espacios disponibles \n");
   }*/
   //consultarDiscoEstructura();

   //printf("%d \n", leerBloque(2));
   //printf("%d \n", leerBloque(29));
   //printf("%d \n", leerBloque(30));
   //printf("%d \n", leerBloque(31));
   //printf("%d \n", leerBloque(32));
   //printf("%d \n", leerBloque(33));

   //particionarDisco("1024");
   //printf("%d \n", leerBloque(1));
   //consultarDiscoEstructura();
   //crearDisco("prueba.txt", "1024");
   //escribirBloque(1, 1000);
   //escribirBloque(1, 1);
   //escribirBloque(3, 2);
   //escribirBloque(4, 0);
   //printf("Bloque a leer es %d \n", leerBloque(1));

   system("PAUSE");
   return 0;
}

void consola(){

   char buffer[100];
   char *trozo = NULL;
   char separador[] = " ";

   printf("admin@sofis-shell:~$ ");
   fgets(buffer, sizeof(buffer), stdin);

   strtok(buffer, "\n");
   trozo = strtok(buffer, separador);

   //Comando para crear el disco-------------------------------------------------------------------------------------------------------------
   if(!strcmp(trozo, "mkfs")){
      char *nombreDisco = strtok(NULL, separador);
      char *tamanoDisco = strtok(NULL, separador);

      if(!(nombreDisco == NULL) && !(tamanoDisco == NULL)){
         if(crearDisco(nombreDisco, tamanoDisco) == 1 && particionarDisco(tamanoDisco) == 1){
            printf("El disco se creo correctamente \n");
         }
      }
      else{
         printf("Comando invalido... \n");
      }
   }
   //Comando para crear un archivo-----------------------------------------------------------------------------------------------------------
   else if(!strcmp(trozo, "crtf")){
      if(existeDiscoMontado() == 1){
          char *nombreArchivo = strtok(NULL, separador);
          char *tamanoDisco = strtok(NULL, separador);

          if(!(nombreArchivo == NULL) && !(tamanoDisco == NULL)){
             //crearArchivo(nombreArchivo,tamanoDisco); //Falta de crear el metodo para crear un archivo con los 2 parametros
          }
          else{
             printf("Comando invalido... \n");
          }
      }
      else{
         printf("No hay un disco montado... \n");
      }
   }
   //Comando para borrar un archivo----------------------------------------------------------------------------------------------------------
   else if(!strcmp(trozo, "rmvf")){
      if(existeDiscoMontado() == 1){
          char *nombreArchivo = strtok(NULL, separador);

          if(!(nombreArchivo == NULL)){
             //borrarArchivo(nombreArchivo); //Falta de crear el metodo para borrar un archivo con el parametro
          }
          else{
             printf("Comando invalido... \n");
          }
      }
      else{
         printf("No hay un disco montado... \n");
      }
   }
   //Comando para listar la informacion del disco--------------------------------------------------------------------------------------------
   else if(!strcmp(trozo, "ls")){
      if(existeDiscoMontado() == 1){
          //consultarDiscoInformacion(); //Falta de crear el metodo para consultar la informacion del disco
      }
      else{
         printf("No hay un disco montado... \n");
      }
   }
   //Comando para consultar la estructura interna del disco----------------------------------------------------------------------------------
   else if(!strcmp(trozo, "vdisk")){
      if(existeDiscoMontado() == 1){
          consultarDiscoEstructura();
      }
      else{
         printf("No hay un disco montado... \n");
      }
   }
   //Comando para consultar la informacion del sistema de archivos---------------------------------------------------------------------------
   else if(!strcmp(trozo, "infdisk")){
      if(existeDiscoMontado() == 1){
          consultarSistemaArchivos();
      }
      else{
         printf("No hay un disco montado... \n");
      }
   }
   //Comando para montar un disco------------------------------------------------------------------------------------------------------------
   else if(!strcmp(trozo, "mount")){
      char *nombreDisco = strtok(NULL, separador);

      if(!(nombreDisco == NULL)){
         if(montarDisco(nombreDisco) == 1){
            printf("El disco se monto correctamente \n");
         }
         else{
            printf("Hubo un error al montar el disco o el disco no existe... \n");
         }
      }
   }
   else{
      printf("Comando invalido... \n");
   }

   fflush(stdin);
}

unsigned char crearDisco(char *pnombre, char *ptamanoDisco){ //Tamaño de disco adecuado es de 16384;

   //Variables
   int i;
   long tamanoDisco = atoi(ptamanoDisco);

   //Valor de retorno
   unsigned char resultado = 1;

   //Logica
   discoGlobal = strdup(pnombre);
   FILE *disco = fopen(discoGlobal, "w+");

   if(disco != NULL){
       for(i = 0; i < tamanoDisco; i++){
          fputs("-", disco);
       }
   }
   else{
      resultado = 0;
   }

   fclose(disco);

   return resultado;
}

unsigned char particionarDisco(char *ptamanoDisco){

   //Variables
   long bloquesTotal;
   long bloquesMapa;
   long bloquesArchivos;
   long bloquesDatos;

   //Valor de retorno
   unsigned char resultado = 1;

   //Logica
   FILE *disco = fopen(discoGlobal, "r+");

   if(disco != NULL){
      //Se especifican los tamaños de cada zona del sistema de archivos
      bloquesTotal = atoi(ptamanoDisco) / bloqueLogico;
      bloquesMapa = bloquesTotal / 8;
      bloquesDatos = bloquesTotal - (bloquesMapa + bloquesArchivos + fsInformacion);
      bloquesArchivos = ceil((atoi(ptamanoDisco) * archivosPorDisco) / bloqueLogico);

      //Se almacena en el disco el tamaño del sistema de archivos
      escribirBloque(1, fsInformacion + bloquesMapa + bloquesArchivos);

      //Se almacena en el disco el tamaño del disco
      escribirBloque(2, atoi(ptamanoDisco));

      //Se almacena en el disco el tamaño de la cantidad de archvios actuales. Se pone en 0 por que esta en desarollo y es un disco nuevo
      escribirBloque(3, 0);

      //Se almacena en el disco el numero de bloque del mapa de bits
      escribirBloque(4, fsInformacion + 1);

      //Se almacena en el disco el numero de bloque del los archivos
      escribirBloque(5, fsInformacion + bloquesMapa + 1);

      //Se almacena en el disco el numero de bloque del los datos
      escribirBloque(6, fsInformacion + bloquesMapa + bloquesArchivos + 1);

      //Se almacena en el disco el total de archivos que puede direccionar el disco
      escribirBloque(7, bloquesArchivos / archivoAtributos);

      //Formatear mapa de bits
      int i;
      for(i = 0; i < bloquesMapa; i++){
         escribirBloque(fsInformacion + 1 + i, 65535);
      }

      //Actualizar los bloques usados
      for(i = 1; i < (fsInformacion + bloquesMapa) + 1; i++){
         actualizarMapaBits(i, 1);
      }
   }
   else{
      resultado = 0;
   }

   fclose(disco);

   return resultado;
}

long leerBloque(long pbloque){

   //Variables
   int i, j;
   long byteInicio = 0;
   long posicion = 0;
   int contador = 0;
   unsigned char byte;

   //Valor de retorno
   long resultado = 0;

   //Logica
   FILE *disco = fopen(discoGlobal, "r+");

   if(disco != NULL){
      byteInicio = ((pbloque * bloqueLogico) - (bloqueLogico));
      posicion = byteInicio + bloqueLogico; //Bloque logico se refiere a la cantidad de bytes que compone el bloque logico

      for(i = posicion; i > byteInicio; i--){
         fseek(disco, i-1, SEEK_SET);
         byte = fgetc(disco);

         for(j = 0; j < 8; j++){
            if(byte & 1){
               resultado = resultado + pow(2,(contador));
            }
            contador++;
            byte >>= (1);
         }
      }
   }
   else{
      resultado = -1;
   }

   fclose(disco);

   return resultado;
}

unsigned char escribirBloque(long pbloque, long pnumero){

   //Variables
   int i, j;
   long byteInicio;
   long resto, cociente;
   int totalBits = bloqueLogico * 8;
   int auxTotalBits = totalBits - 1; //Auxiliar que almacena la variable totalBits. Se realiza -1 por que se trabaja con arreglos donde el indice se inicia en 0
   long nuevo[totalBits - 1]; //Se realiza -1 por que se trabaja con arreglos donde el indice se inicia en 0
   unsigned long byte;
   int indiceTotal = 0;
   int indiceTemporal;

   //Valor de retorno
   unsigned char resultado = 1;

   //Logica
   FILE *disco = fopen(discoGlobal, "r+");

   if(disco != NULL){
      byteInicio = ((pbloque * bloqueLogico) - (bloqueLogico));

      //Se convierte en binario
      for(i = 0; i <= totalBits; i++){
         resto = pnumero % 2;
         cociente = pnumero / 2;
         pnumero = cociente;
         nuevo[auxTotalBits] = resto; //Se almacena de forma invertida
         auxTotalBits--;
      }

      for(i = 0; i < bloqueLogico; i++){
         byte = 0;
         indiceTemporal = (indiceTotal + 8) - 1; //Se realiza -1 por que se trabaja con arreglos donde el indice se inicia en 0
         for(j = 0; j < 8; j++){
            byte += nuevo[indiceTemporal--] * (pow(2,j)); //Se llema hasta el primer bit del byte, y se convierte en decimal
            indiceTotal++;
         }
         fseek(disco, byteInicio, SEEK_SET);
         fputc(byte, disco);
         byteInicio++;
      }
   }
   else{
      resultado = 0;
   }

   fclose(disco);

   return resultado;
}

unsigned char actualizarMapaBits(long pbloque, unsigned char pbit){

   //Variables
   int i;
   unsigned char byte;
   unsigned long byteModificado = 0;
   int byteABrincar = floor((pbloque - 1) / 8) + ((leerBloque(4) - 1) * bloqueLogico); //Leer bloque 4 se refiere al inicio del mapa de bits
   int auxBits = 8;
   int indiceTemporal = 8;
   long nuevo[auxBits - 1]; //Se realiza -1 por que se trabaja con arreglos donde el indice se inicia en 0

   //Valor de retorno
   unsigned char resultado = 1;

   //Logica
   FILE *disco = fopen(discoGlobal, "r+");

   if(disco != NULL){
      //Se pone la aguja al bloque a brincar para leer el byte a modificar
      fseek(disco, byteABrincar, SEEK_SET);
      byte = fgetc(disco);

      //Se pasa el valor a binario se invierte la posicion en el nuevo arreglo
      for(i = auxBits - 1; i >= 0; i--){
         nuevo[i] = (byte & 1);
         byte >>= (1);
      }

      //Calcula el indice del posicion del nuevo arreglo para actualizar el bit
      int indiceACambiar = pbloque - (8 * floor(pbloque / 8));

      //Excepcion si el bit a actualizar es el ultimo bit del arreglo
      if(indiceACambiar == 0){
         indiceACambiar = indiceACambiar + 8;
      }

      //Se cambia el valor del arreglo con el indice calculado anteriormente
      nuevo[indiceACambiar - 1] = pbit;

      //Se convierte a decimal despues de haber sido modificado con la funcion anterior
      indiceTemporal--;
      for(i = 0; i < auxBits; i++){
         byteModificado += nuevo[indiceTemporal--] * (pow(2,i)); //Se llema hasta el primer bit del byte, y se convierte en decimal
      }

      //Se pone la aguja al bloque a brincar para guradar el byte que se modifico
      fseek(disco, byteABrincar, SEEK_SET);
      fputc(byteModificado, disco);
   }
   else{
      resultado = 0;
   }

   fclose(disco);

   return resultado;
}

long consultarEspacioDisponible(long pinicioBloque, long pfinBloque, long pcantidad){

   //Variables
   int i, j;
   unsigned char byte;
   int bits = 8;
   long nuevo[bits - 1];
   long contTotalBloques = 0;
   int disponibles = 0;
   int limite = (pfinBloque - pinicioBloque) / 8;
   int terminar = 0;

   //Valor de retorno
   long resultado;

    //Logica
   FILE *disco = fopen(discoGlobal, "r+");

   if(disco != NULL){
      for(i = 0; i < limite; i++){
         fseek(disco, pinicioBloque, SEEK_SET);
         byte = fgetc(disco);

         for(j = bits - 1; j >= 0; j--){
            nuevo[j] = 0;
            nuevo[j] = (byte & 1);
            byte >>= (1);
         }

         for(j = 0; j < bits; j++){
            if(nuevo[j] == 0){
               disponibles++;
               if(disponibles == pcantidad){
                  contTotalBloques++;

                  return contTotalBloques - pcantidad;
               }
            }
            else{
               disponibles = 0;
            }
            contTotalBloques++;
         }
         pinicioBloque++;
      }

      resultado = -1;
   }
   else{
      resultado = -1;
   }

   fclose(disco);

   return resultado;
}

unsigned char crearArchivo(char *pnombre, long ptamano){

   //Variables
   int i, j;
   long bloqueArchivos = leerBloque(5);
   long bloqueDatos = leerBloque(6);
   long limite = (leerBloque(2) / bloqueLogico) - leerBloque(1);

   long posArchivoDis = consultarEspacioDisponible(bloqueArchivos, bloqueDatos - 1, 3);
   long posDatosDis = consultarEspacioDisponible(bloqueDatos, limite, ptamano);

   //Valor de retorno
   unsigned char resultado = 1;

    //Logica
   FILE *disco = fopen(discoGlobal, "r+");

   if(disco != NULL){
      if((posArchivoDis != -1) && (posDatosDis != -1)){

      }
      else{
         resultado = 0;
      }
   }
   else{
      resultado = 0;
   }

   fclose(disco);

   return resultado;
}

void consultarDiscoEstructura(){

   //Variables
   int i;
   long tamanoFS = leerBloque(1);
   long byteInicio = ((leerBloque(6) * bloqueLogico) - (bloqueLogico));
   long limite = ((leerBloque(2) / bloqueLogico) - leerBloque(1)) * bloqueLogico;

   //Logica
   FILE *disco = fopen(discoGlobal, "r+");

   if(disco != NULL){
      for(i = 0; i < tamanoFS; i++){
         printf("SOFIS");
      }

      for(i = 0; i < limite; i++){
         fseek(disco, byteInicio, SEEK_SET);
         printf("%c", fgetc(disco));
         byteInicio++;
      }
      printf("\n");
   }

   fclose(disco);
}

void consultarSistemaArchivos(){

   printf("-------------------------------------------------------------------- \n");
   printf("1. Tamano total del sistema de archivos: %d \n", leerBloque(1));
   printf("2. Tamano total del disco es: %d \n", leerBloque(2));
   printf("3. Cantidad de archivos actuales: %d \n", leerBloque(3));
   printf("4. Cantidad de archivos total que puede almacenar: %d \n", leerBloque(7));
   printf("5. Numero de bloque de incio del mapa de bits: %d \n", leerBloque(4));
   printf("6. Numero de bloque de incio de los archivos: %d \n", leerBloque(5));
   printf("7. Numero de bloque de incio de los datos: %d \n", leerBloque(6));
   printf("-------------------------------------------------------------------- \n");
}

unsigned char montarDisco(char *pnombre){

   //Valor de retorno
   unsigned char resultado = 1;

   //Logica
   free(discoGlobal);
   discoGlobal = strdup(pnombre);
   FILE *disco = fopen(discoGlobal, "r+");

   if(disco == NULL){
      resultado = 0;
      free(discoGlobal);
   }

   fclose(disco);

   return resultado;
}

//Opcional
unsigned char desmontarDisco(){

   //Valor de retorno
   unsigned char resultado = 1;

   //Logica
   free(discoGlobal);
   FILE *disco = fopen(discoGlobal, "r+");

   if(disco != NULL){
      resultado = 0;
   }

   fclose(disco);

   return resultado;
}

unsigned char existeDiscoMontado(){

   //Valor de retorno
   unsigned char resultado = 1;

   //Logica
   if(discoGlobal == NULL){
      resultado = 0;
   }

   return resultado;
}

unsigned char potencia(long ptamanoDisco){

   if((ptamanoDisco%2) == 0){
      return 1;
   }
}

unsigned char maximoDisco(long ptamanoDisco){

   if(ptamanoDisco>4096){
      return 1;
   }
}