package preparazione_esame;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;

public class Esame13 {

	public static void main(String[] args) {
		ArrayList<int[][]> matrici = new ArrayList<>();
		try (BufferedReader br = new BufferedReader(new FileReader("src/preparazione_esame/esame13.txt"));
				PrintWriter pw1 = new PrintWriter(new FileWriter("esame13-1.txt"));
				PrintWriter pw2 = new PrintWriter(new FileWriter("esame13-2.txt"));
				PrintWriter pw3 = new PrintWriter(new FileWriter("esame13-3.txt"));
				PrintWriter pw4 = new PrintWriter(new FileWriter("esame13-4.txt"));
				PrintWriter pw5 = new PrintWriter(new FileWriter("esame13-5.txt"))) {
			String line = br.readLine();
			String[] rigaString;
			int nRighe = 0; // per far star zitto il compilatore, siamo sicuri che avrà un valore
			ArrayList<int[]> righe = null; // per far star zitto il compilatore, siamo sicuri che avrà un valore
			int[] rigaInt = null; // per far star zitto il compilatore, siamo sicuri che avrà un valore
			int[][] matrice;
			int r;
			boolean in = false; // sto dentro una matrice?
			boolean out = true; // sono fuori dalla matrice?
			while (line != null) {
				if (!line.isEmpty()) { // stiamo leggendo una riga della matrice
					if (out) {
						in = true;
						out = false;
						nRighe = 0;
						righe = new ArrayList<>(); // mi serve una lista espandibile, non so quante righe avrà la matrice
					}
					nRighe++;
					rigaString = line.trim().split(","); // ora so il numero di colonne della matrice corrente
					rigaInt = new int[rigaString.length];
					for (int i = 0; i < rigaString.length; i++) {
						rigaInt[i] = Integer.parseInt(rigaString[i].trim());
					}
					righe.add(rigaInt);
				} else if (in) {
					in = false;
					out = true;
					matrice = new int[nRighe][rigaInt.length]; // solo ora posso creare la matrice, perche solo ora ho nRighe
					r = 0;
					for (int[] riga : righe) {
						matrice[r] = riga;
						r++;
					}
					matrici.add(matrice);
				}
				line = br.readLine();
			}
			if (in) {
				matrice = new int[nRighe][rigaInt.length]; // solo ora posso creare la matrice, perche solo ora ho nRighe
				r = 0;
				for (int[] riga : righe) {
					matrice[r] = riga;
					r++;
				}
				matrici.add(matrice);
			}
			// punto 1
			System.out.println("punto 1)\n----------\n");
			for (int[][] mat : matrici) {
				Esame13.visualizzaMatrice(mat);
				Esame13.stampaMatrice(mat, pw1);
			}
			// punto 2
			System.out.println("punto 2)\n----------\n");
			int sum;
			int maxSum = Integer.MIN_VALUE;
			int maxSumMat = 0; // per far star zitto il compilatore, siamo sicuri che avrà un valore
			for (int i = 0; i < matrici.size(); i++) {
				sum = 0;
				for (int[] riga : matrici.get(i)) {
					for (int val : riga) {
						sum += val;
					}
				}
				if (sum > maxSum) {
					maxSum = sum;
					maxSumMat = i;
				}
			}
			System.out.println("La matrice a somma massima " + maxSum + " e':");
			Esame13.visualizzaMatrice(matrici.get(maxSumMat));
			pw2.println("La matrice a somma massima " + maxSum + " e':");
			Esame13.stampaMatrice(matrici.get(maxSumMat), pw2);
			// punto 3
			System.out.println("punto 3)\n----------\n");
			int temp;
			for (int[][] mat : matrici) {
				if (mat.length == mat[0].length) {
					for (int i = 0; i < mat.length; i++) {
						for (int j = 0; j < mat[0].length; j++) {
							if (i == j) { // diagonale principale
								temp = mat[i][j];
								mat[i][j] = mat[i][mat.length - 1 - j]; // corrispondente elemento sulla diagonale secondaria
								mat[i][mat.length - 1 - j] = temp;
							}
						}
					}
					System.out.println("La matrice a scambiata e'");
					Esame13.visualizzaMatrice(mat);
					pw3.println("La matrice a scambiata e'");
					Esame13.stampaMatrice(mat, pw3);
				}
			}
			// punto 4
			System.out.println("punto 4)\n----------\n");
			int[] colonna;
			ArrayList<int[]> colonne;
			int[] altraColonna;
			ArrayList<int[]> altreColonne;
			boolean ok;
			int nOk;
			for (int[][] mat : matrici) {
				colonne = new ArrayList<>();
				for (int i = 0; i < mat[0].length; i++) {
					colonna = new int[mat.length]; // necessario per evitare side effects dovuti al passaggio per copia di valori e riferimenti!
					for (int j = 0; j < mat.length; j++) {
						colonna[j] = mat[j][i];
					}
					colonne.add(colonna);
				}
				// solo ora ho l'elenco delle colonne della matrice 'mat' in 'colonne'
				for (int[][] altraMat : matrici) {
					if (!mat.equals(altraMat)) {
						/*
						 * come sopra, ma su 'altraMat'
						 */
						altreColonne = new ArrayList<>();
						for (int i = 0; i < altraMat[0].length; i++) {
							altraColonna = new int[altraMat.length];
							for (int j = 0; j < altraMat.length; j++) {
								altraColonna[j] = altraMat[j][i];
							}
							altreColonne.add(altraColonna);
						}
						// solo ora ho l'elenco delle colonne della matrice 'altraMat' in 'altreColonne'
						if (colonne.size() == altreColonne.size()) { // anzitutto le colonne devono essere lunghe uguali
							nOk = 0;
							for (int[] c : colonne) { // per ogni colonna di 'mat'...
								for (int[] aC : altreColonne) { // ...devo controllare in ogni colonna di 'altraMat'...
									ok = true;
									for (int i = 0; i < c.length; i++) {
										if (c[i] != aC[i]) { // ...che i valori siano uguali
											/*
											 * appena ne becco uno diverso, posso passare a un'altra colonna di 'altreColonne'
											 */
											ok = false;
											break;
										}
									}
									if (ok) { // se tutti i valori erano uguali 'ok' e' ancora 'true'...
										nOk++; // ...dunque mi ricordo che una colonna di 'mat' ha una corrispondenza in 'altraMat'...
										break; // ...e posso smettere di cercarne altre uguali in 'altraMat'
									}
								}
							}
							/*
							 * solo ora ho controllato tutte le colonne di 'mat'
							 */
							if (nOk == colonne.size()) { // se le colonne di 'mat' erano N devo aver trovato N colonne uguali per poter stampare
								System.out.println("Le due matrici seguenti hanno le stesse colonne (anche se in ordine diverso)");
								Esame13.visualizzaMatrice(mat);
								Esame13.visualizzaMatrice(altraMat);
								pw4.println("Le due matrici seguenti hanno le stesse colonne (anche se in ordine diverso)");
								Esame13.stampaMatrice(mat, pw4);
								Esame13.stampaMatrice(altraMat, pw4);
							}
						}
					}
				}
			}
			// punto 5
			System.out.println("punto 5)\n----------\n");
			sum = 0;
			maxSum = Integer.MIN_VALUE;
			int maxMat = 0; // per far star zitto il compilatore, siamo sicuri che avrà un valore
			int maxR = 0; // per far star zitto il compilatore, siamo sicuri che avrà un valore
			for (int k = 0; k < matrici.size(); k++) {
				matrice = matrici.get(k);
				for (int i = 0; i < matrice.length; i++) {
					for (int j = 0; j < matrice[0].length; j++) {
						sum += matrice[i][j];
					}
					if (sum > maxSum) {
						maxSum = sum;
						maxMat = k;
						maxR = i;
					}
				}
			}
			System.out.println("La riga di somma massima si trova nella matrice " + maxMat + ", riga " + maxR);
			pw5.println("La riga di somma massima si trova nella matrice " + maxMat + ", riga " + maxR);
		} catch (

		FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	private static void stampaMatrice(int[][] matrice, PrintWriter pw) {
		for (int i = 0; i < matrice.length; i++) {
			for (int j = 0; j < matrice[0].length; j++) {
				pw.print(matrice[i][j] + " ");
			}
			pw.println();
		}
		pw.println("\n----------\n");
	}

	private static void visualizzaMatrice(int[][] matrice) {
		for (int i = 0; i < matrice.length; i++) {
			for (int j = 0; j < matrice[0].length; j++) {
				System.out.print(matrice[i][j] + " ");
			}
			System.out.println();
		}
		System.out.println("\n----------\n");
	}

}