namespace ripasso4;

class Program {
    const int dimensione = 5;
    static void Main(string[] args) {
        Console.Clear();
        //dichiarazione e inizializzazione variabili
        int scelta;
        string[] arrayNomi = new string[dimensione], arrayCognomi = new string[dimensione], arrayNumeri;

        //menu
        do {
            Console.WriteLine("Scegliere un'opzione:");
            Console.WriteLine("1. Pari a sinistra, dispari a destra");
            Console.WriteLine("2. Array paralleli");
            Console.WriteLine("3. Inversione");
            Console.WriteLine("0. Esci");
            Console.Write("Scelta: ");
            scelta = Convert.ToInt32(Console.ReadLine());


            switch (scelta) {
                case 0:
                    Console.Clear();
                    break;
                case 1:
                    Console.Clear();
                    StampaArray(CreaVettoreOrdinato());
                    Pausa();
                    break;
                case 2:
                    Console.Clear();
                    CreaVettoriParalleli(arrayCognomi, arrayNomi);
                    ControllaVettoriParalleli(arrayCognomi, arrayNomi);
                    CercaAlunni(arrayCognomi, arrayNomi);
                    Pausa();
                    break;
                case 3:
                    Console.Clear();
                    arrayNumeri = CreaVettore();
                    Console.Clear();
                    Console.WriteLine("Array originale:");
                    StampaArray(arrayNumeri);
                    Console.WriteLine();
                    Console.WriteLine("Array invertito: ");
                    StampaArray(RibaltaVettore(arrayNumeri));
                    Pausa();
                    break;
                default:
                    Console.WriteLine("Errore: scelta non valida");
                    Pausa();
                    break;
            }
        }
        while (scelta != 0);
    }
    static void StampaArray(string[] p_insieme) {
        for (int j = 0; j < p_insieme.Length; j++) {
            Console.WriteLine("Elemento " + j + ": " + p_insieme[j]);
        }
    }
    static string[] CreaVettoreOrdinato() {
        int[] arrayCasuale = CreaArrayCasuale();
        string[] ritorno = new string[dimensione];
        int indiceDecrescenteArray = dimensione - 1, indiceCrescenteArray = 0;
        for (int i = 0; i < dimensione; i++) {
            if (arrayCasuale[i] % 2 != 0) {
                ritorno[indiceDecrescenteArray] = Convert.ToString(arrayCasuale[i]);
                indiceDecrescenteArray--;
            }
            else {
                ritorno[indiceCrescenteArray] = Convert.ToString(arrayCasuale[i]);
                indiceCrescenteArray++;
            }
        }
        return ritorno;

    }
    static int[] CreaArrayCasuale() {
        //dichiarazione e inizializzazione variabili
        Random caso = new Random();
        int[] ritorno = new int[dimensione];

        for (int i = 0; i < dimensione; i++) {
            ritorno[i] = caso.Next(11);//per ogni posizione di ritorno assegno un valore a caso (metodo Random.Next)
        }
        return ritorno;
    }
    static void Pausa() {
        Console.WriteLine("Premere un tasto per continuare. . .");
        Console.ReadKey();
        Console.Clear();
    }
    static void CreaVettoriParalleli(string[] p_arrayCognomi, string[] p_arrayNomi) {

        for (int i = 0; i < dimensione; i++) { //Inserimento nomi e cognomi
            Console.Clear();

            //Inserimento cognomi
            Console.Write("Inserire il cognome dell'alunno n." + (i + 1) + ": ");
            p_arrayCognomi[i] = Console.ReadLine();

            Console.Clear();

            //Inserimento nomi
            Console.Write("Inserire il nome dell'alunno n." + (i + 1) + ": ");
            p_arrayNomi[i] = Console.ReadLine();
        }
    }
    static void ControllaVettoriParalleli(string[] p_arrayCognomi, string[] p_arrayNomi) {
        string correzione;
        uint elemento;
        char scelta;

        do {
            Console.Clear();
            Console.WriteLine("Cognomi: ");
            StampaArray(p_arrayCognomi);
            Console.WriteLine();
            Console.WriteLine("Nomi: ");
            StampaArray(p_arrayNomi);

            Console.Write("È corretto? [S/N] ");
            scelta = Convert.ToChar(Console.ReadLine());

            switch (scelta) {
                case 'S':
                    break;

                case 'N':
                    Console.Clear();

                    do {
                        Console.Write("Modificare la lista dei nomi o dei cognomi? ");
                        correzione = Console.ReadLine();

                        if (correzione != "nomi" && correzione != "cognomi") {
                            Console.WriteLine("Opzione non valida. Inserire [nomi] o [cognomi].");
                            Pausa();
                        }
                    }
                    while (correzione != "nomi" && correzione != "cognomi");

                    Console.Clear();



                    do {
                        switch (correzione) {
                            case "nomi":
                                StampaArray(p_arrayNomi);
                                break;
                            case "cognomi":
                                StampaArray(p_arrayCognomi);
                                break;
                        }
                        Console.WriteLine();

                        Console.Write("Digitare il numero dell'elemento sbagliato: ");
                        elemento = Convert.ToUInt32(Console.ReadLine());

                        if (elemento < 0 || elemento > dimensione - 1) {
                            Console.WriteLine("Numero di elemento non valido, inserire un numero compreso tra 0 e " + (dimensione - 1));
                            Pausa();
                        }
                    }
                    while (elemento < 0 || elemento > dimensione - 1);

                    Console.Clear();

                    switch (correzione) {
                        case "nomi":
                            Console.WriteLine("Elemento precedente: " + p_arrayNomi[elemento]);
                            break;
                        case "cognomi":
                            Console.WriteLine("Elemento precedente: " + p_arrayCognomi[elemento]);
                            break;
                    }
                    Console.WriteLine();

                    Console.Write("Inserire il nuovo elemento: ");
                    switch (correzione) {
                        case "nomi":
                            p_arrayNomi[elemento] = Console.ReadLine();
                            break;
                        case "cognomi":
                            p_arrayCognomi[elemento] = Console.ReadLine();
                            break;
                    }

                    break;
                default:
                    Console.WriteLine("Opzione non valida, inserire [S] o [N]");
                    Pausa();
                    break;
            }
        }
        while (scelta != 'S');
    }
    static void CercaAlunni(string[] p_arrayCognomi, string[] p_arrayNomi) {
        Console.Clear();

        //dichiarazione e inizializzazione variabili
        string daCercare;
        int i = 0, indiceOccorrenze = 0;
        bool daCercareEsiste = false;

        const int valoreNonValido = -1;
        int[] luogoOccorrenze = new int[dimensione + 1];
        for (int j = 0; j < dimensione + 1; j++) {
            luogoOccorrenze[j] = valoreNonValido;
        }


        do {
            Console.Write("Per quale nome cercare? ");
            daCercare = Console.ReadLine();
            i = 0;
            for (; i < dimensione; i++) {
                if (p_arrayNomi[i] == daCercare) { //se daCercare è un nome che esiste
                    daCercareEsiste = true;
                    luogoOccorrenze[indiceOccorrenze] = i;
                    indiceOccorrenze++;
                }
            }

            if (!daCercareEsiste) {
                Console.WriteLine("Il nome inserito non è stato trovato nella lista dei nomi, inserire un nome valido e riprovare");
                Pausa();
            }
        }
        while (!daCercareEsiste);

        Console.Clear();

        Console.WriteLine("I cognomi che corrispondono al nome " + daCercare + " sono:");
        for (int j = 0; luogoOccorrenze[j] != valoreNonValido; j++) {
            Console.WriteLine(p_arrayCognomi[luogoOccorrenze[j]]);
        }
    }
    static string[] CreaVettore() {
        string[] ritorno = new string[dimensione];
        int i = 0, inputNumero;
        string input;
        const int minValue = 10, maxValue = 100;

        do {
            Console.Clear();
            Console.WriteLine("Hai ancora " + (dimensione - i) + " numeri da poter inserire");
            Console.Write("Inserire un numero ([q] per uscire): ");
            input = Console.ReadLine(); //non posso ancora fare il catch dell'eccezione se viene inserito un qualcosa che non sia un numero o q
            if (input != "q") {
                inputNumero = Convert.ToInt32(input);
                if (inputNumero < minValue || inputNumero > maxValue) {
                    Console.WriteLine("Il numero deve essere compreso tra " + minValue + " e " + maxValue);
                    Pausa();
                }
                else {
                    ritorno[i] = Convert.ToString(inputNumero);
                    i++;
                }
            }
        }
        while (input != "q" && i < dimensione);
        return ritorno;
    }
    static string[] RibaltaVettore(string[] p_array) {
        string[] ritorno = new string[dimensione];
        int j = dimensione - 1;

        for (int i = 0; i < dimensione; i++) {
            ritorno[i] = p_array[j];//il primo elemento di ritorno è l'ultimo di p_array e così via, i e j variano in opposto
            j--;
        }
        return ritorno;
    }
}