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

struct tipo_libro {
    int signatura;
    char titulo[20];
    char autor[25];
    float precio;
    int num_paginas;
    char genero[20];
    char nombre_amigo[25];
    int prestado;
    int activo;
    char fecha_prestamo[15];
};
struct tipo_lista_libro {
    int signatura;
    char titulo[20];
    char autor[25];
    float precio;
    int num_paginas;
    char genero[20];
    char nombre_amigo[25];
    int prestado;
    int activo;
    char fecha_prestamo[15];

    struct tipo_lista_libro *sig;
};

//Declaración de funciones
void anadir_libro(int signatura);
void prestar_libro(int signatura, char amigo[30]);
char *obtener_fecha_actual();
void devolver_libro(int signatura);
void borrar_libro(int signatura);
void listar_libros_prestados();
void listar_libros_prestados_fichero();
void listar_libros();
void listar_libros_fichero();
void listar_amigos_con_prestamo();
void listar_amigos_con_prestamo_fichero();
int obtener_signatura();
void guardar_signatura(int signatura);
struct tipo_lista_libro *anadir_libro_lista(struct tipo_libro libro, struct tipo_lista_libro *lista);
void imprimir_lista_libros(struct tipo_lista_libro *lista);
struct tipo_lista_libro *ordenar_lista_libros_sel(struct tipo_lista_libro *lista);
struct tipo_lista_libro *volcar_libros_fichero_lista(fichero, lista_libros);
void imprimir_lista_libros_fichero(struct tipo_lista_libro *lista, FILE *fichero);

//Menú principal
int main()
{
    int signatura=0, signatura_devolver=0, signatura_eliminar=0;
    char opcion=' ';
    FILE *fichero=NULL;
    char nombre_amigo[25];
    struct tipo_lista_libro *lista_libros=NULL;


    while (1) {
        //Mostramos el menú
        printf(" **********   MENU   ********************************************************\n");
        printf(" *                                                                          *\n");
        printf(" *  1.- Introducir libros                                                   *\n");
        printf(" *  2.- Prestar libros                                                      *\n");
        printf(" *  3.- Devolver libros                                                     *\n");
        printf(" *  4.- Eliminar libros                                                     *\n");
        printf(" *  5.- Listar libros en pantalla ordenados por signatura (titulo y autor)  *\n");
        printf(" *  6.- Listar libros en fichero ordenados por signatura (titulo y autor)   *\n");
        printf(" *  7.- Listar libros en pantalla ordenados por titulo (titulo y autor)     *\n");
        printf(" *  8.- Listar libros en fichero ordenados por titulo (titulo y autor)      *\n");
        printf(" *  9.- Listar libros prestados en pantalla (amigo y fecha prestamo)        *\n");
        printf(" *  a.- Listar libros prestados en fichero (amigo y fecha prestamo)         *\n");
        printf(" *  b.- Listar amigos que tienen algo prestado en pantalla                  *\n");
        printf(" *  c.- Listar amigos que tienen algo prestado en fichero                   *\n");
        printf(" *  0.- Salir                                                               *\n");
        printf(" *                                                                          *\n");
        printf(" ****************************************************************************\n");
        printf("\n Opcion: ");

        scanf("%c", &opcion);
        fflush(stdin);

        if (opcion=='0') {
            return 0;
        }

        if (opcion=='1') {
            //Introducir libros
            //Obtenemos la siguiente signatura
            signatura = obtener_signatura();
            anadir_libro(signatura);
            guardar_signatura(signatura + 1);
        }

        if (opcion=='2') {
            //Prestar libros
            //signatura = obtener_signatura();
            printf("A quien quieres prestar el libro? ");
            gets(nombre_amigo);
            printf("Introduce la signatura del libro a prestar: ");
            scanf("%d",&signatura);
            fflush(stdin);
            prestar_libro(signatura, nombre_amigo);
            //guardar_signatura(signatura + 1);
        }

        if (opcion=='3') {
            //Devolver libros
            printf("Introduzca la signatura del libro a devolver: ");
            scanf("%d", &signatura_devolver);
            fflush(stdin);
            devolver_libro(signatura_devolver);
        }

        if (opcion=='4') {
            //Eliminar libros
            printf("Introduzca la signatura del libro a borrar: ");
            scanf("%d", &signatura_eliminar);
            fflush(stdin);
            borrar_libro(signatura_eliminar);
        }

        if (opcion=='5') {
            //Listar libros en pantalla ordenados por signatura (titulo y autor)
            //Probamos listar libros en pantalla (sin ordenar) -> modificar más tarde
            listar_libros();
        }

        if (opcion=='6') {
            //Listar libros en fichero ordenados por signatura (titulo y autor)
            printf("Generando fichero...\n");
            listar_libros_fichero();
        }

        if (opcion=='7') {
            //Listar libros en pantalla ordenados por titulo (titulo y autor)
            //Obtenemos un array con todos los libros activos
            lista_libros = volcar_libros_fichero_lista(lista_libros);
            //Ordenamos el array de los libros por el campo título
            lista_libros = ordenar_lista_libros_sel(lista_libros);
            //Mostramos el contenido de del array por pantalla
            imprimir_lista_libros(lista_libros);
        }

        if (opcion=='8') {
            //Listar libros en fichero ordenados por titulo (titulo y autor)
            //Obtenemos un array con todos los libros activos
            lista_libros = volcar_libros_fichero_lista(lista_libros);
            //Ordenamos el array de los libros por el campo título
            lista_libros = ordenar_lista_libros_sel(lista_libros);
            //Creamos el fichero de texto para guardar el listado
            fichero = fopen("lib_ord.txt","w");
            //Mostramos el contenido de del array por pantalla
            printf("Generando fichero...\n");
            imprimir_lista_libros_fichero(lista_libros,fichero);
            fclose(fichero);
        }

        if (opcion=='9') {
            //Listar libros prestados en pantalla (amigo y fecha prestamo)
            listar_libros_prestados();
        }

        if (opcion=='a') {
            //Listar libros prestados en fichero (amigo y fecha prestamo)
            printf("Generando fichero...\n");
            listar_libros_prestados_fichero();
        }

        if (opcion=='b') {
            //Listar amigos que tienen algo prestado en pantalla
            listar_amigos_con_prestamo();
        }

        if (opcion=='c') {
            //Listar amigos que tienen algo prestado en fichero
            printf("Generando fichero...\n");
            listar_amigos_con_prestamo_fichero();
        }


        printf(" Pulse <ENTER> para continuar...");
        getchar();
        system("cls");
    }

    return 0;
}


//Esta función realiza la tarea de añadir un libro a la librería. La función solicita los datos correspondientes
//al libro por pantalla y posteriormente guarda esos datos en el fichero binario que almacena todos los libros
//existentes en la librería.
void anadir_libro(int signatura) {
    struct tipo_libro libro;
    FILE *fichero=NULL;

    printf("  Titulo: ");
    gets(libro.titulo);
    printf("  Autor: ");
    gets(libro.autor);
    printf("  Precio: ");
    scanf("%f", &libro.precio);
    printf("  Numero paginas: ");
    scanf("%d", &libro.num_paginas);
    fflush(stdin);
    printf("  Genero: ");
    gets(libro.genero);
    libro.prestado=0;
    strcpy(libro.nombre_amigo, "");
    strcpy(libro.fecha_prestamo, "");
    libro.signatura = signatura;
    libro.activo = 1;

    fichero = fopen("libros.dat", "ab");
    fwrite(&libro,sizeof(libro),1,fichero);
    fclose(fichero);
}

//Esta función se ocupa de indicar que un determinado libro ha sido prestado a un amigo. En la función
//se localiza el registro correspondiente y se modifican los campos prestado y nombre_amigo. La signatura
//y el nombre del amigo se pasan a la funcion como parámetros.
void prestar_libro(int signatura, char amigo[25]) {
    struct tipo_libro libro;
    FILE *fichero=NULL;
    int long_fichero=0, registros=0, i=0;
    char fecha_actual[15]="";

    fichero = fopen("libros.dat","rb+");
    //Comprobamos si hay libros para prestar
    if (fichero!=NULL){
        fseek(fichero,0,SEEK_END);
        long_fichero = ftell(fichero);
        //Comprobamos si el fichero está vacío
        if (long_fichero>0) {
            registros = long_fichero/sizeof(libro);

            //Nos situamos al principio del fichero nuevamente
            fseek(fichero, 0, SEEK_SET);
            for (i=0; i<registros; i++) {
                fread(&libro,sizeof(libro),1,fichero);
                //Comprobamos si el libro está activo y la signatura coincide con la del libro que queremos prestar
                if (libro.activo && libro.signatura==signatura) {
                    libro.prestado = 1;  //indicamos que está prestado
                    strcpy(libro.nombre_amigo,amigo);  //añadimos el nombre del amigo al que se lo prestamos
                    //Obtenemos la fecha actual (para reflejar cuando se realizó el prestamo)
                    strcpy(fecha_actual, obtener_fecha_actual());
                    //printf("La fecha actual es: %s\n",fecha_actual);
                    strcpy(libro.fecha_prestamo, fecha_actual);
                    fseek(fichero,(-1)*sizeof(libro),SEEK_CUR);
                    fwrite(&libro,sizeof(libro),1,fichero);
                    break;
                }
            }
        }
        else {
            //El fichero está vacío
            printf("No hay libros en la estanteria. No se puede realizar el prestamo\n");
        }
        fclose(fichero);
    }else {
        //El fichero no existe
        printf("No hay libros en la estanteria. No se puede realizar el prestamo\n");
    }

}

//Esta función devuelve una cadena con la fecha actual en formato dd-mm-aaaa
char *obtener_fecha_actual() {
    time_t now=NULL;
    struct tm *date=NULL;
    char fecha[15]="";

    now = time(NULL);
    date = localtime(&now);
    sprintf(fecha, "%02d-%02d-%04d",date->tm_mday,date->tm_mon+1,date->tm_year+1900);

    return fecha;
}

//Esta función permite modificar la situación de un determinado libro, poniendo a cero el
//campo que indica que el libro ha sido prestado y borrando el nombre del amigo al que había
//sido prestado.
//La función recibe como parámetro la signatura del libro devuelto.
void devolver_libro(int signatura) {
    FILE *fichero=NULL;
    struct tipo_libro libro;
    int long_fichero=0, registros=0;
    int i=0, read=0;

    //Obtenemos la longitud del fichero y el número de registros que contiene
    fichero = fopen("libros.dat", "rb+");
    fseek(fichero,0,SEEK_END);
    long_fichero = ftell(fichero);
    registros = long_fichero/sizeof(libro);

    //Colocamos el puntero de lectura al inicio del fichero
    fseek(fichero,0,SEEK_SET);
    for (i=0; i<registros; i++) {
        fread(&libro, sizeof(libro),1,fichero);
        if (libro.activo && libro.signatura==signatura) {
            libro.prestado=0;
            strcpy(libro.nombre_amigo,"");
            fseek(fichero, (-1)*sizeof(libro),SEEK_CUR);
            fwrite(&libro,sizeof(libro),1,fichero);
            break;
        }
    }
    fclose(fichero);
}

//Esta función desactiva el registro correspondiente a un libro determinado. El libro en
//cuestión viene determinado por la signatura que se le pasa como parámetro.
void borrar_libro(int signatura) {
    FILE *fichero=NULL;
    struct tipo_libro libro;
    int long_fichero=0, registros=0;
    int i=0;

    //Obtenemos la longitud del fichero y el número de registros que contiene
    fichero = fopen("libros.dat", "rb+");
    fseek(fichero,0,SEEK_END);
    long_fichero = ftell(fichero);
    registros = long_fichero/sizeof(libro);

    //Colocamos el puntero de lectura al inicio del fichero
    fseek(fichero,0,SEEK_SET);
    for (i=0; i<registros; i++) {
        fread(&libro, sizeof(libro), 1, fichero);
        if (libro.activo && (libro.signatura==signatura)) {
            libro.activo=0;
            fseek(fichero, (-1)*sizeof(libro),SEEK_CUR);
            fwrite(&libro, sizeof(libro),1,fichero);
            break;
        }
    }
    fclose(fichero);
}

//Esta función muestra por pantalla un listado de todos los libros (no eliminados previamente) que están
//prestados a algún amigo actualmente.
void listar_libros_prestados() {
    FILE *fichero=NULL;
    struct tipo_libro libro;
    int long_fichero=0, registros=0;
    int i=0, read=0;

    fichero = fopen("libros.dat", "rb");
    //Comprobamos si el fichero existe
    if (fichero !=NULL) {
        fseek(fichero,0,SEEK_END);
        long_fichero = ftell(fichero);
        registros = long_fichero/sizeof(libro);

        //Volvemos al principio del fichero
        fseek(fichero,0,SEEK_SET);
        printf("\n  LIBROS PRESTADOS .............................\n\n");
        for (i=0; i<registros; i++) {
            read = fread(&libro,sizeof(libro),1,fichero);
            if (libro.activo && libro.prestado && read>0) {
                printf("  %s   Titulo: %-25s  ->  Amigo: %s\n", libro.fecha_prestamo, libro.titulo, libro.nombre_amigo);
            }
        }
        printf("\n");
        fclose(fichero);
    }
}

//Esta función genera un listado de todos los libros (no eliminados previamente) que están
//prestados a algún amigo actualmente y lo vuelca a un fichero llamado lib_pres.txt
void listar_libros_prestados_fichero() {
    FILE *fichero=NULL;
    FILE *fichero_listado=NULL;
    struct tipo_libro libro;
    int long_fichero=0, registros=0;
    int i=0, read=0;
    char linea[80]="";

    //Abrimos el fichero de texto donde guardaremos el listado
    fichero_listado=fopen("lib_pres.txt","w");

    //Abrimos el fichero binario dónde están guardados los libros, y obtenemos la longitud y el número de registros que contiene.
    fichero = fopen("libros.dat", "rb");
    fseek(fichero,0,SEEK_END);
    long_fichero = ftell(fichero);
    registros = long_fichero/sizeof(libro);

    //Volvemos al principio del fichero
    fseek(fichero,0,SEEK_SET);
    for (i=0; i<registros; i++) {
        read = fread(&libro,sizeof(libro),1,fichero);
        if (libro.activo && libro.prestado && read>0) {
            sprintf(linea, "%s   Titulo: %-25s  ->  Amigo: %s\n", libro.fecha_prestamo, libro.titulo, libro.nombre_amigo);
            fputs(linea,fichero_listado);
//            printf("Fecha: %s    Titulo: %30s   --> Amigo: %s\n", libro.fecha_prestamo, libro.titulo, libro.nombre_amigo);
        }
    }
    //Cerramos los ficheros
    fclose(fichero);
    fclose(fichero_listado);
}

//Esta función recorre todos los elementos del fichero binario que almacena todos los libros existentes en
//la librería y muestra sus datos por pantalla. El fichero del que se obtienen los datos es "libros.dat".
void listar_libros() {
    FILE *fichero=NULL;
    int long_file=0, registros=0, i=0;
    struct tipo_libro libro;

    fichero = fopen("libros.dat","rb");
    if (fichero!=NULL) {
        //Obtenemos la longitud del fichero en bytes y el número de registros que contiene
        fseek(fichero,0,SEEK_END);
        long_file=ftell(fichero);
        registros = long_file/sizeof(struct tipo_libro);

        //Volvemos al principio del fichero
        fseek(fichero,0,SEEK_SET);
        printf("\n    LIBROS GUARDADOS ...........................\n");
        for (i=0; i<registros; i++) {
            //Leemos cada uno de los libros del fichero
            fread(&libro,sizeof(libro),1,fichero);
            if (libro.activo) {  //No estarán activos si han sido borrados
                //Mostramos por pantalla el listado de los libros si no han sido borrados
                printf("\n    Titulo: %-25s      Autor: %s\n", libro.titulo,libro.autor);
                printf("    Paginas: %-5d    Genero: %s", libro.num_paginas,libro.genero);
                printf("\n    Signatura: %d      Precio: %.2f\n", libro.signatura, libro.precio);
                printf("    Prestado: %d   Amigo: %s\n\n", libro.prestado, libro.nombre_amigo);
            }
        }

        fclose(fichero);
    }
}

//Esta función recorre todos los elementos del fichero binario que almacena todos los libros existentes en
//la librería y vuelca los datos obtenidos a un fichero de texto llamado "libros.txt". El fichero del que
//se obtienen los datos es "libros.dat".
void listar_libros_fichero() {
    FILE *fichero=NULL;
    FILE *fichero_libros=NULL;
    int long_file=0, registros=0, i=0;
    struct tipo_libro libro;
    char linea[80]="";

    //Abrimos los ficheros (el de texto para almacenar el listado, y el binario para obtener los libros almacenados)
    fichero_libros = fopen("libros.txt","w");
    fichero = fopen("libros.dat","rb");
    if (fichero!=NULL) {
        //Obtenemos la longitud del fichero en bytes y el número de registros que contiene
        fseek(fichero,0,SEEK_END);
        long_file=ftell(fichero);
        registros = long_file/sizeof(struct tipo_libro);

        //Volvemos al principio del fichero
        fseek(fichero,0,SEEK_SET);
        for (i=0; i<registros; i++) {
            //Leemos cada uno de los libros del fichero
            fread(&libro,sizeof(libro),1,fichero);
            if (libro.activo) {  //No estarán activos si han sido borrados
                //Volcamos la información del libro actual al fichero de texto
                sprintf(linea, "Titulo: %-25s   Autor: %s\nPaginas: %-5d   Genero: %s\nSignatura: %d     Precio: %.2f\n\n",libro.titulo,
                        libro.autor,libro.num_paginas,libro.genero,libro.signatura,libro.precio);
                fputs(linea,fichero_libros);
//                printf("\n    Titulo: %-30s      Autor: %s\n", libro.titulo,libro.autor);
//                printf("    Paginas: %-5d    Genero: %s", libro.num_paginas,libro.genero);
//                printf("\n    Signatura: %d      Precio: %.2f\n", libro.signatura, libro.precio);
//                printf("    Prestado: %d   Amigo: %s\n\n", libro.prestado, libro.nombre_amigo);
            }
        }

        fclose(fichero);
        fclose(fichero_libros);
    }
}

//Esta función se ocupa de listar por pantalla todos los amigos a los que se le ha prestado algún libro. La
//función recorre el fichero donde se guardan la información sobre los libros, comprobando si han sido prestados.
//En caso afirmativo, se lista el nombre del amigo que aparece en la ficha del libro prestado.
void listar_amigos_con_prestamo(){
    FILE *fichero=NULL;
    int long_file=0, registros=0, i=0;
    struct tipo_libro libro;

    fichero = fopen("libros.dat","rb");
    if (fichero!=NULL) {
        //Obtenemos la longitud del fichero en bytes y el número de registros que contiene
        fseek(fichero,0,SEEK_END);
        long_file=ftell(fichero);
        registros = long_file/sizeof(struct tipo_libro);

        //Volvemos al principio del fichero
        fseek(fichero,0,SEEK_SET);
        printf("\n    AMIGOS CON PRESTAMOS ....................\n\n");
        for (i=0; i<registros; i++) {
            //Leemos cada uno de los libros del fichero
            fread(&libro,sizeof(libro),1,fichero);
            if (libro.activo && libro.prestado) {  //No estarán activos si han sido borrados
                //Mostramos por pantalla el listado de los amigos que tienen algún libro prestado
                printf("    %-25s   ->  Libro: %s\n",libro.nombre_amigo, libro.titulo);
            }
        }
        if (registros==0) {
            printf("Actualmente no hay prestamos.\n");
        }
        printf("\n");
        fclose(fichero);
    }
    else {
        printf("No hay libros para prestar\n\n");
    }
}

//Esta función realiza un listado de los amigos a los que hemos prestado algún libro y lo guarda en un fichero de texto
//llamado "ami_pres.txt". Para obtener el listado recorre los datos almacenados en el fichero "libros.dat" y obteniendo
//los datos referentes a aquellos que aparecen como prestados. De esos se muestra el campo nombre_amigo.
void listar_amigos_con_prestamo_fichero() {
    FILE *fichero=NULL;
    FILE *fichero_listado=NULL;
    int long_file=0, registros=0, i=0;
    struct tipo_libro libro;
    char linea[80]="";

    fichero = fopen("libros.dat","rb");
    fichero_listado = fopen("ami_pres.txt","w");
    if (fichero!=NULL) {
        //Obtenemos la longitud del fichero en bytes y el número de registros que contiene
        fseek(fichero,0,SEEK_END);
        long_file=ftell(fichero);
        registros = long_file/sizeof(struct tipo_libro);

        //Volvemos al principio del fichero
        fseek(fichero,0,SEEK_SET);
        //fputs("    AMIGOS CON PRESTAMOS ....................\n\n",fichero_listado);
        for (i=0; i<registros; i++) {
            //Leemos cada uno de los libros del fichero
            fread(&libro,sizeof(libro),1,fichero);
            if (libro.activo && libro.prestado) {  //No estarán activos si han sido borrados
                //Volcamos en el fichero el listado de los amigos que tienen algún libro prestado
                sprintf(linea, "%-25s   ->  Libro: %s\n",libro.nombre_amigo, libro.titulo);
                fputs(linea,fichero_listado);
            }
        }
        if (registros==0) {
            printf("Actualmente no hay prestamos.\n");
        }
        printf("\n");
        fclose(fichero);
        fclose(fichero_listado);
    }
    else {
        printf("No hay libros para prestar\n\n");
    }
}

//Esta función realiza una ordenación de una lista de libros por su campo título (en orden ascendente). El método de ordenación
//implementado es el de selección. La función recibe un puntero al inicio de la lista como parámetro y devuelve un puntero al
//principio de la lista ordenada.
struct tipo_lista_libro *ordenar_lista_libros_sel(struct tipo_lista_libro *lista) {
    struct tipo_lista_libro *lista_aux = NULL, *lista_aux2 = NULL;
    struct tipo_libro libro;

    lista_aux = lista;
    if (lista != NULL) {
        while (lista_aux->sig != NULL) {
            lista_aux2 = lista_aux->sig;
            while (lista_aux2 != NULL) {
                if (strcmp(lista_aux->titulo, lista_aux2->titulo)>0) {
                    //Copiamos el contenido de lista_aux a una variable temporal
                    strcpy(libro.titulo, lista_aux->titulo);
                    strcpy(libro.autor, lista_aux->autor);
                    libro.num_paginas = lista_aux->num_paginas;
                    libro.precio = lista_aux->precio;
                    libro.prestado = lista_aux->prestado;
                    libro.signatura = lista_aux->signatura;
                    strcpy(libro.genero, lista_aux->genero);
                    //Copiamos el contenido de lista_aux2 a lista_aux
                    strcpy(lista_aux->titulo, lista_aux2->titulo);
                    strcpy(lista_aux->autor, lista_aux2->autor);
                    lista_aux->num_paginas = lista_aux2->num_paginas;
                    lista_aux->precio = lista_aux2->precio;
                    lista_aux->prestado = lista_aux2->prestado;
                    lista_aux->signatura = lista_aux2->signatura;
                    strcpy(lista_aux->genero, lista_aux2->genero);
                    //Copiamos en lista_aux2 el contenido de la variable auxiliar
                    strcpy(lista_aux2->titulo, libro.titulo);
                    strcpy(lista_aux2->autor, libro.autor);
                    lista_aux2->num_paginas = libro.num_paginas;
                    lista_aux2->precio = libro.precio;
                    lista_aux2->prestado = libro.prestado;
                    lista_aux2->signatura = libro.signatura;
                    strcpy(lista_aux2->genero, libro.genero);
                }
                lista_aux2 = lista_aux2->sig;
            }
            lista_aux = lista_aux->sig;
        }
    }
    return lista;
}

//Esta función nos permite obtener la signatura asignada al último libro añadido a la librería. La signatura se
//obtiene de un fichero binario llamado "signatura.dat".
int obtener_signatura() {
    FILE *fich_signatura=NULL;
    int signatura=0, num=0;

    fich_signatura = fopen("sig.dat","rb");
    if (fich_signatura!=NULL) {
        num = fread(&signatura, sizeof(int), 1, fich_signatura);
        if (num==0) signatura = 1;  //inicializamos la signatura si no existe
        fclose(fich_signatura);
    }
    else {
        signatura = 1;
    }

    return signatura;
}

//Esta función permite guardar la signatura asignada al último libro añadido a la librería. La signatura
//se guardará en un fichero binario llamado "signatura.dat".
void guardar_signatura(int signatura) {
    FILE *fich_signatura=NULL;

    fich_signatura = fopen("C:\\pai\\CProjects\\3010-EstebanBacelo\\sig.dat","wb");
    fwrite(&signatura,sizeof(int),1,fich_signatura);
    fclose(fich_signatura);
}

//Esta función nos permite añadir nuevos libros a una lista. Recibe como parámetros una estructura con los datos del libro y
//un puntero al inicio de la lista. La función devuelve el puntero al inicio de la lista de libros con el nuevo incluido.
struct tipo_lista_libro *anadir_libro_lista(struct tipo_libro libro, struct tipo_lista_libro *lista) {
    struct tipo_lista_libro *item_lista = NULL;

    item_lista=(struct tipo_lista_libro *)malloc(sizeof(struct tipo_lista_libro));
    strcpy(item_lista->autor, libro.autor);
    strcpy(item_lista->titulo, libro.titulo);
    strcpy(item_lista->genero, libro.genero);
    item_lista->num_paginas = libro.num_paginas;
    item_lista->precio = libro.precio;
    item_lista->prestado = 0;
    item_lista->sig = NULL;

    if (lista==NULL) {
        lista = item_lista;
    } else {
        item_lista->sig = lista;
        lista = item_lista;
    }

    return lista;
}

//Esta función realiza la tarea de mostrar por pantalla el contenido de una lista de libros.
void imprimir_lista_libros(struct tipo_lista_libro *lista) {
    struct tipo_lista_libro *ptr_aux=NULL;

    if (lista!=NULL) {
        printf("\n    LIBROS ORDENADOS POR TITULO ...........\n\n");
        ptr_aux = lista;
        while (ptr_aux!=NULL) {
            printf("    Titulo: %-25s      Autor: %s\n",ptr_aux->titulo, ptr_aux->autor);
            ptr_aux = ptr_aux->sig;
        }
        printf("\n");
    }
}

//Esta función realiza la tarea de guardar en un fichero el contenido de una lista de libros. Recibe
//como parámetros un puntero al inicio de la lista de libros, y un puntero al fichero de texto donde
//queremos guardar el listado de todos los libros contenidos en la lista.
void imprimir_lista_libros_fichero(struct tipo_lista_libro *lista, FILE *fichero) {
    struct tipo_lista_libro *ptr_aux=NULL;
    char linea[80]="";

    if (fichero!=NULL) {
        if (lista != NULL) {
            ptr_aux = lista;
            while (ptr_aux!=NULL) {
                sprintf(linea, "Titulo: %-25s      Autor: %s\n",ptr_aux->titulo, ptr_aux->autor);
                fputs(linea, fichero);
                ptr_aux = ptr_aux->sig;
            }
        }
    }
    else {
        printf("No se ha podido crear el fichero\n");
    }
}

//Esta función obtiene los libros almacenados en un fichero binario y los introduce en la lista que se indica como
//parámetro. La función devuelve un puntero al inicio de la lista con los libros leídos del fichero.
struct tipo_lista_libro *volcar_libros_fichero_lista(fichero, lista_libros) {
    struct tipo_lista_libro *lista=NULL;
    struct tipo_libro libro;
    int long_file=0, registros=0;
    int i=0;

    fichero = fopen("libros.dat","rb");
    if (fichero != NULL) {
        //Obtenemos la longitud del fichero en bytes y el número de registros que contiene
        fseek(fichero,0,SEEK_END);
        long_file=ftell(fichero);
        registros = long_file/sizeof(struct tipo_libro);

        //Volvemos al principio del fichero
        fseek(fichero,0,SEEK_SET);
        for (i=0; i<registros; i++) {
            //Leemos cada uno de los libros del fichero
            fread(&libro,sizeof(libro),1,fichero);
            if (libro.activo) {  //No estarán activos si han sido borrados
                lista = anadir_libro_lista(libro, lista);
            }
        }
    }
    fclose(fichero);

    return lista;
}