#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "backprop.h"
#include "omp.h"

extern char *strcpy();
extern void exit();

int layer_size = 0;
int platform_id = 0;
int device_id = 0;
int use_gpu = 0;

void backprop_face()
{
  BPNN *net;
  int i;
  float out_err, hid_err;
  net = bpnn_create(layer_size, 16, 1); // (16, 1 can not be changed)

  printf("Input layer size : %d\n", layer_size);
  load(net);
  //entering the training kernel, only one iteration
  printf("Starting training kernel\n");
  bpnn_train_kernel(net, &out_err, &hid_err, platform_id, device_id, use_gpu);
  bpnn_free(net);
  printf("\nFinish the training for one iteration\n");
}

void Usage(char *argv0){

  char *help =
  "\nUsage: %s [switches] \n\n"
  "    -l               :layer size                     \n"
  "    -p platform_id   :OCL platform to use [default=0]\n"
  "    -d device_id     :OCL device to use   [default=0]\n"
  "    -g use_gpu       :1 for GPU 0 for CPU [default=0]\n";
  fprintf(stderr, help, argv0);
  exit(-1);

}

int setup(int argc, char **argv)
{

  int seed;

  int opt;
  extern char *optarg;
  while ((opt=getopt(argc,argv,"l:p:d:g:"))!= EOF) {
      switch (opt) {
          case 'p': platform_id = atoi(optarg);
                    break;
          case 'd': device_id = atoi(optarg);
                    break;
          case 'g': use_gpu = atoi(optarg);
                    break;
          case 'l': layer_size = atoi(optarg);
                    break;
          case '?': Usage(argv[0]);
                    break;
          default:  Usage(argv[0]);
                    break;
      }
  }

  if (layer_size%16!=0){
  fprintf(stderr, "The number of input points must be divided by 16\n");
  exit(0);
  }

  seed = 7;
  bpnn_initialize(seed);
  backprop_face();

  exit(0);
}