package matrice;

import java.util.ArrayList;
import java.util.Iterator;

public class MatriceSparsa<T> implements Iterable<T> {

    protected ArrayList<Record<T>>[] valori;
    private int numRighe;
    private int numColonne;
    private T defaultValue;
    @Override
    public Iterator<T> iterator() {
        return new IteratoreMatriceSparsa<>(valori);
    }


    /**
     * Crea una nuova matrice di dimensione righe x colonne fissando il valore di default.
     * @param righe il numero di righe della matrice
     * @param colonne il numero di colonne della matrice
     * @param valore il valore di default.
     */
    public void creaMatrice(int righe, int colonne, T valore){
        this.numColonne = colonne;
        this.numRighe = righe;
        this.defaultValue = valore;

        valori =  new ArrayList[righe];

        for(int i = 0; i < valori.length; i++){
            valori[i] = new ArrayList<Record<T>>();
            for(int j = 0; j < colonne; j++){
                Record<T> defaultValue = new Record<T>(valore, j);
                valori[i].add(defaultValue);
            }
        }
    }

    public void cambiaValore(int riga, int colonna, T valore){

        if(riga > numRighe || colonna > numColonne) throw new EccezionePosInesistente("La posione non esiste.");
        ArrayList<Record<T>> rigaDesiderata = valori[riga];
        Record<T> recordDesiderato = rigaDesiderata.get(colonna);
        recordDesiderato.valore = valore;
    }

    public T valore(int riga, int colonna){
        if(riga > numRighe || colonna > numColonne) throw new EccezionePosInesistente("La posione non esiste.");
        ArrayList<Record<T>> rigaDesiderata = valori[riga];
        Record<T> recordDesiderato = rigaDesiderata.get(colonna);
        return recordDesiderato.valore;
    }

    public int numRighe(){
        return numRighe;
    }

    public int numColonne(){
        return numColonne;
    }

    public int numValoriSignificativi(){
        int counter = 0;

        for(int i = 0; i < numRighe; i++){
            for(int j = 0; j < numColonne; j++){
                Record tmp = valori[i].get(j);
                T valoreTmp = (T) tmp.valore;
                if(valoreTmp != defaultValue)
                    counter++;
            }
        }
        return counter;
    }


    private class Record<E>{
        E valore;
        int colonna;

        public Record(E valore, int colonna){
            this.valore = valore;
            this.colonna = colonna;
        }
    }

    private class IteratoreMatriceSparsa<T> implements Iterator<T> {

        ArrayList<Record<T>>[] matrice;
        private int numRighe = matrice.length;
        private int colonna = 0;
        private int riga = 0;

        public IteratoreMatriceSparsa(ArrayList<Record<T>>[] matrice) {
            this.matrice = matrice;
        }

        @Override
        public boolean hasNext() {
            return riga < numRighe;
        }

        @Override
        public T next() {

            T elem = (T) matrice[riga].get(colonna).valore;
            colonna++;

            if(colonna == matrice[riga].size()){
                colonna = 0;
                riga++;
            }
            return elem;
        }
    }

    public static void main(String[] args) {

        MatriceSparsa<String> matrice = new MatriceSparsa<String>();
        matrice.creaMatrice(2, 2, "0");
//      matrice.cambiaValore(1, 1, "cazzo!");

        System.out.println(matrice.numValoriSignificativi());

        Iterator iter = matrice.iterator();
        while(iter.hasNext()){
            System.out.println(iter.next());
        }
    }

}