// ******************************* VERY IMPORTANT *************************************************
// THE FOLLOWING DECLARATIONS SHOULD NOT BE DELETED OR CHANGED
// REMOVING OR CHANGING ANY OF THEM WILL STOP YOUR PROGRAM FROM
// COMPILING SUCCESSFULLY WITH THE TEST HARNESS
// PLEASE USE THEM FOR THE PURPOSE FOR WHICH THEY WERE CREATED
//*************************************************************************************************

#include "air.h"
#include <stdio.h>

// This is the BookingsTable two dimensional array,
// it is used to record information about all flight bookings,
// the table has MaxCapacity rows because this is the maximum number of passengers who can have
// valid bookings on this aircraft at any one time,
// the table has four columns used as follows:
// column 0 stores the flight booking number,
// column 1 stores the travel class (1-4),
// column 2 stores the number of passengers travelling together in this flight booking (1-9),
// column 3 is a flag that indicates if seats have been reserved for this booking:
// 0=seats not reserved, 1=seats reserved
int BookingsTable[MaxCapacity][4];
int NumberBookings;	// the actual number of flight bookings made on this flight


// This is the SeatMap two dimensional array,
// it represents the seats of the aircraft,
// it has NumberSeatRows (26) rows because there are 26 seat rows in the aircraft,
// it has 7 columns:
// column 0 contains the actual seat row number because there are missing row numbers
// columns 1,2,3,4,5, and 6 store the booking numbers of the passengers
// who reserved the seats of this row,
// if a seat is free the cell contains -1
// initially all seats are free hence all cells in columns 1-6 should be initialised to -1
int SeatMap[NumberSeatRows][7];

int BookingNumberCounter; // a counter for creating unique booking numbers
int NumberFirst;		// a counter for the number of passengers who booked first class
int NumberPremium;		// a counter for the number of passengers who booked premium class
int NumberEconomy;		// a counter for the number of passengers who booked economy class
int NumberBudget;		// a counter for the number of passengers who booked budget class

// YOU MAY ADD ANY ADDITIONAL GLOBAL VARIABLES THAT YOU THINK ARE NEEDED BELOW THIS LINE
//--------------------------------------------------------------------------------------




// ******************************* VERY IMPORTANT *************************************************
// THE FOLLOWING FUNCTION SKELETONS SHOULD NOT BE DELETED OR THEIR SIGNATURES CHANGED
// REMOVING ANY OF THEM OR CHANGING THEIR RETURN TYPE OR PARAMETER LIST WILL STOP YOUR PROGRAM FROM
// COMPILING SUCCESSFULLY WITH THE TEST HARNESS
//*************************************************************************************************

// This function initialises all counters and variables to their correct initial values
// it should be called once at the beginning of the main function
void InitialiseBookings ()
{

	BookingNumberCounter = MinBookingReferenceNumber;
	NumberBookings = 0;	// initially there are no bookings
	NumberFirst=0;		// obviously there are 0 passengers in this travel class
	NumberPremium=0;	// ditto
	NumberEconomy = 0;	// ditto
	NumberBudget = 0;	// ditto
	// YOU MAY ADD ANY OTHER INITIALISATIONS THAT YOU THINK ARE NECESSARY BELOW THIS LINE
} // END OF THE InitialiseAll FUNCTION

// This function returns a new booking number every time it is called,
// the first time this function is called it returns 1, the second time it returns 2, etc
// the maximum booking number that can be returned is 999,
// if all booking numbers from 1 to 999 have been used the function returns -1
// as indication of inability to create more booking numbers
//
int newBookingNumber ()
{
	BookingNumberCounter++;
	return BookingNumberCounter < 1001 ? BookingNumberCounter - 1 : -1;
}  // END OF THE newBookingNumber FUNCTION

// This function returns 1 (true) if there is enough capacity in a travel_class to seat n more passengers,
// where n is the number of passengers who need to book a flight in this travel class
// otherwise if this travel class is full it returns 0 (false),
// if the travel class is not a valid value (i.e. not a value between 1-4) the function returns -1
int hasCapacity (int travel_class, int n)
{
	switch(travel_class)
	{
		case 1 :
			if ((n + NumberFirst) > MaxSeatsFirst)   //Check if there are enough seats in first class
				return 0;							 //when the number of passengers are added
			else
				return 1;
			break;
		case 2 :
			if ((n + NumberPremium) > MaxSeatsPremium) //Check if there are enough seats in premium
				return 0;							   //when the number of passengers are added
			else
				return 1;
			break;
		case 3:
		case 4:
			if ((n + NumberEconomy + NumberBudget) > MaxSeatsEconomy) //Check if there are enough seats in budget/economy
				return 0;											  //when the number of passengers are added
			else
				return 1;
			break;
		default :
			return -1;
	}
} // END OF THE hasCapacity FUNCTION

// This function adds a new booking to the BookingsTable,
// and update all relevant passenger counters,
// when a booking is added no specific seats are reserved for this booking
// the function returns -1 if something goes wrong (e.g. travel_class is an invalid number)
// if successful, the function returns 1
int addBooking(int booking_number, int travel_class, int number_passengers)
{
	//Validation to check booking number, travel class, and number of passengers are all valid
	if (booking_number < 1 || booking_number > 999 || travel_class < 1 || travel_class > 4 || number_passengers < 1 || number_passengers > 9)
		return -1;
	BookingsTable[NumberBookings][0] = booking_number;   //Adds booking number to table
	BookingsTable[NumberBookings][1] = travel_class;	 //Adds travel class to table
	BookingsTable[NumberBookings][2] = number_passengers;//Adds number of passengers to table
	BookingsTable[NumberBookings][3] = 0;				 //Assigns 0 to seats reserved flag as a default
	NumberBookings++;									 //Increments number of bookings
	if (travel_class == 1)
		NumberFirst += number_passengers;
	if (travel_class == 2) 								 //Updates all relevant
		NumberPremium += number_passengers;				 //passenger counters
	if (travel_class == 3)
		NumberEconomy += number_passengers;
	if (travel_class == 4)
		NumberBudget += number_passengers;
	return 1;

} // END OF THE hasCapacity FUNCTION

// This function searches for a booking in the BookingsTable
// using the booking number as a search key
// and returns the zero-based row index of this booking in the BookingsTable
// if the booking cannot be found the function returns -1
int findBooking (int booking_number)
{
	int i;
	for (i = 0; i < sizeof(BookingsTable[0]); i++)
		if (BookingsTable[i][0] == booking_number)		//Linear search
			break;										//of bookings table
	if (i <  sizeof(BookingsTable[0]))					//to find this booking
		return i;										//returns 0-based index of booking
	else
		return -1;										//returns -1 if booking is not in table
} // END OF THE findBooking FUNCTION


// This function returns the number of passengers
// who are travelling under one booking using information from the BookingsTable
// or -1 if this booking cannot be found
int numberPassengers (int booking_number)
{
	int i;
	for (i = 0; i < sizeof(BookingsTable[0]); i++)
		if (BookingsTable[i][0] == booking_number)	   //Linear search
			break;								       //of bookings table
	if (i <  sizeof(BookingsTable[0]))				   //to find this booking
		return BookingsTable[i][2];					   //returns number of passenegers
	else
		return -1;									   //returns -1 if booking is not in table
} // END OF THE numberPassengers FUNCTION

// This function returns 1 if seats have been reserved for this booking
// and returns 0 if no seats are reserved for this booking
// -1 if this booking cannot be found
int seatsAreReserved (int booking_number)
{
	int i;
	for (i = 0; i < sizeof(BookingsTable[0]); i++)
		if (BookingsTable[i][0] == booking_number)	   //Linear search
			break;								       //of bookings table
	if (i <  sizeof(BookingsTable[0]))				   //to find this booking
		return BookingsTable[i][3];					   //returns seat reserved flag
	else
		return -1;									   //returns -1 if booking is not in table
} // END OF THE seatsAreReserved FUNCTION


// This function returns the travel class of a booking
// and -1 if this booking cannot be found
int travelClass (int booking_number)
{
	int i;
	for (i = 0; i < sizeof(BookingsTable[0]); i++)	   //Linear search
			break;								       //of bookings table
	if (i <  sizeof(BookingsTable[0]))				   //to find this booking
		return BookingsTable[i][1];					   //returns travel class
	else
		return -1;									   //returns -1 if booking is not in table
} // END OF THE travelClass FUNCTION


// always returns 1
int showBookingsTable()
{
	printf("Booking Number   Travel Class   Number of Passengers   Seats? \n");		//Headings for table
	for (int a = 0; a < sizeof(BookingsTable[0]); a++)
		if (BookingsTable[a][0] != 0)		//Will not print any rows where booking number is 0
			//Prints all rows of BookingsTable
			printf("       %i	        %i	         %i	         %i \n" ,BookingsTable[a][0],BookingsTable[a][1],BookingsTable[a][2],BookingsTable[a][3]);

	return 1;
} // END OF THE showBookingsTable FUNCTION


// This function returns 1 if row_number is missing from the seat plan (e.g. row number 13)
// otherwise it returns 0
int rowIsMissing (int row_number)
{
	if (row_number >= 4 && row_number <= 6 || row_number == 9 ||row_number >= 13 && row_number <= 19 || row_number == 33)   //Checks if row number is in the seat plan
		return 1;
	return 0;
} // END OF THE rowIsMissing FUNCTION


// This function returns 1 if the seat number specified by the parameters 'row' and 'letter' is a valid seat
// on the aircraft for the given travel_class,
// if the seat number is not valid the function returns 0,
// this function does not check whether the seat is taken (reserved for someone) or not,
// The function returns -1 if travel_class invalid (not between 1-4)
// since budget class passengers cannot reserve a seat, the function returns 0 if the travel class is budget (4)
int isValidSeat (int travel_class, int row, char letter)
{
	switch(travel_class)
	{
		case 1:
			if (row == 1 || row == 3 || row == 2)		//Checks if row is valid for first class
				if (letter == 'A' || letter == 'B' || letter == 'E' || letter == 'F')	//Checks if letter is valid for first class
					return 1;
			return 0;
		case 2:
			if (row >= 7 && row <= 21 && row != 9)
				if (row > 12 && row < 20) 				//Checks if row is valid for premium
					return 0;
				if (letter >= 'A' && letter <= 'F')		//Checks if letter is valid for premium
					return 1;
		case 3:
			if (row >= 22 && row <= 38 && row != 33 )	//Checks if row is valid for economy
				if (letter >= 'A' && letter <= 'F')		//Checks if letter is valid for economy
					return 1;
				return 0;
			break;
		case 4:											//Returns 0 as budget class cannot reserve seats
			return 0;
		default:
			return -1;
	}
} // END OF THE isValidSeat FUNCTION

// This function returns an integer between 1-6 corresponding to the letters A-F
// it is useful for indexing the columns 1-6 of the SeatMap table
int letterToColumnIndex (char letter)
{
	return letter - 64;		//returns ASCII value of letter minus 64 to get values between 1 and 6
} // END OF THE letterToColumnIndex FUNCTION


// This function initialises the SeatMap by initialising column 0 to the actual seat row number
// and assigning -1 to all 'seats'
// always returns 1
int InitialiseSeatMap ()
{
	int n, a;
	for (a = 0; a < 26; a++)
		for (n = 1; n < 7; n++)
			SeatMap[a][n] = -1;			//Initialises every seat to -1
	for (a = 0; a < 3; a++)
		SeatMap[a][0] = a+1;
	SeatMap[3][0]=7;
	SeatMap[4][0]=8;
	for (a = 5; a < 8; a++)
		SeatMap[a][0] = a+5;			//Assigns column 0 for every row to the correct
	for (a = 8; a < 21; a++)			//seat row numbers
		SeatMap[a][0] = a+12;
	for (a = 21; a < 26; a++)
		SeatMap[a][0] = a+13;
	return 1;
}  // END OF THE InitialiseSeatMap FUNCTION

// This function returns the row index in the SeatMap array for a given aircraft seat row
// returns -1 if this is row does not exist in the aircraft seat map
// for example if row= 11 the function returns 6
int rowIndex (int row)
{
	if (row >= 1 && row <= 3)
		return row - 1;
	if (row == 7 || row == 8)
		return row  - 4;
	if (row >= 10 && row <= 12)			//Returns the correct row
		return row - 5;					//index for the row inputted
	if (row >= 20 && row <= 32)			//into the function
		return row - 12;
	if (row >= 34 && row <= 38)
		return row - 13;
	return -1;
} // END OF THE rowIndex FUNCTION

// returns 1 if the seat specified by row and letter is reserved (for anyone)
// and 0 if the seat is not reserved
// the function returns -1 if the seat specified by row,letter is not valid
int seatIsReserved (int travel_class , int row , char letter)
{
	if (isValidSeat == 0)
		return -1;													//Validation for validity of seat
	if (SeatMap[rowIndex(row)][letterToColumnIndex(letter)] == -1)  //Checks if seat is -1 in the
		return 0;													//SeatMap, and therefore reserved
	return 1;
} // END OF THE seatIsReserved FUNCTION

// This function reserves the seat specified by row and letter to a booking_number
// The function returns -1 if the seat specification is not valid or if the booking does not exist
// otherwise it returns 1
int reserveSeat (int booking_number, int travel_class , int row, char letter)
{
	if (findBooking(booking_number) == -1 || isValidSeat == 0 || isValidSeat == -1) //Validation to check booking number and seat are valid
		return -1;
	BookingsTable[findBooking(booking_number)][3] = 1;						//Sets the seat reserved flag in bookings table to 1
	SeatMap[rowIndex(row)][letterToColumnIndex(letter)] = booking_number;   //Sets the seat in seat map
	return 1;																//to the booking number inputted
} // END OF THE reserveSeat FUNCTION

// Function to return the symbol
// that the seat should be displayed by
// in the seat map
// for first class seats
int FindSymbolFirst(int seat, int booking_number)
{
	if (seat == -1)
		return 'O';
	if (seatsAreReserved(booking_number) == 1)
		return '#';
	return '*';
} // END OF THE FindSymbolFirst FUNCTION

// Function to return the symbol
// that the seat should be displayed by
// in the seat map
// for premium seats
int FindSymbolPremium(int seat, int booking_number)
{
	if (seat == -1)
		return 'o';
	if (seatsAreReserved(booking_number) == 1)
		return '#';
	return '*';
} // END OF THE FindSymbolPremium FUNCTION

// Function to return the symbol
// that the seat should be displayed by
// in the seat map
// for economy seats
int FindSymbolEconomy(int seat, int booking_number)
{
	if (seat == -1)
		return '.';
	if (seatsAreReserved(booking_number) == 1)
		return '#';
	return '*';
} // END OF THE FindSymbolEconomy FUNCTION

// This function displays the SeatMap of the aircraft
// vacant first class seats are displayed as capital O
// vacant premium class seats are shown as small o
// vacant economy seats are shown as .
// seats reserved to the given booking_number are shown as #
// seats reserved for all other bookings are shown as *
int ShowSeatMap (int booking_number)
{
	int a,n, Tclass;
	Tclass = travelClass(booking_number);
	printf("--- FRONT OF AIRCRAFT --- \n");
	printf("First Class Cabin \n");
	printf("	A   B  	   E   F  \n");
	for (a = 0; a < 3; a++)
	{
		printf("%i	" ,SeatMap[a][0]);
		printf("%c   %c      %c   %c   \n" ,FindSymbolFirst(SeatMap[a][1], booking_number), FindSymbolFirst(SeatMap[a][2], booking_number), FindSymbolFirst(SeatMap[a][5], booking_number), FindSymbolFirst(SeatMap[a][6], booking_number));
	}
	printf("--------------    ------\n");
	printf("Main Cabin \n");
	printf("	A  B  C	 D  E  F  \n");
	for (a = 3; a < 10; a++)
	{
		printf("%i	",SeatMap[a][0]);
		printf("%c  %c  %c	 %c  %c  %c \n" ,FindSymbolPremium(SeatMap[a][1], booking_number),FindSymbolPremium(SeatMap[a][2], booking_number),FindSymbolPremium(SeatMap[a][3], booking_number),FindSymbolPremium(SeatMap[a][4], booking_number),FindSymbolPremium(SeatMap[a][5], booking_number),FindSymbolPremium(SeatMap[a][6], booking_number));
	}
	for (a = 10; a < 26; a++)
	{
		printf("%i	",SeatMap[a][0]);
		printf("%c  %c  %c	 %c  %c  %c \n" ,FindSymbolEconomy(SeatMap[a][1], booking_number),FindSymbolEconomy(SeatMap[a][2], booking_number),FindSymbolEconomy(SeatMap[a][3], booking_number),FindSymbolEconomy(SeatMap[a][4], booking_number),FindSymbolEconomy(SeatMap[a][5], booking_number),FindSymbolEconomy(SeatMap[a][6], booking_number));
	}
	printf("\n--- REAR OF AIRCRAFT ---");
} // END OF ShowSeatMap FUNCTION

// This function cancels all seats reserved for a booking
// The function returns -1 if the booking does not exist
// otherwise it returns 1
int cancelSeatReservation (int booking_number)
{
	if (findBooking(booking_number) == -1)
		return -1;
	BookingsTable[findBooking(booking_number)][3] = 0;
	for (int a = 0; a < 26; a++)
		for (int i = 1; i < 7; i++)
			if (SeatMap[a][i] == booking_number)
				SeatMap[a][i] = -1;
	return 1;
} // END OF cancelSeatReservation FUNCTION

// This function cancels a booking and all seats reserved for this booking
// The function returns -1 if the booking does not exist
// otherwise it returns 1
int cancelBooking (int booking_number)
{
	if (findBooking(booking_number) == -1)
		return -1;
	BookingsTable[findBooking(booking_number)][3] = 0;
	cancelSeatReservation(booking_number);
	switch(travelClass(booking_number))
	{
		case 1:
			NumberFirst -= numberPassengers(booking_number);
			break;
		case 2:
			NumberPremium -= numberPassengers(booking_number);
			break;
		case 3:
			NumberEconomy -= numberPassengers(booking_number);
			break;
		case 4:
			NumberBudget -= numberPassengers(booking_number);
			break;

	}
	for (int i = findBooking(booking_number); i < 12; i++)
	{
		BookingsTable[i][0] = BookingsTable[i+1][0];
		BookingsTable[i][1] = BookingsTable[i+1][1];
		BookingsTable[i][2] = BookingsTable[i+1][2];
		BookingsTable[i][3] = BookingsTable[i+1][3];
	}
	NumberBookings--;
	return 1;
} // END OF cancelBooking FUNCTION