// // // // // // // // // // // // // // // // // // // // // // // // 
//
//   CS270 Class Example
//
//   Author: Robert Heckendorn
//           University of Idaho
//
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>

void usage(char *myname)
{
    fprintf(stderr, "Usage: %s loc amount file\n", myname);
}


int main(int argc, char **argv)
{
    unsigned long long int loc;     // location in file to read from
    unsigned long long int amount;  // number of bytes to read
    char *file;    // name of file
    char *value;   // location of buffer to read into
    int valueInt;  // space allocated to read an int into
    int valueLen;  // amount actually read
    int fd;        // file descriptor

    if (argc!=4) {
        usage(argv[0]);
        exit(0);
    }

    // get args without error checking
    loc = atoi(argv[1]);
    amount = atoi(argv[2]);
    file = strdup(argv[3]);

    // open a file with the system call open.   It is opened for reading and writing
    // this assumes the file exists and will not create it if it is not
    if ((fd = open(file, O_RDWR))==-1) {
        printf("ERROR: count not open %s\n", file);
        usage(argv[0]);
        exit(1);
    }

    // TASK 1: read the requested number of bytes from the location in the given file

    // allocate up some space to read into
    value = (char *)malloc(amount);

    // move the read/write "head" to the requested location
    lseek(fd, loc, SEEK_SET);

    // try reading the requested bytes
    if ((valueLen = read(fd, value, amount))==-1) {
        printf("ERROR: reading %s at location %lld\n", file, loc);
        exit(1);
    }

    // if valueLen==0 then an immediate EOF was found
    if (valueLen==0) {
        printf("WARNING: trying to read past the end of the file.  No bytes read.\n", file);
    }

    // dump the bypes read as hex
    for (int i=loc; i<loc+valueLen; i++) {
        printf("%d %02x\n", i, value[i-loc]);
    }

    // IMPORTANT: if any EOF is found when reading then the value
    // buffer is left untouched.  If you were reading in an int but
    // got an EOF then NOTHING would be written into the int.  If you
    // were reading from the middle of sparse file where no data had
    // been written yet, but you were not at EOF then you would read
    // zeros!  Otherwise you would read in the number that was stored
    // at the location.  So initializing an int to a default value
    // before reading into it or setting it to default when EOF is
    // detected might be a good idea.

    // TASK 2: for fun try reading from the same requested location as an int
    // remember that numbers are stored in internal format.   No slow messy conversions
    // to anything we can read.  :-)

    // move the read/write "head" to the requested location
    // NOTE: the previous read moved the read/write "head"
    lseek(fd, loc, SEEK_SET);

    // for test purposes set valueInt to something recognizable.
    valueInt = 666;

    // read the int
    if ((valueLen = read(fd, &valueInt, sizeof(int)))==-1) {
        printf("ERROR: reading an int from %s at location\n", file, loc);
        exit(1);
    }

    // if valueLen==0 then an immediate EOF was found
    if (valueLen==0) {
        printf("WARNING: trying to read past the end of the file.  No bytes read.\n", file);
    }

    // this will print the int read.  If it was past EOF then valueInt should
    // be whatever was in valueInt before the read call.  If you didn't init
    // it will be junk.
    printf("Integer read: %d\n", valueInt);
    return 0;
}