eurovision 2/2

import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

/**
 * Classe pais que conté el nom, la puntuació i una taula dels vots que
 * guarda els punts que dona i a qui se'ls dona.
 *
 * @author copaPiston
 */
class Pais {

    String nom;
    int puntuacio;
    int vots[][] = new int[10][2];
}

/**
 * Genera l'objecte pais, i crida les funcions perque el programa s'inicii.
 *
 * @author copaPiston
 */
public class Main{

    public static void main(String[] args) {
        int opc;
        final int L = 26;
        Pais[] pais = new Pais[L];

        for (int i = 0; i < pais.length; i++) {
            pais[i] = new Pais();
        }
        generacioPunts(pais);
        do {
            opc = menu();
            opcions(opc, pais);

        } while (opc != 0);
        System.out.println("Adeu!!");
    }

    /**
     * Llegim els paisos.
     *
     * @param pais generam els paissos que participaran en aquesta votació.
     */
    public static void carregarPaisos(Pais[] pais) {
        int i=0;
        File fitxer = new File ("paisos.txt");
        try{
            Scanner entradaF = new Scanner(fitxer);
            if(fitxer.exists()){
                while(entradaF.hasNext() && i<26){
                    String nom= entradaF.next();
                    System.out.println(nom);
                    pais[i].nom=nom;
                    i++;
                }
                entradaF.close();
            }else{
                System.out.println("Aquest fitxer no existeix");
            }
        }catch(IOException ex){
            System.out.println("Hi ha errors");
        }

    }


    public static void edicioAny(Pais[] pais){
        Scanner entrada = new Scanner(System.in);
        char opcio;
        int any;

        System.out.print("A quin any correspon aquesta votació: ");
        any=entrada.nextInt();
        File eurovisio = new File ("eurovisio"+any+".txt");

        System.out.print("Vols desar aquesta votació: ");
        opcio=entrada.next().charAt(0);
        opcio=Character.toLowerCase(opcio);

        if(opcio=='s'){
            if (eurovisio.exists()) {
                System.out.println("El fitxer ja existeix");
            } else {
                try {
                    PrintWriter sortida = new PrintWriter(eurovisio);
                    for (int i = 0; i < pais.length; i++) {
                        sortida.print(pais[i].nom+" "+pais[i].puntuacio);
                        for (int j = 0; j < 10; j++) {
                            sortida.print(" "+pais[i].vots[j][0]);
                        }
                        for (int j = 0; j < 10; j++) {
                            sortida.print(" "+pais[i].vots[j][1]);
                        }
                        sortida.println();

                    }
                    sortida.close();
                } catch (IOException ex) {
                    System.out.println("Hi ha hagut algun error amb el fitxer");
                }
            }
        }
    }


    public static void consultarVictorias(){
        Scanner entrada = new Scanner(System.in);
        int victorias=0;
        String nompais;
        System.out.println("De quin pais vols saber les victories que té?");
        nompais = entrada.nextLine();

        File edicions = new File ("edicions.txt");
        try{
            Scanner entradaF = new Scanner(edicions);
            if(edicions.exists()){
                while(entradaF.hasNext()){
                    int edicio= entradaF.nextInt();
                    File eurovisio = new File ("eurovisio"+edicio+".txt");

                    Scanner entradaE = new Scanner(eurovisio);
                    if (eurovisio.exists()) {
                            String nom = entradaE.next();
                            System.out.println("El pais " + nom + " va guanyar la edicio de l'any" + edicio);
                            if (nompais.equals(nom)) {
                                victorias++;
                            }

                        entradaE.close();
                    } else {
                        System.out.println("No hi ha concurs per a l'any "+edicio);
                    }


                }
                entradaF.close();
                System.out.println("El pais "+nompais+" ha guanyat "+victorias+" vegades");
            }else{
                System.out.println("Aquest fitxer no existeix");
            }
        }catch(IOException ex){
            System.out.println("Hi ha errors");
        }



    }

    /**
     * Mostra per pantalla el menu, demana i després retorna l'opció.
     *
     * @return retorna l'opció escollida.
     */
    public static int menu() {
        Scanner entrada = new Scanner(System.in);
        int opc = 100;

        do {
            System.out.print("\n   MENU\n____________\n1. Simular votació\n"
                    + "2. Consultar victories d'un pais\n3. A qui ha votat\n4. Qui l'ha votat\n0. Sortir\nOpcio: ");
            opc = entrada.nextInt();
        } while (opc < 0 || opc > 5);

        return opc;
    }


    /**
     * Comprova si es la primera edició del concurs en aquesta execució del programa
     *
     * @param pais classe pais, amb el nom, la puntuació rebuda, vots donats i paisos a qui se'ls dona.
     * @return retorna un valor 1 o 0 per comprovar si aquesta és la primera edició o si no.
     */
    public static int primeraEdicio(Pais[] pais) {
        int primer = 1;
        for (int i = 0; i < pais.length; i++) {
            if (pais[i].puntuacio != 0) {
                primer = 0;
            }
        }
        return primer;
    }

    /**
     * Segons l'opció escollida anem a un mètode diferent.
     *
     * @param opc reb l'opció escollida, segons la qual actuarà d'una manera distinta per cada opció.
     * @param pais
     */
    public static void opcions(int opc, Pais[] pais) {
        Scanner entrada = new Scanner(System.in);
        int primer, opcPrimer;

        switch (opc) {
            case 1:
                primer = primeraEdicio(pais);
                if (primer == 1) {
                    carregarPaisos(pais);
                    comencarVots(pais);
                    edicioAny(pais);
                } else {
                    System.out.print("Vols iniciar la nova votació amb els mateixos països, diferents o sortir? [1=Mateixos 2=Diferents");
                    opcPrimer = entrada.nextInt();
                    if (opcPrimer == 2) {
                        carregarPaisos(pais);
                        comencarVots(pais);
                        edicioAny(pais);
                    } else if (opcPrimer == 1) {
                        comencarVots(pais);
                        edicioAny(pais);
                    }
                }
                break;
            case 2:
                consultarVictorias();
                break;
            case 3:
                aQuiVota(pais);
                break;
            case 4:
                quiLhaVotat(pais);
                break;
            case 0:
                break;
            default:
                System.out.println("Opcio incorrecta torna a provar!");
        }
    }

    /**
     *assigna els punts que poden donar els paisos a una filera d'una taula
     *
     * @param pais classe pais, amb el nom, la puntuació rebuda, vots donats i paisos a qui se'ls dona.
     */
    public static void generacioPunts(Pais[] pais) {
        for (int i = 0; i < pais.length; i++) {
            pais[i].vots[0][1] = 1;
            pais[i].vots[1][1] = 2;
            pais[i].vots[2][1] = 3;
            pais[i].vots[3][1] = 4;
            pais[i].vots[4][1] = 5;
            pais[i].vots[5][1] = 6;
            pais[i].vots[6][1] = 7;
            pais[i].vots[7][1] = 8;
            pais[i].vots[8][1] = 10;
            pais[i].vots[9][1] = 12;
        }
    }

    /**
     * Comença la votació
     *
     * @param pais classe pais, amb el nom, la puntuació rebuda, vots donats i paisos a qui se'ls dona.
     */
    public static void comencarVots(Pais[] pais) {

        for (int i = 0; i < pais.length; i++) {
            pais[i].puntuacio = 0;
        }
        for (int i = 0; i < pais.length; i++) {
            for (int j = 0; j < 10; j++) {
                boolean comprovat = false;

                pais[i].vots[j][0] = (int) (Math.random() * 26);

                for (int l = 0; l < j && j > 0; l++) {
                    if (pais[i].vots[j][0] == pais[i].vots[l][0] || pais[i].vots[j][0] == i) {
                        j--;
                        comprovat = true;
                    }
                }
                if (comprovat == false) {
                    pais[pais[i].vots[j][0]].puntuacio += pais[i].vots[j][1];
                }
            }
            mostrarClassificacio(pais);
        }
    }

    /**
     * Ordena la classificació de paisos de més votat a menys votat, amb possibilitat d'empats.
     *
     * @param pais classe pais, amb el nom, la puntuació rebuda, vots donats i paisos a qui se'ls dona.
     * @return retorna un auxiliar per poder detectar posteriorment si n'hi han empats.
     */
    public static int[][] ordenarClassificacio(Pais[] pais) {
        String auxNom;
        int auxPunts;
        int auxIndice;
        int auxVots[][] = new int[pais.length][2];

        for (int i = 0; i < pais.length; i++) {
            auxVots[i][0] = i;
            for (int j = 0; j < pais.length; j++) {
                auxVots[j][1] = pais[j].puntuacio;
            }
        }

        for (int i = 0; i < auxVots.length; i++) {
            for (int j = i + 1; j < auxVots.length; j++) {
                if (auxVots[i][1] < auxVots[j][1]) {
                    auxIndice = auxVots[i][0];
                    auxPunts = auxVots[i][1];
                    auxVots[i][0] = auxVots[j][0];
                    auxVots[i][1] = auxVots[j][1];
                    auxVots[j][0] = auxIndice;
                    auxVots[j][1] = auxPunts;
                }
            }
        }
        return auxVots;
    }

    /**
     * Comprova si n'hi ha algun empat, i en cas de que hi hagi mira segons les normes qui té més vots 12, i després 10.
     *
     * @param auxVots auxiliar per comprovar si n'hi han empats.
     * @param pais classe pais, amb el nom, la puntuació rebuda, vots donats i paisos a qui se'ls dona.
     */
    public static void mirarEmpats(int auxVots[][],Pais[]pais) {
        int mesvotat1 = 0, mesvotat2 = 0, mesdotze1 = 0, mesdotze2 = 0, mesdeu1 = 0, mesdeu2 = 0;
        int auxPunts;
        int auxIndice;

        for (int i = 0; i < auxVots.length - 1; i++) {
            if (auxVots[i][1] == auxVots[i + 1][1]) {
                for (int j = 0; j < pais.length - 1; j++) {
                    for (int k = 0; k < pais[j].vots.length - 1; k++) {
                        if (pais[j].vots[k][0] == auxVots[i][1]) {
                            mesvotat1++;
                        } else if (pais[j].vots[k + 1][0] == auxVots[i + 1][1]) {
                            mesvotat2++;
                        }
                        if (pais[j].vots[k][0] == 12) {
                            mesdotze1++;
                        } else if (pais[j].vots[k + 1][0] == 12) {
                            mesdotze2++;
                        }
                        if (pais[j].vots[k][0] == 10) {
                            mesdeu1++;
                        } else if (pais[j].vots[k + 1][0] == 10) {
                            mesdeu2++;
                        }
                    }
                }
            }

            if (mesvotat2 > mesvotat1) {
                desempats(i,auxVots);
            } else if (mesvotat1 == mesvotat2) {
                if (mesdotze2 > mesdotze1) {
                    desempats(i,auxVots);
                } else if (mesdotze1 == mesdotze2) {
                    if (mesdeu2 > mesdeu1) {
                        desempats(i,auxVots);
                    } else if (mesdeu1 == mesdeu2) {

                    }
                }
            }
        }
    }

    /**
     *Ordena segons les normes, els paissos empatats.
     *
     * @param i reb l'índex per canviar l'ordre dels empatats.
     * @param auxVots reb l'auxiliar per canviar l'ordre dels empatats.
     */
    public static void desempats(int i, int auxVots[][]){
        int auxIndice, auxPunts;
        auxIndice = auxVots[i][0];
        auxPunts = auxVots[i][1];
        auxVots[i][0] = auxVots[i + 1][0];
        auxVots[i][1] = auxVots[i + 1][1];
        auxVots[i + 1][0] = auxIndice;
        auxVots[i + 1][1] = auxPunts;
    }

    /**
     * Mostra la classificació ordenada i sense empats.
     *
     * @param pais classe pais, amb el nom, la puntuació rebuda, vots donats i paisos a qui se'ls dona.
     */
    public static void mostrarClassificacio(Pais[] pais) {
        int auxVots[][] = ordenarClassificacio(pais);
        mirarEmpats(auxVots,pais);
        System.out.println("Puntuació:");
        for (int i = 0; i < 12; i++) {

            System.out.printf("├────┬───────────────────────────────────┬────────┬────┬───────────────────────────────────┤\n"
                            + "│ %3d│%-18S %3d             │        │ %3d│%-18S %3d             │ \n"
                            + "├────┴───────────────────────────────────┴────────┴────┴───────────────────────────────────┤\n"
                            + "\033[30m│ \033[41m                                                                                        \033[30m │\033[30m\n", i + 1, pais[auxVots[i][0]].nom, auxVots[i][1], i + 13, pais[auxVots[i + 13][0]].nom, auxVots[i + 13][1]);
            if (i + 14 == pais.length - 1) {
                System.out.printf("├────┬───────────────────────────────────┬────────┬────┬───────────────────────────────────┤\n"
                                + "│    │                                   │        │ %3d│%-18S %3d             │ \n"
                                + "└────┴───────────────────────────────────┴────────┴────┴───────────────────────────────────┘\n", 25, pais[auxVots[i + 14][0]].nom, auxVots[i + 14][1]);
            }
        }
    }

    /**
     * Llegeix per teclat un pais, per després buscarlo i mostrar a qui vota.
     *
     * @param pais classe pais, amb el nom, la puntuació rebuda, vots donats i paisos a qui se'ls dona.
     */
    public static void aQuiVota(Pais[] pais){
        Scanner entrada = new Scanner(System.in);
        String buscarpais;
        System.out.printf("\nIntrodueix el nom del pais que vols buscar: ");
        buscarpais=entrada.nextLine();
        for (int i = 0; i < pais.length; i++) {
            if(buscarpais.equalsIgnoreCase(pais[i].nom)){
                System.out.printf("\nEl pais %s amb %d punts ha votat a:",pais[i].nom,pais[i].puntuacio);
                for (int j = 0; j < pais[i].vots.length; j++) {
                    System.out.printf("\n%d punts per a %s",pais[i].vots[j][1],pais[pais[i].vots[j][0]].nom);

                }
                i=pais.length;
            }
        }
    }

    /**
     * Llegeix per teclat un pais, per després burcarlo i mostrar qui l'ha votat.
     *
     * @param pais classe pais, amb el nom, la puntuació rebuda, vots donats i paisos a qui se'ls dona.
     */
    public static void quiLhaVotat(Pais[] pais){
        Scanner entrada = new Scanner(System.in);
        String buscarpais;
        System.out.printf("\nIntrodueix el nom del pais que vols buscar: ");
        buscarpais=entrada.nextLine();
        for (int i = 0; i < pais.length; i++) {
            for (int j = 0; j < pais[i].vots.length; j++) {
                if(buscarpais.equalsIgnoreCase(pais[pais[i].vots[j][0]].nom)){
                    System.out.printf("\nEl pais %s l'ha votat amb %d punts",pais[i].nom,pais[i].vots[j][1]);
                }
            }
        }
    }
}