#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <vector>
using namespace std;

struct RGB
{
	unsigned char Red = 0;
	unsigned char Green = 0;
	unsigned char Blue = 0;
};

int width_to_int(vector <char> &Width)
{
	switch (Width.size()) //перевод из char в int
	{
	case 2:
		return (Width[0] - '0') * 10 + (Width[1] - '0');
	case 3:
		return (Width[0] - '0') * 100 + (Width[1] - '0') * 10 + (Width[2] - '0');
	case 4:
		return (Width[0] - '0') * 1000 + (Width[1] - '0') * 100 + (Width[2] - '0') * 10 + (Width[3] - '0');
	}
}

int height_to_int(vector <char> &Height)
{
	switch (Height.size()) //перевод из char в int
	{
	case 2:
		return (Height[0] - '0') * 10 + (Height[1] - '0');
	case 3:
		return (Height[0] - '0') * 100 + (Height[1] - '0') * 10 + (Height[2] - '0');
	case 4:
		return (Height[0] - '0') * 1000 + (Height[1] - '0') * 100 + (Height[2] - '0') * 10 + (Height[3] - '0');
	}
}
//=========================================================================================================
//Реализация самих функций
void inversion(vector <vector<unsigned char>>& Pixels) //для P5
{
	for (int i = 0; i < Pixels.size(); ++i)
		for (int j = 0; j < Pixels[i].size(); ++j)
		{
			int buff = 0;
			buff = (int)Pixels[i][j];
			Pixels[i][j] = 255 - buff;
		}
}
void inversion(vector <vector <struct RGB>>& Pixels) //для P6
{
	for (int i = 0; i < Pixels.size(); ++i)
		for (int j = 0; j < Pixels[i].size(); ++j)
		{
			int buff = 0;
			buff = (int)Pixels[i][j].Red;
			Pixels[i][j].Red = 255 - buff;

			buff = (int)Pixels[i][j].Green;
			Pixels[i][j].Green = 255 - buff;

			buff = (int)Pixels[i][j].Blue;
			Pixels[i][j].Blue = 255 - buff;
		}
}

void horizontal_reflextion(vector <vector<unsigned char>>& Pixels) //для P5
{
	for (int i = 0; i < Pixels.size(); ++i)
		for (int j = 0; j < Pixels[i].size() / 2; ++j)
			swap(Pixels[i][j], Pixels[i][Pixels[i].size() - j]);
}

void horizontal_reflextion(vector <vector<struct RGB>>& Pixels) //для P6
{
	for (int i = 0; i < Pixels.size(); ++i)
		for (int j = 0; j < Pixels[i].size() / 2; ++j)
		{
			swap(Pixels[i][j].Red, Pixels[i][Pixels[i].size() - j].Red);
			swap(Pixels[i][j].Green, Pixels[i][Pixels[i].size() - j].Green);
			swap(Pixels[i][j].Blue, Pixels[i][Pixels[i].size() - j].Blue);
		}
}

void vertical_reflextion(vector <vector <unsigned char>>& Pixels) //для P5
{
	for (int i = 0; i < Pixels.size() / 2; ++i)
		for (int j = 0; j < Pixels[i].size(); ++j)
			swap(Pixels[i][j], Pixels[Pixels.size() - i][j]);
}

void vertical_reflextion(vector <vector <struct RGB>>& Pixels) //для P6
{
	for (int i = 0; i < Pixels.size() / 2; ++i)
		for (int j = 0; j < Pixels[i].size(); ++j)
		{
			swap(Pixels[i][j].Red, Pixels[Pixels.size() - i][j].Red);
			swap(Pixels[i][j].Green, Pixels[Pixels.size() - i][j].Green);
			swap(Pixels[i][j].Blue, Pixels[Pixels.size() - i][j].Blue);
		}
}

void clock_and_counter_wise_ninety(vector <vector<unsigned char>>& Pixels, int type) //для P5
{
	vector <vector <unsigned char>> PixelsCopy(Pixels.size(), vector <unsigned char>(Pixels[0].size()));
	//создание копии массива пикселей
	for (int i = 0; i < Pixels.size(); ++i)
		for (int j = 0; j < Pixels[i].size(); ++j)
			PixelsCopy[i][j] = Pixels[i][j]; //непосредственно копирование
	Pixels.clear(); //чистка старого массива
	Pixels.assign(PixelsCopy[0].size(), vector<unsigned char>(PixelsCopy.size()));
	//смена ширины и высоты исходного массива местами

	for (int i = 0; i < Pixels.size(); ++i)
		for (int j = 0; j < Pixels[i].size(); ++j)
		{
			if (type == 1)
			    Pixels[i][j] = PixelsCopy[Pixels[i].size() - j][i]; //смена пикселей по часовой
			if (type == 2)
			    Pixels[i][j] = PixelsCopy[j][Pixels[i].size() - i]; //смена пикселей против часовой
		}

	PixelsCopy.clear(); //чистка копии
}

void clock_and_counter_wise_ninety(vector <vector<struct RGB>>& Pixels, int type) //для P6
{
	vector <vector <struct RGB>> PixelsCopy(Pixels.size(), vector <struct RGB>(Pixels[0].size()));
	//создание копии массива пикселей
	for (int i = 0; i < Pixels.size(); ++i)
		for (int j = 0; j < Pixels[i].size(); ++j) //непосредственно копирование
		{
			PixelsCopy[i][j].Red = Pixels[i][j].Red;
			PixelsCopy[i][j].Green = Pixels[i][j].Green;
			PixelsCopy[i][j].Blue = Pixels[i][j].Blue;
		}
	Pixels.clear(); //чистка старого массива
	Pixels.assign(PixelsCopy[0].size(), vector<struct RGB>(PixelsCopy.size()));
	//смена ширины и высоты исходного массива местами

		for (int i = 0; i < Pixels.size(); ++i)
			for (int j = 0; j < Pixels[i].size(); ++j) //смена пикселей
			{
				if (type == 1)
				{
					Pixels[i][j].Red = PixelsCopy[Pixels[i].size() - j][i].Red;
					Pixels[i][j].Green = PixelsCopy[Pixels[i].size() - j][i].Green;
					Pixels[i][j].Blue = PixelsCopy[Pixels[i].size() - j][i].Blue;
				}
				if (type == 2)
				{
					Pixels[i][j].Red = PixelsCopy[j][Pixels[i].size() - i].Red;
					Pixels[i][j].Green = PixelsCopy[j][Pixels[i].size() - i].Green;
					Pixels[i][j].Blue = PixelsCopy[j][Pixels[i].size() - i].Blue;
				}
			}

	PixelsCopy.clear(); //чистка копии
}

int main(int argc, char* argv[])
{
	//Часть 1. Считка формата файла, ширины и высоты, глубины цвета. Преобразование данных из char в int
	FILE* Source = fopen(argv[1], "rb");
	if (Source == NULL)
	{
		cout << "Warning! File didn`t open";
		return 1;
	}

	if (argc != 4)
	{
		cout << "Not enough parametrs!";
		return 1;
	}

	char Format[2];
	char buff;
	for (int i = 0; i < 2; ++i) //считка формата pnm файла. For exp. P5, P6 and etc.
		Format[i] = fgetc(Source);

	buff = fgetc(Source); //символ переноса строки

	vector <char> Width(1);
	while (true) //считка ширины в char
	{
		buff = fgetc(Source);
		if (buff == ' ') break;
		Width.push_back(buff);
	}
	buff = fgetc(Source); //считка пробела между шириной и высотой
	int width = width_to_int(Width);
	Width.clear(); //очистка памяти

	vector <char> Height(1);
	while (true) //считка высоты в char
	{
		buff = fgetc(Source);
		if (buff == '0a') break;
		Height.push_back(buff);
	}
	buff = fgetc(Source); //считка переноса строки
	int height = height_to_int(Height);
	Height.clear(); //очистка памяти

	char ColorDepth[3];
	for (int i = 0; i < 3; ++i)
		ColorDepth[i] = fgetc(Source); //считка значения глубины цвета в char
	if (((ColorDepth[0] - '0') * 100 + (ColorDepth[1] - '0') * 10 + (ColorDepth[2] - '0')) != 255)
		//перевод значения глубины цвета из char в int и сравнение с 255
	{
		cout << "Warning! Incorrect ColorDepth. Must be equal 255";
		return 1;
	}
	buff = fgetc(Source); //считка символа переноса строки

	//Часть 2. Работа с матрицей пикселей. Считка и преобразование char в int

	if (Format[1] == '5') //если файл в градации серого
	{
		vector <vector <unsigned char>> Pixels(height, vector<unsigned char>(width));
		for (int i = 0; i < height; ++i)
			for (int j = 0; j < width; ++j)
			{
				Pixels[i][j] = 0;
				buff = fgetc(Source);
				Pixels[i][j] = buff;
			}
		fclose(Source); //после считки данных, файл больше не нужен, закрываем
		switch ((int)argv[3])
		{
		case 0:
			inversion(Pixels);
			break;
		case 1:
			horizontal_reflextion(Pixels);
			break;
		case 2:
			vertical_reflextion(Pixels);
			break;
		case 3:
			clock_and_counter_wise_ninety(Pixels, 1);
			break;
		case 4:
			clock_and_counter_wise_ninety(Pixels, 2);
			break;
		}

	}
	else if (Format[1] == '6') //если цветное
	{
		vector <vector <struct RGB>> Pixels(height, vector<struct RGB>(width));

		for (int i = 0; i < height; ++i)
			for (int j = 0; j < width; ++j)
			{
				buff = fgetc(Source); //считка 1 байта пикселя
				Pixels[i][j].Red = buff;

				buff = fgetc(Source); //считка 2 байта пикселя
				Pixels[i][j].Green = buff;

				buff = fgetc(Source); //считка 3 байта пикселя
				Pixels[i][j].Blue = buff;
			}

		switch ((int)argv[3])
		{
		case 0:
			inversion(Pixels);
			break;
		case 1:
			horizontal_reflextion(Pixels);
			break;
		case 2:
			vertical_reflextion(Pixels);
			break;
		case 3:
			clock_and_counter_wise_ninety(Pixels, 1);
			break;
		case 4:
			clock_and_counter_wise_ninety(Pixels, 2);
			break;
		}
	}
	return 0;
}