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

#include <unistd.h>
#include <pthread.h>

struct regression {
_Atomic  long long SX;
_Atomic  long long SY;
_Atomic  long long SXX;
_Atomic  long long SYY;
_Atomic  long long SXY;
};

struct point {
  int x;
  int y;
};

#define NB_THREADS 4
#include "linear_regression_sample_datasets.h"

void print_linear_regression_results(struct regression* r, int nb_points) {
  printf("SX=%lld\n", r->SX);
  printf("SXX=%lld\n", r->SXX);
  printf("SY=%lld\n", r->SY);
  printf("SXY=%lld\n", r->SXY);

  double a, b;

  b = ((double)nb_points*r->SXY - r->SX*r->SY)/((double)nb_points*r->SXX - r->SX*r->SX);
  a = ((double)r->SY - b*r->SX)/nb_points;

  printf("\nEquation of best fit is: y = %0.4f + %0.4fx\n",a,b);
}

void linear_regression_update(struct regression* r, struct point* point) {
  r->SX  += (long long) point->x;
  r->SXX += (long long) point->x * point->x;
  r->SY  += (long long) point->y;
  r->SXY += (long long) point->x * point->y;
}

void linear_regression(struct point* points, int n) {
  struct regression r;
  r.SX = 0;
  r.SXX = 0;
  r.SY  = 0;
  r.SYY = 0;
  r.SXY = 0;

  for(int i = 0; i < n; i++) {
    linear_regression_update(&r, &points[i]);
  }

  print_linear_regression_results(&r, n);
}


void process_sample_dataset() {
  struct point *points = dataset_500;
  int nb_points = 500;
  linear_regression(points, nb_points); 
}


struct worker_info {
  struct regression *global_r;
  /* TODO: if needed, add other fields to this data structure*/
  int pipe_fd;
};

void linear_regression_worker(struct worker_info *wi) {
  struct regression r;
  r.SX  = 0;
  r.SXX = 0;
  r.SY  = 0;
  r.SYY = 0;
  r.SXY = 0;

  while(1) {  /* TODO: exit the loop when there is no more work */
    struct point p;

    /* TODO: get a new point */
    read(wi->pipe_fd, &p, sizeof(struct point));

    if(p.x == INT_MAX && p.y == INT_MAX)
      break;
    linear_regression_update(&r, &p);
  }

  wi->global_r->SX  += r.SX;
  wi->global_r->SXX += r.SXX;
  wi->global_r->SY  += r.SY;
  wi->global_r->SYY += r.SYY;
  wi->global_r->SXY += r.SXY;
}

void* worker_thread(void* arg) {
  struct worker_info *wi = arg;
  linear_regression_worker(wi);
  return NULL;
}

void process_file(char* input_file) {

  struct point *points = dataset_500;
  int nb_points = 500;

  struct regression global_r;
  global_r.SX = 0;
  global_r.SXX = 0;
  global_r.SY  = 0;
  global_r.SYY = 0;
  global_r.SXY = 0;


  pthread_t tid[NB_THREADS];
  /* TODO: Initialize wi, and create a workerthread */
  struct worker_info wi;
  wi.global_r = &global_r;
  int pipe_fd[2];
  pipe(pipe_fd);
  wi.pipe_fd = pipe_fd[0];

  for(int i = 0; i<NB_THREADS; i++) {
    pthread_create(&tid[i], NULL, worker_thread, &wi);
  }
  
  for(int i=0; i<nb_points; i++) {
    struct point *p = &points[i];
    /* TODO: communicate p to the worker thread */
    write(pipe_fd[1], p, sizeof(struct point));
  }

  for(int i=0; i<NB_THREADS; i++) {
    struct point p = {INT_MAX, INT_MAX};
    write(pipe_fd[1], &p, sizeof(struct point));
  }
  for(int i=0; i<NB_THREADS; i++) {
    pthread_join(tid[i], NULL);
  }

  print_linear_regression_results(&global_r, nb_points);
}


int main(int argc, char**argv) {
  if(argc < 2) {
    printf("usage: %s input_file\n", argv[0]);
    return EXIT_FAILURE;
  }

  process_file(argv[1]);

  return(0);
}