using System;
using System.IO;


namespace Fedortsov.Lab7Exc1
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int[,] incidenceMatrix = null;

            Menu(out incidenceMatrix);
        }

        static void Menu(out int[,] incidenceMatrix)
        {
            incidenceMatrix = null;
            DoublyLinkedList<int>[] adjacencyList = null;

            int choice;

            bool exit = false;

            while (!exit)
            {
                Console.Clear();
                Console.WriteLine("Задание: преобразовать матрицу инцидентности в список смежности.");
                Console.WriteLine("1. Ввести матрицу инцидентности");
                Console.WriteLine("2. Преобразовать в список смежности");
                Console.WriteLine("3. Экспортировать список смежности в файл");
                Console.WriteLine("4. Импортировать матрицу инцидентности из файла");
                Console.WriteLine("5. Выход");
                Console.WriteLine("\n\nВажно для импорта:\n" +
                    "1. Первая строка файла должна содержать количество вершин (целое число)." +
                    "\n2. Вторая строка файла должна содержать количество ребер (целое число).\n" +
                    "3. Далее следуют строки, каждая из которых соответствует одной вершине и содержит набор чисел,\n" +
                    "являющихся элементами матрицы инцидентности для этой вершины. " +
                    "\nКаждый элемент матрицы должен быть отделен от других пробелом.\n" +
                    "Пример:\n" +
                    "4\n" +
                    "3\n" +
                    "1 1 0\n" +
                    "1 1 1\n" +
                    "0 0 1\n" +
                    "1 0 0\n");

                do
                {
                    Console.Write("\nВыбор: ");
                } while (!int.TryParse(Console.ReadLine(), out choice));

                switch (choice)
                {
                    case 1:
                        incidenceMatrix = FillMatrixFromConsole();
                        break;

                    case 2:
                        if (incidenceMatrix == null)
                        {
                            Console.WriteLine("Матрица инцидентности не задана");
                            break;
                        }

                        adjacencyList = ConvertMatrixToList(incidenceMatrix);

                        Console.WriteLine("Список смежности:");
                        for (int i = 0; i < adjacencyList.Length; i++)
                        {
                            Console.Write($"{i + 1} - > ");

                            foreach (int vertex in adjacencyList[i])
                            {
                                Console.Write($"{vertex + 1} ");
                            }

                            Console.WriteLine();
                        }

                        Console.ReadKey();

                        break;

                    case 3:
                        if (adjacencyList == null)
                        {
                            Console.WriteLine("Список смежности не задан");
                            break;
                        }

                        ExportAdjacencyList(adjacencyList);

                        Console.ReadKey();

                        break;

                    case 4:

                        if (ImportIncidenceMatrix(out int[,] matrix))
                        {
                            Console.WriteLine("Импорт завершен!");
                            incidenceMatrix = matrix;
                        }
                        else
                        {
                            Console.WriteLine("Импорт матрицы инцидентности не удался");
                        }

                        Console.ReadKey();

                        break;

                    case 5:
                        exit = true;
                        break;

                    default:
                        Console.WriteLine("Неверный выбор");
                        break;
                }

                Console.WriteLine();
            }
        }

        static int[,] FillMatrixFromConsole()
        {
            int[,] incidenceMatrix = null;
            bool incidenceMatrixExists, isCorrectAmountEdges, isCorrectVertex;
            int maxAmountEdges, n, m;

            do
            {
                do
                {
                    Console.Write("Введите количество вершин: ");
                } while (!int.TryParse(Console.ReadLine(), out n));

                maxAmountEdges = n * (n - 1) / 2;

                do
                {
                    do
                    {
                        Console.Write("Введите количество ребер: ");
                    } while (!int.TryParse(Console.ReadLine(), out m));

                    if (maxAmountEdges < m)
                    {
                        isCorrectAmountEdges = true;
                        Console.WriteLine("\nМаксимальное кол-во ребер: " + maxAmountEdges + ". Повторите ввод.\n");
                    }
                    else
                        isCorrectAmountEdges = false;

                } while (isCorrectAmountEdges);


                incidenceMatrix = new int[n, m];

                for (int i = 0; i < n; i++)
                {
                    for (int j = 0; j < m; j++)
                    {
                        do
                        {
                            do
                            {
                                Console.Write($"Введите элемент [{i},{j}]: ");
                            } while (!int.TryParse(Console.ReadLine(), out incidenceMatrix[i, j]));

                            if (incidenceMatrix[i, j] != 1 && incidenceMatrix[i, j] != 0)
                            {
                                isCorrectVertex = false;
                                Console.WriteLine("\nВведите элемент правильно: 1 или 0.\n");
                            }
                            else
                                isCorrectVertex = true;

                        } while (!isCorrectVertex);
                    }
                }

                incidenceMatrixExists = true;

                for (int i = 0; i < n; i++)
                {
                    int degree = 0;
                    for (int j = 0; j < m; j++)
                    {
                        degree += incidenceMatrix[i, j];
                    }
                    if (degree % 2 != 0) // нечетная степень у вершины
                    {
                        incidenceMatrixExists = false;
                        break;
                    }
                }

                if (!incidenceMatrixExists)
                    Console.WriteLine("Матрица инцидентности не существует. Повторите ввод.");

            } while (!incidenceMatrixExists);

            Console.WriteLine("Матрица инцидентности:");
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    Console.Write($"{incidenceMatrix[i, j]} ");
                }
                Console.WriteLine();
            }

            Console.ReadKey();

            return incidenceMatrix;
        }
        static DoublyLinkedList<int>[] ConvertMatrixToList(int[,] incidenceMatrix)
        {
            DoublyLinkedList<int>[] adjacencyList = null;

            adjacencyList = new DoublyLinkedList<int>[incidenceMatrix.GetLength(0)];

            for (int i = 0; i < incidenceMatrix.GetLength(0); i++)
            {
                adjacencyList[i] = new DoublyLinkedList<int>();

                for (int j = 0; j < incidenceMatrix.GetLength(1); j++)
                {
                    if (incidenceMatrix[i, j] == 1)
                    {
                        for (int k = 0; k < incidenceMatrix.GetLength(0); k++)
                        {
                            if (k != i && incidenceMatrix[k, j] == 1)
                            {
                                adjacencyList[i].AddLast(k);
                            }
                        }
                    }
                }
            }

            return adjacencyList;
        }
        static void ExportAdjacencyList(DoublyLinkedList<int>[] adjacencyList)
        {
            try
            {
                Console.Write("Введите имя файла для экспорта: ");
                string filename = Console.ReadLine();

                using (StreamWriter writer = new StreamWriter(filename))
                {
                    for (int i = 0; i < adjacencyList.Length; i++)
                    {
                        writer.Write($"{i}: ");

                        foreach (int vertex in adjacencyList[i])
                        {
                            writer.Write($"{vertex} ");
                        }

                        writer.WriteLine();
                    }
                }
                Console.WriteLine($"Список смежности экспортирован в файл {filename}");
            }
            catch (IOException)
            {
                Console.WriteLine("Ошибка экспорта!");
            }
        }
        public static bool ImportIncidenceMatrix(out int[,] matrix)
        {
            matrix = null;

            Console.Write("Введите путь к файлу: ");
            string filePath = Console.ReadLine();

            try
            {
                if (!File.Exists(filePath))
                {
                    Console.WriteLine("Ошибка: файл не существует.");
                    return false;
                }

                using (var reader = new StreamReader(filePath))
                {
                    if (!int.TryParse(reader.ReadLine(), out int vertexCount) || vertexCount <= 0)
                    {
                        Console.WriteLine("Ошибка: некорректное количество вершин.");
                        return false;
                    }

                    if (!int.TryParse(reader.ReadLine(), out int edgeCount) || edgeCount <= 0)
                    {
                        Console.WriteLine("Ошибка: некорректное количество ребер.");
                        return false;
                    }

                    matrix = new int[vertexCount, edgeCount];

                    for (int i = 0; i < vertexCount; i++)
                    {
                        string line = reader.ReadLine();
                        string[] values = line.Split(' ');

                        if (values.Length != edgeCount)
                        {
                            Console.WriteLine($"Ошибка: некорректное количество элементов в строке {i + 3}.");
                            return false;
                        }

                        for (int j = 0; j < edgeCount; j++)
                        {
                            if (!int.TryParse(values[j], out matrix[i, j]))
                            {
                                Console.WriteLine($"Ошибка: некорректный элемент в строке {i + 3}, столбце {j + 1}.");
                                return false;
                            }
                        }
                    }
                }
            }
            catch (FileNotFoundException)
            {
                Console.WriteLine("Ошибка: файл не найден.");
                return false;
            }
            catch (UnauthorizedAccessException)
            {
                Console.WriteLine("Ошибка: доступ к файлу запрещен.");
                return false;
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Ошибка: {ex.Message}");
                return false;
            }

            return true;
        }
    }
}