// fredrihl o-2

import easyIO.*; // EasyIO v4.0
import java.util.*;
//import java.io.*;


/**
 * Oblig 2 INF1010. 
 * @author fredrihl
 * @version 1
 * @param args[0] filen som skal løses
 */ 
class o2 {
	public static void main (String[] args) {
		if (args.length == 1) {
			String fil = args[0];
			Kontroll k = new Kontroll(fil);
		} else System.out.print(" * Angi fil, eks: 'java o2 sudoku.txt'n");
	} // main
} // o2




class Kontroll {

	Utsyn ut = new Utsyn();
	Brett brett;

	/**
	 * Kontruktøren i klassen Kontroll bruker angitt filnavn til å hente en slik fil og blablabla.
	 */
	Kontroll(String fil) {
	/*	Alle løsningene til en tom fil:*/

	/*/	Generere tom
		int dim=2, horz=1, vert=1;
		this.b = new Brett(dim, horz, vert);
		for(int i=0; i<dim; i++) for(int j=0; j<dim; j++) b.assign( new Rute('.', i, j, b) );
	//*/
		
	//lese fra fil
		In data = new In(fil);
		int dim = 0, hr = 0, vr = 0;
		int i = 0, id=0;
		
		//lesing
		if(!data.endOfFile()) dim = data.inInt();
		 else ut.readError();
		if(!data.endOfFile()) hr = data.inInt();
		 else ut.readError();
		if(!data.endOfFile()) vr = data.inInt();
		 else ut.readError();
		 
		brett = new Brett(dim, hr, vr);
		
		while(!data.endOfFile() && i<dim) {
			int j=0;
			while(j < dim) {
				int boks = ((id/(hr * dim)) * hr)+((id % dim) / vr);	//utregning av boks
				brett.assign(new Rute(data.inChar("n "), i, j++, boks, id++, brett) );
			}
			i++;
		} // while
		data.close();
		//*/
		brett.tilordneSektor();
		int[][] a = new int[dim][dim];
		for(int x=0; x<dim; x++)
			for(int y=0; y<dim; y++)
				a[x][y] = brett.ruter[x][y].getValue();
		ut.printBrett(a);
//		brett.bokser[2].skriv();
		brett.ruter[0][0].provAlleSifferMegOgResten(0,0);
		brett.skrivLosninger();
		System.out.print("n antalltestbrett: " +brett.antalltestbrett+"n");

	} // Kontroll()
}



// ** Modell ** //

class Brett {
	
	int dimensjon, ant_x, ant_y; //dimensjoner, antall Boks i x- og y-retning
	Rute[][] ruter;
	Sektor[] kolonner, rader, bokser;	
	ArrayList<int[][]> losninger = new ArrayList<int[][]>();
	int antalltestbrett = 0;
	
	Brett(int dimensjon, int ant_x, int ant_y) {
		this.ruter = new Rute[dimensjon][dimensjon];
		this.dimensjon = dimensjon;
		this.ant_x = ant_x;
		this.ant_y = ant_y;
		this.kolonner = new Kol[dimensjon];
		this.rader = new Rad[dimensjon];
		this.bokser = new Boks[dimensjon];
		for(int i=0; i<dimensjon; i++) {
			kolonner[i] = new Kol();
			rader[i] = new Rad();
			bokser[i] = new Boks();
		}
	}

	public void assign(Rute r) {
		int[] koo = r.sektor();
		this.ruter[koo[0]][koo[1]] = r; 
	}
	
	public void tilordneSektor() {
		for(Rute rt[]: ruter) {
			for(Rute r: rt){
				int[] koo = r.sektor();
				this.kolonner[koo[0]].assign(r);
				this.rader[koo[1]].assign(r);
				this.bokser[koo[2]].assign(r);
			}
		}
	}
		
	
	public int giDim() {
		return this.dimensjon;
	}
	
	
	
	public void addLosning(Rute[][] l) {
		int[][] losning = new int[dimensjon][dimensjon];
		for(int x=0; x<dimensjon; x++)
			for(int y=0; y<dimensjon; y++)
				losning[x][y] = ruter[x][y].getValue();
		this.losninger.add(losning);
	}
	
		
	public void skrivLosninger() {
		for(int[][] l: losninger) Utsyn.printBrett(l);
	}
	
}

/**
 * Generell superklasse for de forskjellige sektorene på brettet
 */
class Sektor {
	ArrayList<Rute> verdier = new ArrayList<Rute>();

	public void assign(Rute r) {
		this.verdier.add(r);
	}
	public boolean unique(int value) {
		boolean finnes = false;
		for(Rute r: verdier) if(r.getValue() == value) finnes = true;
		return !finnes;
	}
	void skriv() {
		for(Rute r: verdier) System.out.print("mongo: "+r.getValue() + " ");
	}
}

class Rad extends Sektor {
	//nothing
}

class Kol extends Sektor {
//
}

class Boks extends Sektor {

}

class Rute {

	int value, id;
	int kol, rad, boks, dim;
	Brett br; // brukes i den rekursive metoden.
	
	Rute(char c, int x, int y, int boks, int id, Brett br) {	
		this.value = toNumber(c);
		this.boks = boks;
		this.id = id;
		this.kol = x;
		this.rad = y;
		this.dim = br.giDim();
		this.br = br;
	}
	
	public int getValue() {
		return this.value;
	}
	public void setValue(int v) {
		this.value = v;
	}
	
	public int[] sektor() {
		int[] k = {kol,rad,boks};
		return k;
	}
	
	private static int toNumber(char c) {
		int value;
		value = Character.digit(c, 36);
		if(value == -1) value = 0;	//Usatt verdi = 0
		return value;
	}
	
	public void provAlleSifferMegOgResten(int x, int y) {

		boolean alle=false;

		y++;
		if (y == dim) {
		    y = 0;
		    x++;
		    if (x == dim)
			alle = true;
		} //slutt if
		
		if (value == 0) {
			for(int v=1; v<dim; v++) {
				if(br.kolonner[kol].unique(v) && br.rader[rad].unique(v) && br.bokser[boks].unique(v)){
					setValue(v);
					if(alle) {
						br.addLosning(br.ruter);
						br.antalltestbrett++;
						alle = false;
					} else br.ruter[x][y].provAlleSifferMegOgResten(x,y);
				}
			}//for()
			setValue(0);
		} else {
		
			if(alle) {
				br.addLosning(br.ruter);
				alle = false;
			} else br.ruter[x][y].provAlleSifferMegOgResten(x,y);
		}
	
	} //provalle


}


/**
 * Kontroll setter i gang sirkuset.
 */


class Utsyn {

	private static char toChar(int value) {
		char c = Character.forDigit(value, 36);		
		if(value==-1) c = '-';
		return c;
	}

	static void readError() {
		System.out.print(" ** Error: Det har oppstått en feil under lesing av fil.n");
	}
	
	static void printBrett(int[][] brett) {
		String out = "";
		for(int[] rad: brett) {
			for(int r: rad) {
				out += toChar(r) + "  ";
			}
			out += "n";
		}
		System.out.println(out);
	}
	
}