/*=======================================================*/
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <float.h>

#define MAX_NAME_LEN 80
#define MAX_NUM_TRIALS 20
#define MAX_SUBJECTS 500
#define MAX_TRIALS (MAX_SUBJECTS * MAX_NUM_TRIALS)

#define TRUE 1
#define FALSE 0

/*=======================================================*/
typedef struct
{
    char name[MAX_NAME_LEN];
    double err;
    double sec;
    int wu;
    int condition_n;
    int valid;
} trial_t;

/*-------------------------------------------------------*/
typedef struct
{
    char  name[MAX_NAME_LEN];
    int   condition_n;
} trial_key_t;

/*-------------------------------------------------------*/
typedef struct
{
    int    total_trials;
    int    total_valid_trials;
    double avg_error;
    trial_t *lowest_error;
} stats_t;

/*=======================================================*/
FILE *scan_trial_filename();
int scan_trials(FILE *infile, trial_t trials[]);
trial_t scan_trial(FILE *infile);
void print_trials(trial_t trials[], int num_trials);
void print_trial(trial_t trial);
void process_invalidations(trial_t trials[], int num_trials);
trial_t *find_trial(trial_t trials[], int num_trials, trial_key_t *key);
stats_t calc_stats(trial_t trials[], int num_trials);
void print_summary(stats_t results);

/*=======================================================*/
int main(void)
{
    int num_trials;
    FILE *trial_file;
    trial_t trials[MAX_TRIALS];
    stats_t results;

    /* Open the trial data file */
    trial_file = scan_trial_filename();
    if (trial_file == NULL)
        return 0; /* Bail out early! */

    /* Read in the trial data then close the trial file*/
    num_trials= scan_trials(trial_file, trials);
    fclose(trial_file);

    /* Process requests to invalidate certain trials */
    process_invalidations(trials, num_trials);
    print_trials(trials, num_trials);

    /* Calculate statistics on valid trials */
    results = calc_stats(trials, num_trials);

    /* Print Summary */
    print_summary(results);
    return 0;
}

/*=======================================================*/
FILE *scan_trial_filename()
{
    char trial_filename[MAX_NAME_LEN];
    FILE *trial_file;

    scanf("%s", trial_filename);
    trial_file = fopen(trial_filename, "r");
    if (trial_file == NULL)
    {
        printf("Unable to open %s\n", trial_filename);
        printf("Exiting!\n");
    }
    return trial_file;
}

/*=======================================================*/
int scan_trials(FILE *infile, trial_t trials[])
{
    int current_trial = 0;

    while (current_trial < MAX_TRIALS && !feof(infile))
    {
        trials[current_trial] = scan_trial(infile);
        current_trial++;
    }

    return current_trial - 1;/* last trial is bogus */
}

/*=======================================================*/
trial_t scan_trial(FILE *infile)
{
    trial_t result;

     result.valid = TRUE;
    /* Replace variables that were above with parts of result */
    fscanf(infile, "%s%d%lf%lf%d", result.name, &result.condition_n,
          &result.err, &result.sec, &result.wu);
    return result;
}

/*=======================================================*/
void print_trials(trial_t trials[], int num_trials)
{
    int i = 0;

    for (i = 0; i < num_trials; i++)
    {
        printf("==============\n");
        print_trial(trials[i]);
    }
    printf("==============\n");
}

/*=======================================================*/
void print_trial(trial_t trial)
{
    printf("Subject: %s\n", trial.name);
    printf("N cond.: %d\n", trial.condition_n);
    printf(" Errors: %f\n", trial.err);
    printf("   Time: %f\n", trial.sec);
    printf("W-Units: %d\n", trial.wu);
    printf("  Valid: %d\n", trial.valid);
}

/*=======================================================*/
void process_invalidations(trial_t trials[], int num_trials)
{
    trial_key_t key;
    trial_t *found = NULL;

    while (scanf("%s%d", key.name, &key.condition_n) != EOF)
    {
        found = find_trial(trials, num_trials, &key);
        if (found)
            found->valid = FALSE;
        else
            printf("Could not find %s(%d)\n",
                   key.name, key.condition_n);
    }
}

/*=======================================================*/
trial_t *find_trial(trial_t trials[], int num_trials, trial_key_t *key)
{

    int i;
    int v;

    for (i=0; i<num_trials; i++)
    {
       v = strcmp(trials[i].name, key->name);
       if (v == 0 && trials[i].condition_n == key->condition_n)
       {
               return (&trials[i]);
       }

    }


    return NULL;
}

/*=======================================================*/
stats_t calc_stats(trial_t trials[], int num_trials)
{
    stats_t results = {0};

    trial_t *cur_trial = NULL;
    int i;
    int valid = 0;

    double error_sum = 0.0;
    double eff_sum = 0.0;
    double min_error = FLT_MAX;
    /*double efficiency = 0.0;
    double max_eff = -1.0; */

       /*Total valid trials*/
       for (i = 0; i < num_trials; i++)
       {
       cur_trial = &trials[i];
       if (cur_trial->valid != FALSE)
           valid++;
       }

       /*Sum error*/
        for (i = 0; i < num_trials; i++)
       {
           cur_trial = &trials[i];
           if (cur_trial->valid != FALSE)
               error_sum += cur_trial->err;
       }

       /*Find lowest error*/
    for(i = 0; i <=num_trials; i++)
    {
        cur_trial = &trials[i];
           if (cur_trial->valid != FALSE)
           cur_trial->err;

        if ((cur_trial->err) < min_error)
                {
                        min_error = cur_trial->err;
                }
    }




    results.total_trials=num_trials;
    results.total_valid_trials = valid;
    results.avg_error = error_sum/results.total_valid_trials;


    if (num_trials <= 0)
        return results;

    return results;
}

/*=======================================================*/
void print_summary(stats_t results)
{
    printf("=====Results=====\n");
    printf("  Total trials: %d\n", results.total_trials);
    printf("   Total valid: %d\n", results.total_valid_trials);
    printf("     Avg error: %f\n", results.avg_error);
    if (results.lowest_error)
    {
        printf("\n==>Trial showing lowest error<==\n");
        print_trial(*results.lowest_error);
    }
    if (results.best.efficiency)
    {
        printf("\n==>Trial showing lowest error<==\n");
        print_trial(*results.lowest_error);
    }


}