using System.Net;

namespace matrix_4;

class Program {
    static void Main(string[] args) {
        Console.Clear();
        int scelta, lineaAutobus, lineaAutobus2, fermataAutobus, fermataAutobus2, conto, j = 0;
        (string[], string[], bool[,]) configurazione = Configurazione();
        string[] fermateAutobus = configurazione.Item1, lineeAutobus = configurazione.Item2;
        int[] lineePartenza = new int[fermateAutobus.Length], lineeDestinazione = new int[fermateAutobus.Length];
        bool[,] corrispondenzaLineaFermata = configurazione.Item3;
        bool nullo = true;

        do {
            Console.WriteLine("Inserire un'opzione:");
            Console.WriteLine("1. La linea passa per la fermata?");
            Console.WriteLine("2. Quali linee passano per la fermata?");
            Console.WriteLine("3. Quali e quante sono le fermate per la linea?");
            Console.WriteLine("4. Due linee hanno fermate in comune?");
            Console.WriteLine("5. Percorsi tra due fermate");
            Console.WriteLine("0. Esci");
            Console.Write("Scelta: ");
            scelta = Convert.ToInt32(Console.ReadLine());

            switch (scelta) {
                case 0:
                    break;
                case 1:
                    Console.Clear();
                    lineaAutobus = SelezionaElementoArray(lineeAutobus);
                    fermataAutobus = SelezionaElementoArray(fermateAutobus);
                    Console.Clear();

                    if (corrispondenzaLineaFermata[lineaAutobus, fermataAutobus]) {
                        Console.WriteLine($"La linea {lineeAutobus[lineaAutobus]} passa per la fermata {fermateAutobus[fermataAutobus]}");
                    }
                    else {
                        Console.WriteLine($"La linea {lineeAutobus[lineaAutobus]} non passa per la fermata {fermateAutobus[fermataAutobus]}");
                    }
                    Pausa();
                    break;
                case 2:
                    Console.Clear();

                    conto = 0;
                    fermataAutobus = SelezionaElementoArray(fermateAutobus);
                    Console.Clear();

                    Console.WriteLine($"Per la fermata {fermateAutobus[fermataAutobus]} passano le linee:");
                    for (int i = 0; i < corrispondenzaLineaFermata.GetLength(1); i++) {
                        if (corrispondenzaLineaFermata[fermataAutobus, i]) {
                            Console.WriteLine(lineeAutobus[i]);
                            conto++;
                        }
                    }
                    Console.WriteLine($"Per la fermata {fermateAutobus[fermataAutobus]} passano {conto} linee");
                    Pausa();
                    break;
                case 3:
                    Console.Clear();
                    conto = 0;
                    lineaAutobus = SelezionaElementoArray(lineeAutobus);
                    Console.Clear();

                    Console.WriteLine($"La linea {lineeAutobus[lineaAutobus]} ha le fermate:");
                    for (int i = 0; i < corrispondenzaLineaFermata.GetLength(0); i++) {
                        if (corrispondenzaLineaFermata[i, lineaAutobus]) {
                            Console.WriteLine(fermateAutobus[i]);
                            conto++;
                        }
                    }
                    Console.WriteLine($"Le fermate per la linea {lineeAutobus[lineaAutobus]} sono {conto}");
                    Pausa();
                    break;
                case 4:
                    Console.Clear();
                    lineaAutobus = SelezionaElementoArray(lineeAutobus);
                    Console.Clear();
                    lineaAutobus2 = SelezionaElementoArray(lineeAutobus);
                    Console.Clear();
                    if (lineaAutobus != lineaAutobus2) {
                        Console.WriteLine($"Tra le linee {lineeAutobus[lineaAutobus]} e {lineeAutobus[lineaAutobus2]} fermate in comune sono:");
                        for (int i = 0; i < corrispondenzaLineaFermata.GetLength(0); i++) {
                            if (corrispondenzaLineaFermata[i, lineaAutobus] == corrispondenzaLineaFermata[i, lineaAutobus2]) {
                                Console.WriteLine(fermateAutobus[i]);
                                nullo = false;
                            }
                        }

                        if (nullo) {//serve per scrivere se non c'è nessuna fermata in comune
                            Console.WriteLine("Nessuna");
                        }

                    }
                    else {
                        Console.WriteLine("Selezionare due linee differenti.");
                    }

                    Pausa();
                    break;
                case 5:
                    Console.Clear();
                    fermataAutobus = SelezionaElementoArray(fermateAutobus);
                    Console.Clear();
                    fermataAutobus2 = SelezionaElementoArray(fermateAutobus);
                    Console.Clear();
                    if (fermataAutobus != fermataAutobus2) {
                        Console.Write($"Tra le fermate {fermateAutobus[fermataAutobus]} e {fermateAutobus[fermataAutobus2]} passano le linee: ");
                        for (int i = 0; i < corrispondenzaLineaFermata.GetLength(1); i++) {
                            if (corrispondenzaLineaFermata[fermataAutobus, i] && corrispondenzaLineaFermata[fermataAutobus2, i]) {
                                Console.Write($"{lineeAutobus[i]} ");
                                nullo = false;
                            }
                        }

                        if (nullo) {//serve per scrivere se non c'è nessuna fermata in comune
                            Console.WriteLine("Nessuna");
                            Console.WriteLine("Quindi si può:");


                            Array.Fill(lineePartenza, int.MaxValue);
                            Array.Fill(lineeDestinazione, int.MaxValue);

                            //trovo tutte le linee che passano per la fermata di partenza
                            for (int i = 0; i < corrispondenzaLineaFermata.GetLength(0) && j < lineePartenza.Length; i++) {
                                if (corrispondenzaLineaFermata[i, fermataAutobus]) {
                                    lineePartenza[j] = i;
                                    j++;
                                }
                            }
                            //trovo tutte le linee che passano per la fermata di destinazione
                            for (int i = 0; i < corrispondenzaLineaFermata.GetLength(0) && j < corrispondenzaLineaFermata.GetLength(1); i++) {
                                if (corrispondenzaLineaFermata[fermataAutobus2, i]) {
                                    lineeDestinazione[j] = i;
                                    j++;
                                }
                            }

                            //riordino il tutto per semplificare i cicli
                            lineePartenza = InsertionSort(lineePartenza);
                            lineeDestinazione = InsertionSort(lineeDestinazione);


                            j = 0;
                            for (int k = 0; k < corrispondenzaLineaFermata.GetLength(1); k++) {
                                for (int i = 0; i < corrispondenzaLineaFermata.GetLength(0); i++) {
                                    if (!(lineePartenza[i] == int.MaxValue || lineeDestinazione[k] == int.MaxValue)) {
                                        while (j < corrispondenzaLineaFermata.GetLength(0)) {
                                            //Verifico che la fermata j sia in comune tra la linea di partenza e di destinazione
                                            if (corrispondenzaLineaFermata[j, lineePartenza[i]] == corrispondenzaLineaFermata[j, lineeDestinazione[k]] && corrispondenzaLineaFermata[j, lineeDestinazione[k]]) {
                                                if (lineePartenza[i] != lineeDestinazione[k]) {
                                                    Console.WriteLine($"Prendere la linea {lineeAutobus[lineePartenza[i]]}, cambiare alla fermata {fermateAutobus[j]} e proseguire sulla linea {lineeAutobus[lineeDestinazione[k]]}");
                                                }
                                            }
                                            j++;
                                        }
                                        j = 0;
                                    }
                                }
                            }
                        }
                    }
                    else {
                        Console.WriteLine("Selezionare due fermate differenti.");
                    }
                    Pausa();
                    break;
            }
        }
        while (scelta != 0);


    }

    static void Pausa() {
        Console.WriteLine("Premere un tasto per continuare. . .");
        Console.ReadKey();
        Console.Clear();
    }

    static (string[], string[], bool[,]) Configurazione() {
        int dimensione1, dimensione2, r = 0, c = 0, scelta;
        (string[], string[], bool[,]) ritorno;

        Console.Clear();
        do {
            Console.Write("Quante sono le fermate dell'autobus? ");
            dimensione1 = Convert.ToInt32(Console.ReadLine());
            if (dimensione1 <= 0) {
                Console.WriteLine("Errore: non è possibile inserire un numero minore o uguale a zero.");
                Pausa();
            }
        }
        while (dimensione1 <= 0);
        ritorno.Item1 = new string[dimensione1];
        for (int i = 0; i < dimensione1; i++) {
            Console.Write($"Inserire la fermata n. {i + 1}: ");
            ritorno.Item1[i] = Console.ReadLine();
        }

        Console.Clear();

        do {
            Console.Write("Quante sono le linee dell'autobus? ");
            dimensione2 = Convert.ToInt32(Console.ReadLine());
            if (dimensione2 <= 0) {
                Console.WriteLine("Errore: non è possibile inserire un numero minore o uguale a zero.");
                Pausa();
            }
        }
        while (dimensione2 <= 0);
        ritorno.Item2 = new string[dimensione2];
        for (int i = 0; i < dimensione2; i++) {
            Console.Write($"Inserire la linea n. {i + 1}: ");
            ritorno.Item2[i] = Console.ReadLine();
        }

        ritorno.Item3 = new bool[dimensione1, dimensione2];

        Console.Clear();

        while (r < dimensione1) {
            while (c < dimensione2) {
                Console.WriteLine($"La linea {ritorno.Item2[c]} si ferma alla fermata {ritorno.Item1[r]}?");
                Console.WriteLine("[0] Sì\t[1] No");
                scelta = Convert.ToInt32(Console.ReadLine());
                switch (scelta) {
                    case 0:
                        ritorno.Item3[r, c] = true;
                        c++;
                        Console.Clear();
                        break;
                    case 1:
                        ritorno.Item3[r, c] = false;
                        c++;
                        Console.Clear();
                        break;
                    default:
                        Console.WriteLine("Opzione non valida.");
                        Pausa();
                        break;
                }
            }
            r++;
            c = 0;
        }
        return ritorno;
    }

    static void StampaArray(string[] p_array) {
        for (int j = 0; j < p_array.Length; j++) {
            Console.WriteLine("Elemento " + j + ": " + p_array[j]);
        }
    }

    static int SelezionaElementoArray(string[] p_array) {
        int ritorno;
        do {
            Console.WriteLine("Quale elemento selezionare?");
            StampaArray(p_array);
            ritorno = Convert.ToInt32(Console.ReadLine());
            if (ritorno < 0 || ritorno > p_array.Length) {
                Console.WriteLine("La scelta inserita non è valida.");
                Pausa();
            }
        } while (ritorno < 0 || ritorno > p_array.Length);

        return ritorno;

    }

    static int[] InsertionSort(int[] p_array) { //implementazione ufficiale copiata da Classroom
        int i, j;
        int temp;

        for (i = 1; i < p_array.Length; i++) {
            temp = p_array[i];
            j = i - 1;
            while (j >= 0 && p_array[j] > temp) {
                p_array[j + 1] = p_array[j];
                j--;
            }
            p_array[j + 1] = temp;
        }

        return p_array;
    }
}