package server;

import java.io.*;
import java.net.*;
import java.util.Collections;
import java.util.LinkedList;

import client.NoConsistentEpsException;
import client.NoConsistentMinSupException;
import client.ServerException;
import server.data.Data;
import server.data.EmptySetException;
import server.database.DBAccess;
import server.database.DatabaseConnectionException;
import server.keyboardinput.Keyboard;
import server.mining.ClosedPatternArchive;
import server.mining.ClosedPatternMiner;
import server.mining.FrequentPattern;
import server.mining.FrequentPatternMiner;
import server.utility.LinkList;
import server.utility.Puntatore;

public class Server {
	public static final int PORT = 8080;
	public static void main(String[] args)throws IOException, ServerException{
		ServerSocket ss = new ServerSocket(PORT); // Il Server si mette in ascolto sulla porta 8080
		System.out.println("Server Avviato: " + ss);

		String choice = ""; // Operazione scelta sul client
		String table_name = "";
		float minSup = 0F;
		float eps = 0F;
		String path = "";

		try{
			// Il server accetta la connessione
			Socket socket = ss.accept();
			// La connessione è avvenuta

			BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			PrintWriter pout = new PrintWriter( new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())),true);

			try{
				System.out.println("Connessione accettata: " + socket);

				//Ricevo la scelta effettuata sul menu
				choice = in.readLine();
				System.out.println("Ricevuto da Client: " + choice);


				//Se si richiede la scoperta di pattern chiusi allora si richiedono gli altri valori
				if(choice.equals("1")){
					//Invio la stringa e ricevo il nome della tabella
					pout.println("Inserire nome tabella");
					table_name = in.readLine();
					System.out.println("Tabel_name: " + table_name);

					//Il server richiede il valore di minSup
					pout.println("Inserire il valore di minSup");
					minSup = Float.parseFloat(in.readLine()); //La stringa ricevuta viene convertita in Float e assegnata a minSup
					do{
					if(minSup<= 0 || minSup >1){
							pout.println("Inserire nuovamente il valore di minSup"); //Se il valore non è lecito manda questa stringa e il client deve rimandare il valore di minSup
							minSup = Float.parseFloat(in.readLine());
					}
					}while(minSup <= 0 || minSup > 1);
					System.out.println("minSup: " + minSup);

					//Il Server richiede il valore di eps e lo riceve dal client
					pout.println("Inserire il valore di eps");
					eps = Float.parseFloat(in.readLine()); //La stringa ricevuta viene convertita in Float e assegnata a minSup
					do{
					if(eps<= 0 || eps >1){
							pout.println("Inserire nuovamente il valore di eps"); //Se il valore non è lecito manda questa stringa e il client deve rimandare il valore di minSup
							eps = Float.parseFloat(in.readLine());
					}
					}while(eps <= 0 || eps > 1);
					System.out.println("esp: " + eps);

					//Il Server richiede il nome del file più estensione su cui salvare (Si assume di salvare sul workspace)
					pout.println("Inserire il nome del file su cui salvare");
					path = in.readLine();
					System.out.println("path: " + path);

					//Il Server fornisce il servizio di scoperta di pattern chiusi
					try{
						if (DBAccess.initConnection() == false)
							throw new DatabaseConnectionException();
						else{
							Data data = new Data(table_name); //Carico la matrice

							// Scoperta patten frequenti
							LinkList outputFP = FrequentPatternMiner.frequentPatternDiscovery(data, minSup);

							// Copio i pattern frequenti in una LinkedList che mi
							// servirà per la scoperta di pattern chiusi
							LinkedList<FrequentPattern> out = new LinkedList<FrequentPattern>();
							Puntatore p = outputFP.firstList();
							int i = 1;
							while (!outputFP.endList(p)) {
								FrequentPattern FP = (FrequentPattern) outputFP.readList(p);
								out.add(FP); // copia nella lista
								// System.out.println(i + ":" + FP); // stampa di
								// pattern
								// frequenti
								p = outputFP.succ(p);
								i++;
							}

							Collections.sort(out);// ordinamento della lista di pattern
													// frequenti

							// calcolo dei pattern chiusi
							ClosedPatternArchive archivio = ClosedPatternMiner.closedPatternDiscovery(out, eps);
							//System.out.print(archivio); // stampa pattern chiusi

							if(archivio == null) throw new ServerException();

							// salvataggio
							try{
							ClosedPatternArchive.salvataggio(archivio, path);
							}catch (IOException e) {
								System.err.println("Errore nel salvataggio");
							}
							pout.println("END");
						}
					}catch (DatabaseConnectionException e) {
						System.err.println("Errore caricamento driver");
					}catch (EmptySetException e) {
						System.err.println("Matrice vuota");
					}


				}

				else if(choice.equals("2")){
					try{
					pout.println("Inserire il nome del file con estensione");
				    path = in.readLine();
				    System.out.println("Ricevo dal client il nome del file: " +path);

				    File file = new File(path);
				    if(!(file.exists())){
				    	pout.println("File non trovato");
				    }
				     ClosedPatternArchive ar = ClosedPatternArchive.caricamento(path);
				    } catch (IOException exc) {
				     System.err.println("Errore nel caricamento, archivio non trovato");
				    } catch (Exception e) {
				     e.getMessage();
				    }
				}

				pout.println("END"); //Chiudo il ciclo su client

			}finally{
				socket.close();
			}
		}
		finally {
			System.out.println("closing...");
			ss.close();
		}
	}
}