/*
Compile: make merge_arrays
Run: ./merge_arrays
make merge_arrays && ./merge_arrays
*/

#include "base.h"
//HIHIHIHIHIHIHIHI

//template begin

struct Bike{
    int wheel_size; // 20 - 30 inch
    int gear_count; // 1-27 gears
    float price; //0.0 Euro - ...
};

typedef struct Bike Bike;

int compare(Bike* bike1, Bike* bike2);

double calculate_coolness(Bike* bike);

//prints a bike and it's coolness.
void print_bike(Bike* bike){
    printf("Coolness: %5.1lf of bike with %2d' wheels and %2d gears for %8.2f Euro\n", calculate_coolness(bike), bike->wheel_size, bike->gear_count, bike->price);
}

// Initializes a bike with randowm values.
void init_rnd_bike(Bike* bike){
    bike->gear_count = i_rnd(27) + 1;
    (*bike).wheel_size = i_rnd(10) + 20;
    bike->price = (float)d_rnd(2000.0);
}
// Initializes a given bike array.
void init_sorted_bike_array(Bike* bikes, int length){
    for(int i = 0; i < length; i++){
        init_rnd_bike(bikes + i);
        //print_bike(bikes + i);
    }

    bool unsorted = true;
    while(unsorted){
        unsorted = false;
        int i = 0;
        while( i < length - 1){
            if(compare(bikes + i , bikes + i + 1) > 0) {
                Bike temp = *(bikes + i);
                bikes[i] = bikes[i + 1];
                bikes[i + 1] = temp;
                unsorted = true;
            }
            i++;
        }
    }
}

bool check_merged_array(Bike* bikes, int length){
    for(int i = 0; i < length - 1 ; i++){
        if(compare(bikes + i , bikes + i + 1) > 0 ){
            return false;
        }
    }
    return true;
}

//template end

//Calculates and returns the coolness of a given Bike.
double calculate_coolness(Bike* bike){
    double price_factor = 1.0;
    double wheel_factor = 1.0;
    double gear_factor = 1.0;

    // todo: implement
	price_factor = (-2.75)*pow(10.0, -6)*pow((bike->price-1000),2)+3;
	gear_factor = (1/7)*bike->gear_count+0.5;
    if(bike->wheel_size >= 24 || bike->wheel_size <= 27){
  		wheel_factor = 1.9;
  	}
  	else {
  		wheel_factor = 0.9;
  	}

    // end: implement
    return price_factor * gear_factor * wheel_factor;
}
// Compares two bikes. Returns -1 if bike1 is "cooler" than bike2, 1 if bike2 is "cooler" than bike1, else 0
int compare(Bike* bike1, Bike* bike2){
    // todo: implement
  double coolness_bike1 = calculate_coolness(bike1);
  double coolness_bike2 = calculate_coolness(bike2);

  if(coolness_bike1 < coolness_bike2) {
			return -1;
  			}
    else if (coolness_bike1 > coolness_bike2) {
    	return 1;
  			}

  return 0; //todo
}


// Merge sorted arrays bikes1 and bikes2, such that the result is sorted array bout.
void merge_arrays(Bike* bikes1, int n1, Bike* bikes2, int n2, Bike* bout) {
	int counterb1 = 0;
  int counterb2 = 0;
  for(int i = 0;i != n1+n2; i++){

    if(counterb1 == n1) {
      int j = i;
      for(;j != n1+n2; j++){
        bout[j] = bikes2[counterb2];
        counterb2++;
      }
      break;
    }

    if(counterb2 == n1) {
      int j = i;
      for(;j != n1+n2; j++){
        bout[j] = bikes1[counterb1];
        counterb1++;
      }
      break;
    }

   	else if (compare(&bikes1[counterb1],&bikes2[counterb2]) == -1){
    	bout[i] = bikes2[counterb2];
      counterb2++;
    }
  	else if (compare(&bikes1[counterb1],&bikes2[counterb2]) == 1){
    	bout[i] = bikes1[counterb1];
      counterb1++;
    }
  	else {
  		bout[i] = bikes1[counterb1];
      counterb1++;
  	}
  }
}

// Test array merging.
void merge_arrays_test(void) {

    // Declaration of arrays
    int n1 = 10;
    Bike bikes1[n1];
    int n2 = 12;
    Bike bikes2[n2];
    Bike bikes_merged[n1 + n2];

    // Initializiation
    init_sorted_bike_array(bikes1, n1);
    init_sorted_bike_array(bikes2, n2);
    printf("Bikes1: \n");
    for(int i = 0; i < n1; i++){
        print_bike(bikes1 + i);
    }
    printf("Bikes2: \n");
    for(int i = 0; i < n2; i++){
        print_bike(bikes2 + i);
    }
    printf("Bikes initialized. \n");


    printf("merge...\n");


    // Merging
    merge_arrays(bikes1, n1,  bikes2, n2,  bikes_merged);


    /* uncomment for testing merge_array
    // Output
    for(int i = 0; i < n1 + n2; i++){
        print_bike(bikes_merged + i);
    }

    // Testing
    test_equal_b(check_merged_array(bikes_merged, n1 + n2), true);
    */
}


int main(void) {
    merge_arrays_test();
    return 0;
}