// irplugin.cpp : Defines the entry point for the console application.
//
// an example iracing plug applcation displaying drivers nam, number and car
// and real time rpm and gear.
//
// provided as is and has been tested to compile correctly on my machine.
// no warranty or otherwise esponsablilty implied.
//
// some sections of code are from community and iracing staff feedback and are referenced
// throughout where appropriate.
//
// ive added an additional header (irplugin.h) where i stick all my own functions as a habit
// and to neaten up the code to save from twalling lines for debugging issues.
//
// p.s i havne gone through and update the c string to c++ string declarations, but they work ok.
//
// have fun! :-)
//
#define _USE_MATH_DEFINES
#include "stdafx.h"

//bring in some usual headers for various tasks////
#include <windows.h>
#include <stdio.h>
#include <conio.h>
#include <time.h>
#include <string>
#include <signal.h>
// added for filestream
#include <iostream>
#include <fstream>
#include <cmath>
#include <sstream>
#include <iomanip>

//bring in the irsdk headers
#include "irsdk_defines.h"	//irsdk
#include "yaml_parser.h"	//irsdk

// set stanard namespace
using namespace std;

// 16 ms timeout
#define TIMEOUT 16

std::string strAppVers = "App Version 0.4 - Console and HTML file output!\n"; //defines a simple string for output as your app version, and newline.
std::string ledstr = "0img.jpg";
std::string gearstr = "N";
std::string driver;
std::string number;
std::string trackname;
std::string cartype;

char *data = NULL;
int nData = 0;

/////////////////////////////////////////////////////////
#include "irplugin.h"  //imports application specific custom functions
////////////////////////////////////////////////////////


int _tmain(int argc, _TCHAR* argv[])
{

	//inital application startup.

	ofstream dataFile; //create file stream for data.txt

	system("cls"); //clear console
	printf("%s\n\n", strAppVers);
	printf("Press CTRL-C to exit.\n");

	// trap ctrl-c
	signal(SIGINT, ex_program);
		
	// bump priority up so we get time from the sim
	SetPriorityClass(GetCurrentProcess(), HIGH_PRIORITY_CLASS);

	// ask for 1ms timer so sleeps are more precise
	timeBeginPeriod(1);

	printf("Waiting for session to start..\n");

	while(true)
	{
		if(irsdk_waitForDataReady(TIMEOUT, data))
		{
			const irsdk_header *pHeader = irsdk_getHeader();
			if(pHeader)
			{
				// if header changes size, assume a new connection
				if(!data || nData != pHeader->bufLen)
				{
					if(data) 
						delete [] data;
					nData = pHeader->bufLen;
					data = new char[nData];

					///////////////////////////
					system("cls");
					printf("%s\n\n", strAppVers);
					printf("Press CTRL-C to exit.\n");
					printf("connected to sim...\n\n");
					// process header here///////
					// this is where you access and display your session info, like track, driver, etc.
					// these are the 'sessioninfo' and 'weekendinfo' sections.
					//

						
						dataFile.open("idata.csv");
						dataFile.seekp(0);


					//////////////////////////////////////////
					const char *valuestr;
					int valuelen;
					if(parseYaml(irsdk_getSessionInfoStr(), "WeekendInfo:TrackName:" , &valuestr, &valuelen)){
						printf("Track: %.*s\n",valuelen,valuestr);
						trackname = valuestr;
						

						}else{
							printf("not found\n");
					}
					// note: printf: .* = The precision is not specified in the format string, 
					// but as an additional integer value argument preceding the argument that has to be formatted.
					// this code Thanks to Peter holt.
					//////////////////////////////////////////

					//////////////////////////////GET LOADED CAR AND DRIVER///////////////////////////////////
					////thx to Dave Tucker for this section
					const char *valstr;
					int valstrlen; 
					char str[512];
					//
					int carIdx = -1;
					char nameStr[512];
					char pathStr[512];
					char numbStr[512];
					//
					// get the playerCarIdx
					if(parseYaml(irsdk_getSessionInfoStr(), "DriverInfo:DriverCarIdx:", &valstr, &valstrlen))
						carIdx = atoi(valstr);
					////
					if(carIdx >= 0)
					{
						//////////////////////////////////
						// get drivers name
						sprintf_s(str, 512, "DriverInfo:Drivers:CarIdx:{%d}UserName:", carIdx);
						if(parseYaml(irsdk_getSessionInfoStr(), str, &valstr, &valstrlen))
						{
							strncpy_s(nameStr, 512, valstr, valstrlen);
							nameStr[valstrlen] = '\0'; //driversname
						}//
						//////////////////////////////////
						// get drivers car path
						sprintf_s(str, 512, "DriverInfo:Drivers:CarIdx:{%d}CarPath:", carIdx);
						if(parseYaml(irsdk_getSessionInfoStr(), str, &valstr, &valstrlen))
						{
							strncpy_s(pathStr, 512, valstr, valstrlen);
							pathStr[valstrlen] = '\0'; //drivers car
						}//
						//////////////////////////////////
						// get drivers car number
						sprintf_s(str, 512, "DriverInfo:Drivers:CarIdx:{%d}CarNumber:", carIdx);
						if(parseYaml(irsdk_getSessionInfoStr(), str, &valstr, &valstrlen))
						{
							strncpy_s(numbStr, 512, valstr, valstrlen);
							numbStr[valstrlen] = '\0'; //drivers number
						}//
						//////////////////////////////////
					}////
					//////////////////////////////GET LOADED CAR AND DRIVER///////////////////////////////////

					printf ( "Driver: %s %s %s \n\n", numbStr ,nameStr, pathStr );
						number = numbStr;
						driver = nameStr;
						cartype = pathStr;
					//////////////////////////////GET LOADED CAR AND DRIVER///////////////////////////////////
					//where 
					// numbstr = drivers car number 
					// namestr = drivers text full name
					// namestr = car/chassis in use by driver.

					//
					//
					/////////////////////////////end process headers here
				}
				else if(data)
				{
										// process data here///////////
					// this is where you access and work with the telemitry vars, in 1/60th itterations.
					// see 'irsdk 1_0 data vars.csv' for specific ones your after.
					//
					////////////////////////////////////
					// fetch current gear value
					const char g_gearoffset[] = "Gear";
					int gearoffset = irsdk_varNameToOffset(g_gearoffset);				
					int CurrentGear = * ((int *)(data + gearoffset));
					if (CurrentGear == 0)
					{
						gearstr = "N"; 
					}
					else if (CurrentGear == -1)
					{
						gearstr = "R";
					}
					else
					{
						std::stringstream out;
						out << CurrentGear;
						gearstr = out.str();
					}
					/////////////////////////////////////
					//
					////////////////////////////////////
					// fetch current RPM value
					const char g_RPMoffset[] = "RPM";
					int RPMoffset = irsdk_varNameToOffset(g_RPMoffset);				
					float engRPM = * ((float *)(data + RPMoffset));
					/////////////////////////////////////
					//
					/////////////////////////////////////
					// fetch current Speed value
					const char g_speedoffset[] = "Speed";
					int speedoffset = irsdk_varNameToOffset(g_speedoffset);				
					float speed = * ((float *)(data + speedoffset));
					float kph = speed * 3.6; //convert m/s to km/h
					float mph = kph * 5 / 8; //convert km/h to mi/h
					/////////////////////////////////////
					//
					/////////////////////////////////////
					// fetch current fuellevel value
					const char g_fuelloffset[] = "FuelLevel";
					int fuelloffset = irsdk_varNameToOffset(g_fuelloffset);				
					float fuell = * ((float *)(data + fuelloffset));
					double gal = fuell * 0.264;// convert lts to gal
					/////////////////////////////////////
					//
					/////////////////////////////////////
					// fetch current Throttle value
					const char g_throttleoffset[] = "Throttle";
					int throttleoffset = irsdk_varNameToOffset(g_throttleoffset);				
					float throttle = * ((float *)(data + throttleoffset));
					int throttlep = throttle * 100;
					/////////////////////////////////////
					//
					/////////////////////////////////////
					// fetch current Brake value
					const char g_brakeoffset[] = "Brake";
					int brakeoffset = irsdk_varNameToOffset(g_brakeoffset);				
					float brake = * ((float *)(data + brakeoffset));
					int brakep = brake * 100;
					/////////////////////////////////////
					//
					/////////////////////////////////////
					// fetch current Clutch value
					const char g_clutchoffset[] = "Clutch";
					int clutchoffset = irsdk_varNameToOffset(g_clutchoffset);				
					float clutch = * ((float *)(data + clutchoffset));
					int clutchp = clutch * 100;
					/////////////////////////////////////
					//
					////////////////////////////////////
					// fetch current ShiftIndicatorPct value (0.0-1.0)
					const char g_ShiftPCToffset[] = "ShiftIndicatorPct"; 
					int ShiftPCToffset = irsdk_varNameToOffset(g_ShiftPCToffset);				
					float ShiftPCT = * ((float *)(data + ShiftPCToffset));
					int Shiftp = ShiftPCT * 100;
						////// Rev LEDs to string...ledstr..
						if (Shiftp > 80)
						{
							ledstr = "80img.jpg";
						} 
						else if (Shiftp > 60)
						{
							ledstr = "60img.jpg";
						}
						else if (Shiftp > 40)
						{
							ledstr ="40img.jpg";
						}
						else if (Shiftp > 20)
						{
							ledstr = "20img.jpg";
						}
						else // Shiftp < 20..no leds on..
						{
							ledstr= "0img.jpg";
						}
					/////////////////////////////////////
					//
					////////////////////////////////////
					// get Steering Wheel Angle
					const char g_swaoffset[] = "SteeringWheelAngle"; 
					int swaoffset = irsdk_varNameToOffset(g_swaoffset);				
					float swr = * ((float *)(data + swaoffset)); // in radians
					float swa = swr * 180 / M_PI;
					/////////////////////////////////////
					//
					////////////////////////////////////
					// get lap count
					const char g_lapsoffset[] = "Lap"; 
					int lapsoffset = irsdk_varNameToOffset(g_lapsoffset);				
					int laps = * ((float *)(data + lapsoffset));
					/////////////////////////////////////
					//
					////////////////////////////////////
					// fetch current lap distance % 
					const char g_lapdistPCToffset[] = "LapDistPct"; 
					int lapdistPCToffset = irsdk_varNameToOffset(g_lapdistPCToffset);				
					float lapdistPCT = * ((float *)(data + lapdistPCToffset));
					int lapdistp = lapdistPCT * 100;
					/////////////////////////////////////
					//
					////////////////////////////////////
					// fetch current Engine Voltage
					const char g_voltsoffset[] = "Voltage"; 
					int voltsoffset = irsdk_varNameToOffset(g_voltsoffset);				
					float volts = * ((float *)(data + voltsoffset));
					/////////////////////////////////////
					//
					////////////////////////////////////
					// get water level and temp
					const char g_wleveloffset[] = "WaterLevel"; 
					const char g_wtempoffset[] = "WaterTemp";
					int wleveloffset = irsdk_varNameToOffset(g_wleveloffset);
					int wtempoffset = irsdk_varNameToOffset(g_wtempoffset);
					float wlevel = * ((float *)(data + wleveloffset));
					float wtemp = * ((float *)(data + wtempoffset));
					/////////////////////////////////////
					//
					////////////////////////////////////
					// get oil level temp and pressure
					const char g_oilloffset[] = "OilLevel"; 
					const char g_oiltoffset[] = "OilTemp";
					const char g_oilpoffset[] = "OilPress";
					int oilloffset = irsdk_varNameToOffset(g_oilloffset);
					int oiltoffset = irsdk_varNameToOffset(g_oiltoffset);
					int oilpoffset = irsdk_varNameToOffset(g_oilpoffset);
					float oill = * ((float *)(data + oilloffset));
					float oilt = * ((float *)(data + oiltoffset));
					float oilp = * ((float *)(data + oilpoffset));
					/////////////////////////////////////
					//

					////////////////////////////////////
					// is car on track..
					const char g_ontrackoffset[] = "IsOnTrack"; 
					int ontrackoffset = irsdk_varNameToOffset(g_ontrackoffset);				
					bool ontrack = * ((float *)(data + ontrackoffset));
					/////////////////////////////////////

					//
					if (ontrack)
					{
					printf("RPM:%d Gear:%d Speed:%dkph/%dmph Fuel:%dlts/%dgal Throttle:%d Shift:%d    \r", int (engRPM), CurrentGear, int(kph), int(mph), int(fuell), int(gal), throttlep, Shiftp); //current rpm and gear
					
					dataFile	<< number << "," 
								<< driver << ","
								<< cartype << "," 
								<< int (engRPM) << "," 
								<< CurrentGear << "," 
								<< int(kph) << "," 
								<< int(mph) << "," 
								<< int(fuell) << "," 
								<< int(gal) << "," 
								<< throttlep << "," 
								<< Shiftp << "," 
								<< brakep << "," 
								<< clutchp << "," 
								<< swa << ","
								<< laps << ","
								<< lapdistp << ","
								<< volts << ","
								<< wlevel << ","
								<< wtemp << ","
								<< oilp << ","
								<< oilt << ","
								<< oill << ","
								<< "eof" << endl;
					dataFile.seekp(0);
					//dataFile.close();

					}
					//
					//
					//printf("RPM Current: %d Gear: %d \r", int (engRPM), CurrentGear); //current rpm and gear
					//

					//
					//
					/////////////////////////////// end pocess data here
				}
			}//no data being recieved.
		}
		//optional test, in case you need to close out a file...
		else if(!irsdk_isConnected())
		{
			// session ended
			if(data)
				delete[] data;
			data = NULL;
			dataFile.close();			
		}
	}

	// call on exit to close memory mapped file
	irsdk_shutdown();

	return 0;
}