#include <assert.h>
#include <check.h>
#include <inttypes.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

#include "../discrete.h"
#include "../pthread.h"

uint64_t large_primes[] = {
  22181233, 30722903, 39410039, 48210479, 23878483, 32452597, 41161361,
  49978519, 25582069, 34185953, 42918971, 51754777, 27290279, 35925737,
  44679787, 53532901, 29005421, 37666553, 46439677, 55316903
};

uint64_t large_gens[] = {
  11090619, 15361451, 19705019, 24105239, 11939242, 16226298, 20580682,
  24989259, 12791034, 17092978, 21459486, 25877391, 13645139, 17962870,
  22339897, 26766452, 14502710, 18833278, 23219838, 27658451
};

uint64_t mod_powers[] = {
  10722318, 10718795, 16846904, 28514080, 13198105, 21563282, 16451148,
  31188765, 8174568, 24132030, 5838284, 8726777, 10697873, 30365043,
  40656885, 6262555, 301068, 34096955, 29442656, 36415956
};

// Move these to tests/private.c
// These are p / 4 * 3
uint64_t expected[] = {
  16635924, 23042175, 29557527, 36157857, 17908860, 24339447, 30871020,
  37483887, 19186551, 25639464, 32189226, 38816082, 20467707, 26944302,
  33509838, 40149675, 21754065, 28249914, 34829757, 41487675
};


START_TEST (MIN_find_one_generator)
{
  printf ("======================================\n");
  printf ("PUBLIC\n");
  printf ("  MIN find one generator\n");
  printf ("  Calls find generator(%" PRId64 ") in a separate thread\n", large_primes[10]);
  printf ("  Should compute %" PRId64 "\n\n", large_gens[10]);

  uint64_t single = find_gen (large_primes[10]);
  ck_assert_int_eq (single, large_gens[10]);
}
END_TEST

START_TEST (MIN_find_two_generators)
{
  printf ("======================================\n");
  printf ("PUBLIC\n");
  printf ("  MIN find two generators\n");
  printf ("  Calls find_generator(%" PRId64 ") in a separate thread\n", large_primes[0]);
  printf ("    Should compute %" PRId64 "\n", large_gens[0]);
  printf ("  Calls find_generator(%" PRId64 ") in a separate thread\n", large_primes[1]);
  printf ("    Should compute %" PRId64 "\n\n", large_gens[1]);

  uint64_t * pair = find_gens (2, large_primes);
  ck_assert (pair != NULL);
  ck_assert_int_eq (pair[0], large_gens[0]);
  ck_assert_int_eq (pair[1], large_gens[1]);
  free (pair);
}
END_TEST

START_TEST (MIN_find_5_generators)
{
  printf ("======================================\n");
  printf ("PRIVATE\n");
  printf ("  MIN find one generator\n");
  printf ("  Calls find generator() for the following values:\n  ");

  size_t i;
  for (i = 0; i < 5; i++)
    printf ("  %" PRId64, large_primes[i]);
  printf ("\n");
  uint64_t * gens = find_gens (5, large_primes);

  printf ("  Computed the following generators:\n  ");
  for (i = 0; i < 5; i++)
    printf ("  %" PRId64, gens[i]);
  printf ("\n");

  printf ("  Expected the following generators:\n  ");
  for (i = 0; i < 5; i++)
    printf ("  %" PRId64, large_gens[i]);
  printf ("\n\n");

  ck_assert (gens != NULL);
  for (i = 0; i < 5; i++)
    ck_assert_int_eq (gens[i], large_gens[i]);

}
END_TEST

START_TEST (MIN_last_5_discrete_logs)
{
  printf ("======================================\n");
  printf ("PUBLIC\n");
  printf ("  MIN last 5 discrete logs\n");
  printf ("  Uses threads to compute the discrete logarithms for:\n");
  size_t i;
  for (i = 0; i < 5; i++)
    {
      printf ("    g = %8"PRId64 "; ", large_gens[15 + i]);
      printf ("    p = %"PRId64 "; ", large_primes[15 + i]);
      printf ("    g^n = %"PRId64 "\n", mod_powers[15 + i]);
    }

  struct time_args args;
  memset (&args, 0, sizeof (args));
  args.results = calloc (20, sizeof (uint64_t));
  args.start_index = 15;
  args.number = 5;
  args.generators = large_gens;
  args.primes = large_primes;
  args.mod_powers = mod_powers;

  pthread_t thread;
  pthread_create (&thread, NULL, time_log_thread, (void *) &args);
  pthread_join (thread, NULL);
  printf ("  Thread took %lf seconds\n", args.time_taken);
  for (i = 0; i < 5; i++)
    printf ("  Computed n = %"PRId64 " [expected %"PRId64"]\n",
            args.results[15 + i], expected[15 + i]);
  printf ("\n");
  for (i = 0; i < 5; i++)
    ck_assert_int_eq (args.results[15 + i], expected[15 + i]);
  free (args.results);

}
END_TEST

START_TEST (MIN_parallel_discrete_logs)
{
  printf ("======================================\n");
  printf ("PUBLIC\n");
  printf ("  MIN parallel discrete logs\n");
  printf ("  Uses 4 threads to compute the discrete logarithms for:\n");
  size_t i;
  for (i = 0; i < 20; i++)
    {
      printf ("    g = %8"PRId64 "; ", large_gens[15 + i]);
      printf ("    p = %"PRId64 "; ", large_primes[15 + i]);
      printf ("    g^n = %"PRId64 "\n", mod_powers[15 + i]);
    }

  struct timeval start, end;
  gettimeofday (&start, NULL);
  for (i = 0; i < 20; i++)
    discrete_log (mod_powers[i], large_gens[i], large_primes[i]);
  gettimeofday (&end, NULL);
  double sequential_time = time_diff (start, end);
  printf ("  Sequential real-time took %lf seconds\n", sequential_time);

  uint64_t * logs = calloc (20, sizeof (uint64_t));

  gettimeofday (&start, NULL);
  pthread_t thread[4];
  struct time_args args[4];
  for (i = 0; i < 4; i++)
    {
      memset (&args[i], 0, sizeof (args[i]));
      args[i].results = logs;
      args[i].start_index = i * 5;
      args[i].number = 5;
      args[i].generators = large_gens;
      args[i].primes = large_primes;
      args[i].mod_powers = mod_powers;
      pthread_create (&thread[i], NULL, time_log_thread, (void *) &args[i]);
    }

  for (i = 0; i < 4; i++)
    pthread_join (thread[i], NULL);
  gettimeofday (&end, NULL);

  double parallel_time = time_diff (start, end);
  printf ("  Parallel real-time took %lf seconds\n", parallel_time);
  for (i = 0; i < 4; i++)
    printf ("    Thread %zd took %lf seconds\n", i, args[i].time_taken);

  size_t j;
  for (i = 0; i < 4; i++)
    {
      for (j = 0; j < 5; j++)
        printf ("  Thread %zd computed n = %"PRId64 " [expected %"PRId64"]\n",
                i, logs[i * 4 + j], expected[i * 4 + j]);
    }
  printf ("\n");
  for (i = 0; i < 20; i++)
    ck_assert_int_eq (logs[i], expected[i]);
  free (logs);


  ck_assert (parallel_time * 2 < sequential_time);
  ck_assert (parallel_time * 4 > sequential_time);

}
END_TEST

void public_tests (Suite *s)
{
  TCase *tc_public = tcase_create ("Public");
  tcase_set_timeout (tc_public, 20.0);
  tcase_add_test (tc_public, MIN_find_one_generator);
  tcase_add_test (tc_public, MIN_find_two_generators);
  tcase_add_test (tc_public, MIN_last_5_discrete_logs);
  tcase_add_test (tc_public, MIN_parallel_discrete_logs);
  suite_add_tcase (s, tc_public);
}