#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#include <list>
#include <iomanip>
#include <sstream>

using namespace std;


int inputIntegerNumber(const int MIN_NUMBER, const int MAX_NUMBER) {
    bool IsIncorrect;
    int Number;
    string Input = "";

    do {
        getline(cin, Input);
        IsIncorrect = false;
        try {
            Number = stoi(Input);
        }
        catch (invalid_argument ex) {
            cout << "Введите число:\n";
            IsIncorrect = true;
        }
        catch (out_of_range ex) {
            cout << "Число не должно быть меньше " << MIN_NUMBER << " и больше, чем "
                << MAX_NUMBER << "\n";
            IsIncorrect = true;
        }
        if (!IsIncorrect && (Number <  MIN_NUMBER || Number > MAX_NUMBER)) {
            cout << "Число не должно быть меньше " << MIN_NUMBER << " и больше, чем "
                << MAX_NUMBER << "\n";
            IsIncorrect = true;
        }
    } while (IsIncorrect);

    return Number;
}

bool checkFile(const string PathToFile) {
    bool Flag = true;
    int CurrentNumber;
    ifstream InputFile(PathToFile);
    while ((Flag) && (!InputFile.eof())) {
        try {
            InputFile >> CurrentNumber;
        }
        catch (invalid_argument ex) {
            cout << "Некорректные данные в файле.\n";
            Flag = false;
        }
        catch (out_of_range ex) {
            cout << "Некорректные данные в файле.\n";
            Flag = false;
        }
        if (Flag && (CurrentNumber < 1 || CurrentNumber > 20)) {
            cout << "Некорректные данные в файле.\n";
            Flag = false;
        }
    }
    InputFile.close();
    return Flag;
}

bool checkPermissionForWriting(const string& PathToFile) {
    bool Flag;
    ofstream FileOut(PathToFile);

    if (FileOut.is_open()) {
        FileOut.close();
        Flag = true;
    }
    else {
        cout << "Файл не доступен для записи.\n";
        Flag = false;
    }

    return Flag;
}


bool checkExtension(const string& PathToFile) {
    const string extension = "txt";
    bool Flag;

    if (PathToFile.length() > 4 && PathToFile.substr(PathToFile.length() - 3) == extension) {
        Flag = true;
    }
    else {
        cout << "Неверное расширение.\n";
        Flag = false;
    }

    return Flag;
}

bool checkPermissionForReading(const string& PathToFile) {
    bool Flag;
    ifstream FileIn(PathToFile);
    if (FileIn.is_open()) {
        FileIn.close();
        Flag = true;
    }
    else {
        cout << "Файл не доступен для чтения.\n";
        Flag = false;
    }
    return Flag;
}

const string inputPathToFileForReading() {
    string PathToFile;
    do {
        cout << "Введите путь к файлу для чтения:\n";
        getline(cin, PathToFile);
    } while (!checkExtension(PathToFile) || !checkPermissionForReading(PathToFile) || !checkFile(PathToFile));
    return PathToFile;
}

const string inputPathToFileForWriting() {
    string PathToFile;
    do {
        cout << "Введите путь к файлу для записи: \n";
        getline(cin, PathToFile);
    } while (!checkExtension(PathToFile) || !checkPermissionForWriting(PathToFile));
    return PathToFile;
}

typedef vector<list<int>> TListArray;
typedef vector<vector<int>> TMatrix;


void printListArray(TListArray& ListArray) {
    cout << "Списки инцидентности:\n";
    for (int i = 0; i < ListArray.size(); i++) {
        cout << i + 1 << ": ";
        for (auto Iterator : ListArray[i])
            cout << "->" << Iterator;
        cout << '\n';
    }
}

void writeIncidentMatrix(TMatrix& IncidentMatrix, ofstream& FileOut) {
    FileOut << "Матрица инциденций:\n" << "   ";
    for (int i = 0; i < IncidentMatrix[0].size(); i++) {
        FileOut << setw(2) << (char)(i + 97) << ' ';
    }
    FileOut << '\n';
    for (int i = 0; i < IncidentMatrix.size(); i++) {
        FileOut << i + 1 << ": ";
        for (int j = 0; j < IncidentMatrix[i].size(); j++)
            FileOut << setw(2) << IncidentMatrix[i][j] << " ";
        FileOut << '\n';
    }
    FileOut << '\n';
}

void saveToFile(TMatrix& IncidentMatrix) {
    char Answer;
    cout << "Введите '1', если хотите сохранить в файл.\n";
    cin >> Answer;
    cin.ignore(256, '\n');
    if (Answer == '1') {
        string PathToFile = inputPathToFileForWriting();
        ofstream FileOut(PathToFile);
        writeIncidentMatrix(IncidentMatrix, FileOut);
        cout << "Матрица сохранена в файл.\n";
    }
    cout << "Программа завершена.";
}

void printIncidentMatrix(TMatrix& IncidentMatrix) {
    cout << "Матрица инциденций:\n" << "   ";
    for (int i = 0; i < IncidentMatrix[0].size(); i++) {
        cout << setw(2) << (char)(i + 97) << ' ';
    }
    cout << '\n';
    for (int i = 0; i < IncidentMatrix.size(); i++) {
        cout << i + 1 << ": ";
        for (int j = 0; j < IncidentMatrix[i].size(); j++)
            cout << setw(2) << IncidentMatrix[i][j] << " ";
        cout << '\n';
    }
    cout << '\n';
}

void addVertex(TListArray &ListArray, int Index, int VertexNumber) {
    ListArray[Index].push_back(VertexNumber);
}

vector<int> getVertexNumber(string Buffer) {
    vector<int> VertexNumbers;
    string Number;
    int j;
    for (int i = 1; i < Buffer.size(); i++) {
        if (Buffer[i] != ' ') {
            j = i;
            while ((Buffer[j] != ' ') && j < Buffer.size())
                Number += Buffer[j++];
            if (Number != "")
                VertexNumbers.push_back(stoi(Number));
            i = j;
            Number = "";
        }
    }
    return VertexNumbers;
}

void readFormFile(TListArray& ListArray, string PathToFile) {
    int NumberOfVertices, VertexNumber, i;
    string Buffer = "";
    vector<int> VertexNumbers;
    i = -1;
    ifstream FileIn(PathToFile);
    FileIn >> NumberOfVertices;
    ListArray.resize(NumberOfVertices);
    while (!FileIn.eof()) {
        getline(FileIn, Buffer);
        VertexNumbers = getVertexNumber(Buffer);
        for (int j = 0; j < VertexNumbers.size(); j++)
            addVertex(ListArray, i, VertexNumbers[j]);
        i++;
    }
    FileIn.close();
}

int inputVertexNumber(int WrongNumber, int MaxIndexOfVertices) {
    bool IsIncorrect = true;
    int VertexNumber;
    do {
        cout << "Введите номер следующей инцидентной вершины: ";
        VertexNumber = inputIntegerNumber(1, MaxIndexOfVertices);
        if (VertexNumber == WrongNumber) {
            IsIncorrect = true;
            cout << "Текущая вершина не может быть инцидентна данной.\n";
        }
        else{
            IsIncorrect = false;
        }
        cout << '\n';
    } while (IsIncorrect);
    return VertexNumber;
}

void receiveListReprezentation(TListArray& ListArray) {
    int NumberOfVertices, VertexNumber, CurrentNumberOfVertices;
    cout << "Введите количество вершин:\n";
    NumberOfVertices = inputIntegerNumber(1, 10);
    ListArray.resize(NumberOfVertices);
    for (int i = 0; i < NumberOfVertices; i++) {
        cout << "Введите количество вершин, смежных с вершиной " << i + 1 << ":\n";
        CurrentNumberOfVertices = inputIntegerNumber(0, NumberOfVertices - 1);
        for (int j = 0; j < CurrentNumberOfVertices; j++) {
            VertexNumber = inputVertexNumber(i + 1, NumberOfVertices);
            addVertex(ListArray, i, VertexNumber);
        }
    }
}

void receiveGraph(TListArray& ListArray) {
    char Answer = 'q';
    cout << "Введите '1', если хотите счиать из файла. '2' - из консоли.\n";
    do {
        cin >> Answer;
        cin.ignore(256, '\n');
        if (Answer == '1') {
            string PathToFile = inputPathToFileForReading();
            readFormFile(ListArray, PathToFile);
            cout << "Граф получен.\n";
        }
        else
            if (Answer == '2') {
                receiveListReprezentation(ListArray);
                cout << "Граф получен.\n";
            }
            else
                cout << "Введите '1' или '2'.\n";
    } while ((Answer != '1') && (Answer != '2'));
}

void resizeIncidentMatrix(TMatrix& IncidentMatrix, int NumberOfColumns) {
    for (int i = 0; i < IncidentMatrix.size(); i++) {
        IncidentMatrix[i].resize(NumberOfColumns);
    }
}

TMatrix receiveAdjacencyMatrix(TListArray& ListArray){
    TMatrix AdjacencyMatrix(ListArray.size(), vector<int>(ListArray.size(), 0));
    for (int i = 0; i < ListArray.size(); i++) {
        for (auto const& Iterator : ListArray[i]) {
            AdjacencyMatrix[i][Iterator - 1] = 1;
        }
    }
    return AdjacencyMatrix;
}

TMatrix receiveIncidentMatrix(TListArray& ListArray) {
    TMatrix AdjacencyMatrix = receiveAdjacencyMatrix(ListArray);
    TMatrix IncidentMatrix(ListArray.size(), vector<int>((ListArray.size() * (ListArray.size() - 1) / 2), 0));
    int ColCount = 0;
    for (int i = 0; i < AdjacencyMatrix.size(); i++) {
        for (int j = 0; j < AdjacencyMatrix.size(); j++) {
            if (AdjacencyMatrix[i][j] == 1) {
                IncidentMatrix[j][ColCount] = 1;
                if (AdjacencyMatrix[j][i] == 1)
                    IncidentMatrix[i][ColCount] = 1;
                else
                    IncidentMatrix[i][ColCount] = -1;
                AdjacencyMatrix[j][i] = 0;
                ColCount++;
            }
        }
    }
    resizeIncidentMatrix(IncidentMatrix, ColCount);
    return IncidentMatrix;
}

int main() {
    system("chcp 1251");
    TListArray ListArray;
    receiveGraph(ListArray);
    printListArray(ListArray);
    TMatrix IncidentMatrix = receiveIncidentMatrix(ListArray);
    printIncidentMatrix(IncidentMatrix);
    saveToFile(IncidentMatrix);
    return 0;
}