#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
using namespace std;
#include "pos.h"

const string dir_name[4] = { "NORTH", "EAST", "SOUTH", "WEST" };

int POS::get_x() const
{
	return x;
}

int POS::get_y() const
{
	return y;
}

DIR POS::get_dir() const
{
	return dir;
}

bool POS::set_xy(int new_x, int new_y)
{
	if (new_x < 0 || new_y < 0)
	{
		cout << "Attempt to move to illegal position at line " << linenum << endl;
		return true;		//	Does not stop the program
	}
	x = new_x;
	y = new_y;
	return true;
}

//	Parse an integer from the stream
int POS::parse_int(stringstream& ss)
{
	string	temp;
	getline(ss, temp, COMMA);
	return stoi(temp);
}

//	Move x and y by some increment
//	Moves to negative positions are ignored
bool POS::move_xy(int incr_x, int incr_y)
{
	return set_xy(x + incr_x, y + incr_y);	
}

//	Parse a direction from the stream
bool POS::parse_direction(stringstream& ss, DIR & dir)
{
	string	temp;

	getline(ss, temp);
	rtrim(temp);
	for (int i = 0; i < 4; i++)
		if (temp == dir_name[i])
		{
			dir = (DIR)i; 
			return true;
		}
	cout << "Invalid direction: " << temp << endl;
	return false;	
}
//	LOCATE x , y , dir
bool POS::parse_locate(stringstream& ss)
{
	int temp_x, temp_y;
	temp_x = parse_int(ss);
	temp_y = parse_int(ss);
	set_xy(temp_x, temp_y);
	return parse_direction(ss, dir);	
}

//	Format a POS to the output stream
std::ostream& operator << (std::ostream& os, const POS& pos)
{
	os << pos.x << "," << pos.y << "," << dir_name[(int)pos.dir];
	return os;
}

#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
using namespace std;
#include "pos.h"

//	Globals
POS		curr_pos;
int		linenum = 0;

//	Remove a single trailing space from string
void rtrim(string& str)
{
	if (str[str.size() - 1] == ' ')
		str.erase(str.size() - 1);	//  Erase trailing sopace
}

void upshift(string& str)
{
	for (size_t i = 0; i < str.size(); i++)
		if (islower(str[i]))
			str[i] = toupper(str[i]);
}
//	Move in some direction
bool do_move(DIR dir)
{	
	const int delta_x[4] = { 0, 1, 0, -1 };
	const int delta_y[4] = { 1, 0, -1, 0 };

	return curr_pos.move_xy(delta_x[(int)dir], delta_y[(int)dir]); 
}

//	Report current position
bool do_report()
{
	cout << curr_pos << endl;
	return true;
}

//	Echo the OUTPUT command
bool do_output(const string & line)
{
	cout << line << endl;
	return true;
}

bool parse_line(const string& line)
{
	string cmd;
	stringstream	ss(line);

	ss >> cmd;
	if (cmd == "LOCATE")
		return curr_pos.parse_locate(ss);
	if (cmd == "MOVE")
		return do_move(curr_pos.get_dir());	
	if (cmd == "REPORT")
		return do_report();
	if (cmd == "OUTPUT:")
		return do_output(line);
	if (cmd == "RIGHT")
		return do_move (DIR::EAST);
	if (cmd == "LEFT")
		return do_move(DIR::WEST);
	if (cmd == "UP")
		return do_move(DIR::NORTH);
	if (cmd == "DOWN")
		return do_move(DIR::NORTH);
	cout << "Command not recognized: " << cmd << endl;
	return false;
}

bool parse_file(const string& fname)
{
	ifstream	ifs(fname);
	string		line;

	if (!ifs.is_open())
	{
		cout << "Unable to open file: " << fname << endl;
		return false;
	}
	while (getline(ifs, line))
	{
		linenum++;
		cout << linenum << ".  " << line << endl;
		upshift(line);
		if (!parse_line(line))
		{
			cout << "Could not parse line: " << line << endl;
			return false;
		}
	}
	return true;
}

int main()
{
	if (!parse_file("test.txt"))
		return 1;
	return 0;
}

#include <iostream>
#include <fstream>
#include <string>
#include <string_view>
#include <array>
#include <utility>
#include <algorithm>
#include <vector>
#include <cctype>
#include <limits>

enum Dir {
	NORTH, SOUTH, EAST, WEST
};

enum Instruct {
	MOVE, REPORT, LEFT, RIGHT, UP, DOWN
};

struct Pos {
	std::pair<int, int> pos {};
	Dir dir {};
};

struct Case {
	Pos locPos, outPos;
	std::vector<Instruct> instructs;
};

std::string& toUpper(std::string& s) {
	for (auto& c : s)
		c = static_cast<char>(std::toupper(static_cast<unsigned char>(c)));

	return s;
}

constexpr std::array<std::string_view, 4> dir { "NORTH", "SOUTH", "EAST", "WEST" };
constexpr std::array<std::string_view, 6> instruct { "MOVE", "REPORT", "LEFT", "RIGHT", "UP", "DOWN" };

std::istream& operator>>(std::istream& is, Pos& pos) {
	std::string d;

	if (char del {}; is >> pos.pos.first >> del >> pos.pos.second >> del >> d) {
		if (const auto p { std::ranges::find(dir, toUpper(d)) }; p != dir.end())
			pos.dir = Dir(p - dir.begin());
		else {
			std::cout << "Incorrect direction\n";
			is.setstate(std::ios_base::badbit);
		}

		is.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
	}

	return is;
}

std::ostream& operator<<(std::ostream& os, const Pos& pos) {
	return os << pos.pos.first << ',' << pos.pos.second << ',' << dir[pos.dir];
}

std::istream& operator>>(std::istream& is, Case& cse) {
	std::string str;
	cse.instructs.clear();

	if (is >> str; is && (str == "LOCATE"))
		if (is >> cse.locPos) {
			do {
				if (is >> str; is && (toUpper(str) != "OUTPUT:")) {
					is.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
					if (const auto i { std::ranges::find(instruct, str) }; i != instruct.end())
						cse.instructs.push_back(Instruct(i - instruct.begin()));
					else {
						std::cout << "Invalid instruction\n";
						is.setstate(std::ios_base::badbit);
					}
				}
			} while (is && (str != "OUTPUT:"));

			is >> cse.outPos;
		}
	else if (is) {
		std::cout << "LOCATE expected\n";
		is.setstate(std::ios_base::badbit);
	}

	return is;
}

std::ostream& operator<<(std::ostream& os, const Case& cse) {
	os << "LOCATE " << cse.locPos << '\n';

	for (const auto& i : cse.instructs)
		os << instruct[i] << '\n';

	return os << "Output: " << cse.outPos;
}

int main() {
	std::ifstream ifs("test.txt");

	if (!ifs)
		return (std::cout << "Can not open input file\n"), 1;

	std::vector<Case> cases;

	for (Case c; ifs >> c; cases.push_back(c));

	for (const auto& c : cases)
		std::cout << c << '\n';
}