#include <stdio.h>
#include <stdlib.h>
#include <sys/msg.h>
#include <string.h>

double *results;
size_t messageSize;

struct message {
    int matrixWidth;
    int mpStart;
    int rCount;
    double *vector;
    double *matrixPart;
};

/* message structure */
struct msgbuf {
    long mtype;
    char mtext[10];
};

void sendMessage(int messageQueueId, double message) {
    struct msgbuf msgbuf;
    char str[10];
    sprintf(str, "%lf", message);
    strcpy(msgbuf.mtext, str);
    msgbuf.mtype = 2;
    /* send message to queue */
    if (msgsnd(messageQueueId, &msgbuf, messageSize, 0) == -1) {
        perror("calc msgsnd");
        printf("calc msgsnd %d\n", messageQueueId);
        exit(1);
    }
}

double receiveMessage(int messageQueueId) {
    struct msgbuf msgbuf;
    messageSize = sizeof(msgbuf.mtext) + 1;
    char *ptr;
    /* receive message from queue */
    if (msgrcv(messageQueueId, &msgbuf, messageSize, 1, 0) == -1) {
        perror("calc msgrcv");
        printf("calc msgrcv %d\n", messageQueueId);
        exit(1);
    }
    return strtod(msgbuf.mtext, &ptr);
}

struct message receiveData(int messageQueueId) {
    struct message message;
    message.matrixWidth = (int) receiveMessage(messageQueueId);
    message.mpStart = (int) receiveMessage(messageQueueId);
    message.rCount = (int) receiveMessage(messageQueueId);
    message.vector = (double *) calloc(message.matrixWidth, sizeof(double));
    /* receive vector from queue */
    for (int i = 0; i < message.matrixWidth; i += 1) {
        message.vector[i] = receiveMessage(messageQueueId);
    }

    int mpSize = message.matrixWidth * message.rCount;
    message.matrixPart = (double *) calloc(mpSize, sizeof(double));
    /* receive matrix from queue */
    for (int i = 0; i < mpSize; i += 1) {
        message.matrixPart[i] = receiveMessage(messageQueueId);
    }
    printf("%d received everything\n", messageQueueId);
    return message;
}

void doCalculations(struct message message) {
    int shift;
    results = (double *) calloc(message.matrixWidth, sizeof(double));
    for (int i = 0; i < message.rCount; i += 1) {
        shift = i * message.matrixWidth;
        for (int j = 0; j < message.matrixWidth; j += 1)
            results[i] += message.matrixPart[shift + j] * message.vector[j];
    }
}

void sendResults(int messageQueueId, struct message message) {
    sendMessage(messageQueueId, message.mpStart);
    sendMessage(messageQueueId, message.rCount);
    /* send results to queue */
    for (int i = 0; i < message.rCount; i += 1) {
        sendMessage(messageQueueId, results[i]);
    }
}

void doCleanup(struct message message) {
    free(message.matrixPart);
    free(message.vector);
    free(results);
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("USAGE: satellite.exe message_queue_id\n");
        exit(1);
    }
    char *ptr;
    int messageQueueId = (int) strtol(argv[1], &ptr, 10);
    printf("messageQueueId %d\n", messageQueueId);
    struct message message = receiveData(messageQueueId);
    doCalculations(message);
    sendResults(messageQueueId, message);
    doCleanup(message);
    printf("WOW %d\n", messageQueueId);
    return 0;
}