#include 
#include 
#include 
#include 

// these read-input-from-file functions were made with the help of chatGPT.
void readDoublesFromFile(const char *filePath, double *numbers, size_t numberOfNumbers) {
    FILE *file = fopen(filePath, "r");
    
    if (file == NULL) {
        printf("Error opening the file: %s\n", filePath);
        exit(1);
    }
    
    for (size_t i = 0; i < numberOfNumbers; i++) {
        int result = fscanf(file, "%lf", &numbers[i]);
        if (result != 1) {
            printf("Error reading double from file at index %zu, result = %d\n", i, result);
            fclose(file);
            exit(1);
        }
    }
    
    fclose(file);
}

void readIntsFromFile(const char *filePath, int *numbers, size_t numberOfNumbers) {
    FILE *file = fopen(filePath, "r");
    
    if (file == NULL) {
        printf("Error opening the file: %s\n", filePath);
        exit(1);
    }
    
    for (size_t i = 0; i < numberOfNumbers; i++) {
        int result = fscanf(file, "%d", &numbers[i]);
        if (result != 1) {
            printf("Error reading int from file at index %zu, result = %d\n", i, result);
            fclose(file);
            exit(1);
        }
    }
    
    fclose(file);
}

void readLongsFromFile(const char *filePath, long *numbers, size_t numberOfNumbers) {
    FILE *file = fopen(filePath, "r");
    
    if (file == NULL) {
        printf("Error opening the file: %s\n", filePath);
        exit(1);
    }

    for (size_t i = 0; i < numberOfNumbers; i++) {
        int result = fscanf(file, "%ld", &numbers[i]);
        if (result != 1) {
            printf("Error reading long from file at index %zu, result = %d\n", i, result);
            fclose(file);
            exit(1);
        }
    }
    
    fclose(file);
}

int main() {
    const char *rowvalPath = "pglib_opf_case30000_rowval.txt";
    const char *colptrPath = "pglib_opf_case30000_colptr.txt";
    const char *nzvalPath = "pglib_opf_case30000_nzval.txt";
    size_t numberOfNumbers = 65231;
    size_t colptrLen = 30000;
    size_t N = colptrLen - 1;

    int *rowval = (int *)malloc(numberOfNumbers * sizeof(int));
    long *colptr = (long *)malloc(colptrLen * sizeof(long));
    double *nzval = (double *)malloc(numberOfNumbers * sizeof(double));
    
    if (rowval == NULL || colptr == NULL || nzval == NULL) {
        printf("Memory allocation failed.\n");
        return 1;
    }

    readIntsFromFile(rowvalPath, rowval, numberOfNumbers);
    readLongsFromFile(colptrPath, colptr, colptrLen);
    readDoublesFromFile(nzvalPath, nzval, numberOfNumbers);

    SparseMatrixStructure s = {
        .rowCount     = N,
        .columnCount  = N,
        .columnStarts = colptr,
        .rowIndices   = rowval,
        .attributes = {
            .triangle = SparseLowerTriangle,
            .kind = SparseSymmetric,
        },
        .blockSize = 1,
    };

    SparseMatrix_Double ABA = {
        .structure = s,
        .data = nzval
    };
    
    clock_t start1, end1;
    start1 = clock();
    SparseOpaqueFactorization_Double f = SparseFactor(SparseFactorizationCholesky, ABA);
    end1 = clock();
    printf("time for factoring: %lf\n", ((double) (end1 - start1)) / CLOCKS_PER_SEC);

    size_t M = 10000;
    double* randomVs = (double *)malloc(M*N * sizeof(double));
    if (randomVs == NULL){
        printf("allocation failed");
        return 1;
    }

    srand(time(NULL));
    for (int i = 0; i < M*N; ++i)
        randomVs[i] = ((double) rand())/RAND_MAX;

    clock_t start2, end2;
    start2 = clock();
    for (int i = 0; i < M*N; i += N){
        DenseVector_Double b = {
            .count = N,
            .data = randomVs + i
        };
        SparseSolve(f, b);
    }
    end2 = clock();
    printf("time for 10k in-place solves: %lf\n", ((double) (end2 - start2)) / CLOCKS_PER_SEC);
    // Free the allocated memory
    free(rowval);
    free(colptr);
    free(nzval);
    SparseCleanup(f);
    free(randomVs);
    return 0;
}