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

void writeTask()
{
    cout << "Данная программа находит седловую точку квадратной матрицы\n";
}

string fileInputPath(bool isFileForRead)
{
    bool isNotCorrect;
    string path;
    fstream file;
    if (isFileForRead)
    {
        cout << "Введите путь к файлу для чтения: ";
    }
    else
    {
        cout << "Введите путь к файлу для записи: ";
    }
    do
    {
        isNotCorrect = false;
        cin >> path;
        file.open(path);
        if (!file.is_open())
        {
            cout << "Файл не найден. Повторите попытку...\n";
            isNotCorrect = true;
        }
    } while (isNotCorrect);
    file.close();
    return path;
}

int fileInputMatrixOrder(string path)
{
    fstream file;
    const int MAX_ORDER = 10;
    const int MIN_ORDER = 2;
    bool isFileForRead = true;
    bool isNotCorrect;
    int matrixOrder;
    do
    {
        isNotCorrect = false;
        file.open(path);
        if (!file.is_open()) {
            cout << "Не удалось открыть файл. ";
            isNotCorrect = true;
        }
        if (!isNotCorrect)
        {
            file >> matrixOrder;
            if (file.fail())
            {
                file.clear();
                while (file.get() != '\n');
                cout << "Некорректно введённый порядок матрицы. ";
                isNotCorrect = true;
            }
            if ((!isNotCorrect) && ((matrixOrder < MIN_ORDER) || (matrixOrder > MAX_ORDER)))
            {
                cout << "Порядок матрицы неверного диапазона! ";
                isNotCorrect = true;
            }
            if (isNotCorrect)
            {
                cout << "Повторите попытку...\n";
                path = fileInputPath(isFileForRead);
                file.close();
            }
        }
    } while (isNotCorrect);
    file.close();
    return matrixOrder;
}

int** fileMatrixInput(string path, int** matrix, int order)
{
    ifstream file;
    bool isNotCorrect;
    bool isFileForRead = true;
    do
    {
        isNotCorrect = false;
        file.open(path);
        file.get() != '\n';
        int i = 0;
        while ((!isNotCorrect) && (i < order))
        {
            int j = 0;
            while ((!isNotCorrect) && (j < order))
            {
                file >> matrix[i][j];
                if (file.fail())
                {
                    cout << "Ошибка! Найдено некорректное значение элемента матрицы\n";
                    isNotCorrect = true;
                    i--;
                }
                j++;
            }
            i++;
        }
        if (isNotCorrect)
        {
            cout << "Проверьте правильность введённых данных и повторите попытку...\n";
            path = fileInputPath(isFileForRead);
        }
    } while (isNotCorrect);
    file.close();
    return matrix;
}

int consoleInputMatrixOrder()
{
    const int MIN_ORDER = 2;
    const int MAX_ORDER = 10;
    bool isNotCorrect;
    int order;
    do
    {
        isNotCorrect = false;
        cout << "Введите порядок квадратной матрицы\n";
        cin >> order;
        if (cin.fail())
        {
            cin.clear();
            while (cin.get() != '\n');
            cout << "Ошибка ввода! Повторите попытку...\n";
            isNotCorrect = true;
        }
        if ((!isNotCorrect) && (cin.get() != '\n'))
        {
            cin.clear();
            cout << "Ошибка ввода! Повторите попытку...\n";
            isNotCorrect = true;
        }
        if ((!isNotCorrect) && ((order < MIN_ORDER) || (order > MAX_ORDER)))
        {
            cout << "Ошибка ввода! Проверьте, входит ли введённое значение в допустимый диапазон и повторите попытку...\n";
            isNotCorrect = true;
        }
    } while (isNotCorrect);
    return order;
}

int** matrixCreation(int order)
{
    int** matrix = new int* [order];
    for (int i = 0; i < order; i++)
    {
        matrix[i] = new int[order];
    }
    return matrix;
}

int** consoleFillMatrix(int** matrix, int order)
{
    const int MIN_ELEMENT = -2147483648;
    const int MAX_ELEMENT = 2147483647;
    bool isNotCorrect;
    for (int i = 0; i < order; i++)
    {
        for (int j = 0; j < order; j++)
        {
            do
            {
                isNotCorrect = false;
                cout << "Введите " << j + 1 << " элемент " << i + 1 << " строки\n";
                cin >> matrix[i][j];
                if (cin.fail())
                {
                    cin.clear();
                    while (cin.get() != '\n');
                    cout << "Ошибка ввода! Повторите попытку...";
                    isNotCorrect = true;
                }
                if ((!isNotCorrect) && (cin.get() != '\n'))
                {
                    cin.clear();
                    cout << "Ошибка ввода! Повторите попытку...\n";
                    isNotCorrect = true;
                }
                if ((!isNotCorrect) && ((order < MIN_ELEMENT) || (order > MAX_ELEMENT)))
                {
                    cout << "Ошибка ввода! Введено число неверного диапазона\n";
                    isNotCorrect = true;
                }
            } while (isNotCorrect);
        }
    }
    return matrix;
}

void consoleMatrixOutput(int** matrix, int order)
{
    cout << "Исходная матрица:\n";
    for (int i = 0; i < order; i++)
    {
        for (int j = 0; j < order; j++)
        {
            cout << matrix[i][j] << " ";
        }
        cout << endl;
    }
}

int* smallestElementsInLine(int** matrix, int order)
{
    int min;
    int* minIndexes = new int[order];
    for (int i = 0; i < order; i++)
    {
        min = matrix[i][0];
        minIndexes[i] = 0;
        for (int j = 0; j < order; j++)
        {
            if (matrix[i][j] <= min)
            {
                min = matrix[i][j];
                minIndexes[i] = j;
            }
        }
    }
    return minIndexes;
}

int* largestElementsInColumn(int** matrix, int order)
{
    int max;
    int* maxIndexes = new int[order];
    for (int j = 0; j < order; j++)
    {
        max = matrix[0][j];
        maxIndexes[j] = 0;
        for (int i = 0; i < order; i++)
        {
            if (matrix[i][j] >= max)
            {
                max = matrix[i][j];
                maxIndexes[j] = i;
            }
        }
    }
    return maxIndexes;
}

void findingMatrixSaddlePoints(int** matrix, bool isConsoleAnswer, int& order)
{
    fstream file;
    string path;
    int* maxElemIndexes = smallestElementsInLine(matrix, order);
    int* minElemIndexes = largestElementsInColumn(matrix, order);
    int saddlePoint;
    bool isSaddlePoint;
    bool isNotCorrect;
    for (int i = 0; i < order; i++)
    {
        for (int j = 0; j < order; j++)
        {
            if ((minElemIndexes[i] == j) && (maxElemIndexes[j] == i))
            {
                saddlePoint = matrix[i][j];
                isSaddlePoint = true;
            }
        }
    }
    if (isConsoleAnswer)
    {
        if (isSaddlePoint)
        {
            cout << "Седловая точка матрицы: " << saddlePoint;
        }
        else
        {
            cout << "Седловой точки нет";
        }
    }
    else
    {
        bool isFileForRead = false;
        do
        {
            isNotCorrect = false;
            path = fileInputPath(isFileForRead);
            file.open(path);
            if (!file.is_open())
            {
                cout << "Не удалось открыть файл. Повторите попытку...\n";
                isNotCorrect = true;
            }
            if (!isNotCorrect)
            {
                if (isSaddlePoint)
                {
                    file << "Седловая точка матрицы: " << saddlePoint;
                }
                else
                {
                    file << "Седловой точки нет";
                }
            }
        } while (isNotCorrect);
        file.close();
    }
}

int** fileChoice(int& order)
{
    bool isFileForRead = true;
    string path = fileInputPath(isFileForRead);
    order = fileInputMatrixOrder(path);
    int** matrix = matrixCreation(order);
    matrix = fileMatrixInput(path, matrix, order);
    return matrix;
}

int** consoleChoice(int& order)
{
    order = consoleInputMatrixOrder();
    int** matrix = matrixCreation(order);
    matrix = consoleFillMatrix(matrix, order);
    consoleMatrixOutput(matrix, order);
    return matrix;
}

int chooseOutputMethod()
{
    bool isNotCorrect;
    int choice;
    do
    {
        isNotCorrect = false;
        cin >> choice;
        if (cin.fail())
        {
            cin.clear();
            while (cin.get() != '\n');
            cout << "Число введено некорректно. Повторите попытку...\n";
            isNotCorrect = true;
        }
        if ((!isNotCorrect) && (cin.get() != '\n'))
        {
            cin.clear();
            cout << "Число введено некорректно. Повторите попытку...\n";
            isNotCorrect = true;
        }
        if ((!isNotCorrect) && (choice != 1) && (choice != 2))
        {
            cout << "Введите либо 1, либо 2. Ваш выбор: \n";
            isNotCorrect = true;
        }
    } while (isNotCorrect);
    return choice;
}

void solution()
{
    int order = 0;
    int** matrix = nullptr;
    bool isConsoleAnswer = false;
    cout << "Введите число, чтобы выбрать способ решения задания: 1 - через консоль, 2 - через файл\n";
    int choice = chooseOutputMethod();
    if (choice == 1)
    {
        isConsoleAnswer = true;
        matrix = consoleChoice(order);
        findingMatrixSaddlePoints(matrix, isConsoleAnswer, order);
    }
    else
    {
        matrix = fileChoice(order);
        cout << "Введите число, чтобы выбрать способ вывода решения задания: 1 - через консоль, 2 - через файл\n";
        choice = chooseOutputMethod();
        if (choice == 1)
        {
            isConsoleAnswer = true;
            findingMatrixSaddlePoints(matrix, isConsoleAnswer, order);
        }
        else
        {
            findingMatrixSaddlePoints(matrix, isConsoleAnswer, order);
            cout << "Седловая точка матрицы успешно выведена в файл!";
        }
    }
}

int main()
{
    setlocale(LC_ALL, "Rus");
    writeTask();
    solution();
}