//---------------------------------------------------------------------
//
// Name:
//
// Course: CS 1430, Section 2
//
// Purpose: A program that converts between kilometers and miles
// or between Fahrenheit temperature and Celcius.
//
// Input: A character value of 'K' , 'M' , 'F' or 'C'.
// An int or float representing the amount.
//
// Output: A correct conversion between 'K' and 'M' or 'F' and 'C'
// An error message shown for incorrect input of character or
// an error if the temperature or distance is out of range.
//---------------------------------------------------------------------

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;

const float MILES_PER_KM = 1.0f / 1.61f;
const float KM_PER_MILE = 1.61f;
const float FREEZING_F = 32.0f;
const float FAHR_PER_CELSIUS = 9.0f / 5.0f;
const float CELSIUS_PER_FAHR = 5.0f / 9.0f;
const float MAX_F_TEMP = 100.0f;
const float MIN_F_TEMP = 0.0f;

char k = 'K';
char m = 'M';
char f = 'F';
char c = 'C';

float unit;
float amount;

int main()
{
cout << " Input a type (K, M, F, C) : ";
cin >> unit;
cout << " Input an amount : ";
cin >> amount;

if ( unit == 'K' )
{
if ( amount > 0 )
{
cout << " Distance " << amount << " miles is "
<< amount * MILES_PER_KM << " kilometers.";
}
}
return 0;
}

#include <iostream>
#include <exception>

class UnableToProcessException : public std::exception
{


public:
UnableToProcessException(std::string ss) : s(ss) {}
~UnableToProcessException() throw () {}
const char* what() const throw()
{
return (std::string("UNABLE TO PROCESS: ") + s).c_str();
}

private:
std::string s;
};

class Measurement
{

public:
Measurement() {}
Measurement(float _amount, char _type) : amount(_amount), type(_type) {}
~Measurement() throw () {}
float amount;
char type;
};

class UnitConverter
{
public:
Measurement convert(Measurement) throw(UnableToProcessException);
private:
static const float MILES_PER_KM = 1.0f / 1.61f;
static const float KM_PER_MILE = 1.61f;
static const float FREEZING_F = 32.0f;
static const float FAHR_PER_CELSIUS = 9.0f / 5.0f;
static const float CELSIUS_PER_FAHR = 5.0f / 9.0f;
static const float MAX_F_TEMP = 100.0f;
static const float MIN_F_TEMP = 0.0f;

void assertValidData(Measurement) throw(UnableToProcessException);
char getConvertedType(char) throw(UnableToProcessException);


};

void UnitConverter::assertValidData(Measurement measurement) throw(UnableToProcessException)
{

if(measurement.type == 'F' && (measurement.amount < MIN_F_TEMP || measurement.amount > MAX_F_TEMP))
{
throw UnableToProcessException("Temperature too hot or too cold.\nPlease enter a temperature comfortable when wearing a sweater.");
}
else if((measurement.type == 'M' || measurement.type == 'K') && measurement.amount < 0)
{
throw UnableToProcessException("Negative distances are not supported.");
}

}

char UnitConverter::getConvertedType(char type) throw(UnableToProcessException)
{

char converted;

switch(type)
{
case 'K':
converted = 'M';
break;
case 'M':
converted = 'K';
break;
case 'F':
converted = 'C';
break;
case 'C':
converted = 'F';
break;
default:
throw UnableToProcessException(std::string("")+type+" is not a recognized measurement.");
}

return converted;
}

Measurement UnitConverter::convert(Measurement measurement) throw(UnableToProcessException)
{

Measurement convertedMeasurement;

assertValidData(measurement);


switch(measurement.type)
{
case 'K':
convertedMeasurement.amount = measurement.amount * MILES_PER_KM;
break;
case 'M':
convertedMeasurement.amount = measurement.amount * KM_PER_MILE;
break;
case 'F':
convertedMeasurement.amount = (measurement.amount - FREEZING_F) * CELSIUS_PER_FAHR;
break;
case 'C':
convertedMeasurement.amount = (measurement.amount * FAHR_PER_CELSIUS) + FREEZING_F;
break;
default:
throw UnableToProcessException(std::string("")+measurement.type+" is not a recognized measurement.\nPlease enter either K, M, F, or C.");

}

convertedMeasurement.type = getConvertedType(measurement.type);
assertValidData(convertedMeasurement);

return convertedMeasurement;




}


class Driver
{

public:
void run();
private:
std::string getFormatString(char);



};

std::string Driver::getFormatString(char type)
{
std::string s;

//nested if statement to satisfy the "requirement"
if(type == 'K' || type == 'M')
{
s = "Distance";
if(type == 'K')
{
s+= " %g kilometers is %g miles.";
}
else if(type == 'M')
{
s+= " %g miles is %g kilometers.";
}
}
else if(type == 'C' || type == 'F')
{
s = "Temperature";
if(type == 'C')
{
s+= " %g C is %g F.";
}
else if(type == 'F')
{
s+= " %g F is %g C.";
}
}

return s;

}
void Driver::run()
{
char type;
float amount;
const char* format;
std::cout << "Input a type and an amount (K, M, F, C): ";
std::cin >> type >> amount;


Measurement measurement, convertedMeasurement;
UnitConverter uc = UnitConverter();

try
{
measurement = Measurement(amount,type);


convertedMeasurement = uc.convert(measurement);

format = getFormatString(type).c_str();

printf(format,measurement.amount,convertedMeasurement.amount);
}
catch(std::exception& e)
{
std::cout << e.what() << std::endl;
}




}


int main()
{
Driver d;

d.run();

}