/*
 # This file is part of the Astrometry.net suite.
 # Licensed under a 3-clause BSD style license - see LICENSE
 */

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/mman.h>
#include <fcntl.h>

#include "solvedfile.h"
#include "errors.h"

#if defined(__APPLE__)
// MacOS 10.3 with gcc 3.3 doesn't have O_SYNC.
#if !defined(O_SYNC)
#define O_SYNC 0
#endif
#endif


int solvedfile_getsize(char* fn) {
    FILE* f;
    off_t end;
    f = fopen(fn, "rb");
    if (!f) {
        return -1;
    }
    if (fseek(f, 0, SEEK_END) ||
        ((end = ftello(f)) == -1)) {
        fprintf(stderr, "Error: seeking to end of file %s: %s\n",
                fn, strerror(errno));
        fclose(f);
        return -1;
    }
    return (int)end;
}

int solvedfile_get(char* fn, int fieldnum) {
    FILE* f;
    unsigned char val;
    off_t end;

    // 1-index field numbers:
    fieldnum--;

    f = fopen(fn, "rb");
    if (!f) {
        // assume it's not solved!
        return 0;
    }
    if (fseek(f, 0, SEEK_END) ||
        ((end = ftello(f)) == -1)) {
        fprintf(stderr, "Error: seeking to end of file %s: %s\n",
                fn, strerror(errno));
        fclose(f);
        return -1;
    }
    if (end <= fieldnum) {
        fclose(f);
        return 0;
    }
    if (fseeko(f, (off_t)fieldnum, SEEK_SET) ||
        (fread(&val, 1, 1, f) != 1) ||
        fclose(f)) {
        fprintf(stderr, "Error: seeking, reading, or closing file %s: %s\n",
                fn, strerror(errno));
        fclose(f);
        return -1;
    }
    return val;
}

// lastfield = 0 for no limit.
static il* solvedfile_getall_val(char* fn, int firstfield, int lastfield, int maxfields, int val) {
    FILE* f;
    off_t end;
    int fields = 0;
    il* list;
    int i;
    unsigned char* map;

    list = il_new(256);

    f = fopen(fn, "rb");
    if (!f) {
        // if file doesn't exist, assume no fields are solved.
        if (val == 0) {
            for (i=firstfield; i<=lastfield; i++) {
                il_append(list, i);
                fields++;
                if (fields == maxfields)
                    break;
            }
        }
        return list;
    }

    if (fseek(f, 0, SEEK_END) ||
        ((end = ftello(f)) == -1)) {
        fprintf(stderr, "Error: seeking to end of file %s: %s\n",
                fn, strerror(errno));
        fclose(f);
        il_free(list);
        return NULL;
    }
    // 1-index
    firstfield--;
    lastfield--;
    if (end <= firstfield) {
        fclose(f);
        return list;
    }

    map = mmap(NULL, end, PROT_READ, MAP_SHARED, fileno(f), 0);
    fclose(f);
    if (map == MAP_FAILED) {
        fprintf(stderr, "Error: couldn't mmap file %s: %s\n", fn, strerror(errno));
        il_free(list);
        return NULL;
    }

    for (i=firstfield; ((lastfield == -1) || (i<=lastfield)) && (i < end); i++) {
        if (map[i] == val) {
            // 1-index
            il_append(list, i+1);
            if (il_size(list) == maxfields)
                break;
        }
    }

    munmap(map, end);

    if (val == 0) {
        // fields larger than the file size are unsolved.
        for (i=end; i<=lastfield; i++) {
            if (il_size(list) == maxfields)
                break;
            // 1-index
            il_append(list, i+1);
        }
    }
    return list;
}

il* solvedfile_getall(char* fn, int firstfield, int lastfield, int maxfields) {
    return solvedfile_getall_val(fn, firstfield, lastfield, maxfields, 0);
}

il* solvedfile_getall_solved(char* fn, int firstfield, int lastfield, int maxfields) {
    return solvedfile_getall_val(fn, firstfield, lastfield, maxfields, 1);
}

int solvedfile_setsize(char* fn, int sz) {
    int f;
    unsigned char val;
    off_t off;
    f = open(fn, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
    if (f == -1) {
        fprintf(stderr, "Error: failed to open file %s for writing: %s\n",
                fn, strerror(errno));
        return -1;
    }
    off = lseek(f, 0, SEEK_END);
    if (off == -1) {
        fprintf(stderr, "Error: failed to lseek() to end of file %s: %s\n", fn, strerror(errno));
        close(f);
        return -1;
    }
    // this gives you the offset one past the end of the file.
    if (off < sz) {
        // pad.
        int npad = sz - off;
        int i;
        val = 0;
        for (i=0; i<npad; i++)
            if (write(f, &val, 1) != 1) {
                fprintf(stderr, "Error: failed to write padding to file %s: %s\n",
                        fn, strerror(errno));
                close(f);
                return -1;
            }
    }
    if (close(f)) {
        fprintf(stderr, "Error closing file %s: %s\n", fn, strerror(errno));
        return -1;
    }
    return 0;
}

int solvedfile_set_array(char* fn, anbool* vals, int N) {
    int f;
    unsigned char val;
    int i;

    solvedfile_setsize(fn, N);

    // (file mode 666; umask will modify this, if set).
    f = open(fn, O_WRONLY | O_CREAT | O_SYNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
    if (f == -1) {
        fprintf(stderr, "Error: failed to open file %s for writing: %s\n",
                fn, strerror(errno));
        return -1;
    }
    val = 1;
    for (i=0; i<N; i++) {
        if (!vals[i])
            continue;
        if ((lseek(f, (off_t)i, SEEK_SET) == -1) ||
            (write(f, &val, 1) != 1)) {
            fprintf(stderr, "Error: seeking or writing file %s: %s\n",
                    fn, strerror(errno));
            return -1;
        }
    }
    if (close(f)) {
        fprintf(stderr, "Error closing file %s: %s\n",
                fn, strerror(errno));
        return -1;
    }
    return 0;
}

int solvedfile_set_file(char* fn, anbool* vals, int N) {
    FILE* f;
    int i;

    // Ensure the array contains values 0, 1.
    for (i=0; i<N; i++)
        if (vals[i]) vals[i] = TRUE;
        else vals[i] = FALSE;

    f = fopen(fn, "wb");
    if (!f) {
        SYSERROR("Failed to open file \"%s\" for writing", fn);
        return -1;
    }
    if ((fwrite(vals, 1, N, f) != N) ||
        fclose(f)) {
        SYSERROR("Failed to write solved file \"%s\"", fn);
        return -1;
    }
    return 0;
}

int solvedfile_set(char* fn, int fieldnum) {
    int f;
    unsigned char val;
    off_t off;

    // 1-index
    fieldnum--;

    // (file mode 666; umask will modify this, if set).
    f = open(fn, O_WRONLY | O_CREAT | O_SYNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
    if (f == -1) {
        fprintf(stderr, "Error: failed to open file %s for writing: %s\n",
                fn, strerror(errno));
        return -1;
    }
    off = lseek(f, 0, SEEK_END);
    if (off == -1) {
        fprintf(stderr, "Error: failed to lseek() to end of file %s: %s\n", fn, strerror(errno));
        close(f);
        return -1;
    }
    // this gives you the offset one past the end of the file.
    if (off < fieldnum) {
        // pad.
        int npad = fieldnum - off;
        int i;
        val = 0;
        for (i=0; i<npad; i++)
            if (write(f, &val, 1) != 1) {
                fprintf(stderr, "Error: failed to write padding to file %s: %s\n",
                        fn, strerror(errno));
                close(f);
                return -1;
            }
    }
    val = 1;
    if ((lseek(f, (off_t)fieldnum, SEEK_SET) == -1) ||
        (write(f, &val, 1) != 1) ||
        close(f)) {
        fprintf(stderr, "Error: seeking, writing, or closing file %s: %s\n",
                fn, strerror(errno));
        close(f);
        return -1;
    }
    return 0;
}