/src/es/uned/genTest/ComputationalLogic/wrapperProver9Mace4/SingletonProver9.java

package es.uned.genTest.ComputationalLogic.wrapperProver9Mace4;



import java.io.*;

import java.util.*;



import es.uned.genTest.ComputationalLogic.PCLogicClausifyFormula;

import es.uned.genTest.ComputationalLogic.PCLogicFormula;

import es.uned.genTest.ComputationalLogic.PCLogicListClausifyFormula;

import es.uned.genTest.ComputationalLogic.PCLogicListProofs;



/**

 * Implementa la gestión de fórmulas lógicas mediante la aplicación externa

 * Prover9

 * 

 * @author Joaquín Campillo Molina - jcampillomolina@hotmail.com, Febrero/2012

 * @version 1.0

 */

public class SingletonProver9 {

	static private SingletonProver9 singletonProver9 = new SingletonProver9();

	static private String time = "";

	private final int EXIT_FALSE = 0;

	private final int EXIT_TRUE = 1;

	private final int EXIT_ERROR = 2;

	private PCLogicListClausifyFormula listClausifyFormula = new PCLogicListClausifyFormula();

	private PCLogicListProofs proofs = new PCLogicListProofs();



	private SingletonProver9() {

	}



	static public SingletonProver9 getSingletonProver9() {

		return singletonProver9;

	}



	public boolean exec(List<PCLogicFormula> assumptions,

			List<PCLogicFormula> goals, String path) {

		readPropertiesFile();

		boolean result = false;

		int resultProver9 = EXIT_ERROR;

		while (resultProver9 == EXIT_ERROR) {

			// Modificación 25/02/2012 para evitar mostrar resoluciones

			// repetidas

			this.listClausifyFormula.clear();

			this.proofs.clear();

			resultProver9 = execProver9(assumptions, goals, path);

		}

		if (resultProver9 == EXIT_FALSE)

			result = false;

		else

			result = true;

		return result;

	}



	private int execProver9(List<PCLogicFormula> assumptions,

			List<PCLogicFormula> goals, String path) {

		Iterator<PCLogicFormula> iter = null;

		StringBuffer out = new StringBuffer();

		try {

			boolean findProof = false;

			String formulas = "formulas(assumptions).\n";

			iter = assumptions.iterator();

			while (iter.hasNext())

				formulas = formulas + iter.next().getFormula() + ".\n";

			formulas = formulas + "end_of_list.\n";

			formulas = formulas + "formulas(goals).\n";

			iter = goals.iterator();

			while (iter.hasNext())

				formulas = formulas + iter.next().getFormula() + ".\n";

			formulas = formulas + "end_of_list.\n";

			File file = new File(path + "input.in");

			if (!file.exists()) {

				file.createNewFile();

			}

			FileWriter inputProver9 = new FileWriter(file.getName());

			BufferedWriter bufferedWriter = new BufferedWriter(inputProver9);

			bufferedWriter.write(formulas);

			bufferedWriter.close();



			Process p = Runtime.getRuntime().exec(

					path + "prover9.exe -t " + time + " -f " + path

							+ "input.in");

			// Se obtiene el stream de salida del programa

			InputStream is = p.getInputStream();

			/*

			 * Se prepara un bufferedReader para poder leer la salida más

			 * comodamente.

			 */

			BufferedReader br = new BufferedReader(new InputStreamReader(is));

			// Se lee la primera linea

			String aux = br.readLine();

			if (aux == null) {

				return EXIT_ERROR;

			}

			out.append(aux + "\n");

			String clausify = "";

			String order = "";

			String charac = "";

			String references = "";

			Boolean findOrder;

			PCLogicClausifyFormula pcLogicClausifyFormula = null;

			// Mientras se haya leido alguna linea

			// while (!aux.contains("exit")) { -- Esta es otra opción a tener en

			// cuenta

			while (!aux.contains("proofs=")) {

				// Descomentar la siguiente linea para visualizar resultados

				// prover9

				// System.out.println (aux);

				if (aux.contains("PROCESS NON-CLAUSAL FORMULAS")) {

					aux = br.readLine();

					while (!aux.contains("end of process non-clausal formulas")) {

						aux = br.readLine();

						if (aux.contains("assumption")) {

							findOrder = false;

							order = "";

							int i = 0;

							clausify = "";

							while (i < aux.trim().length()

									&& !aux.trim().substring(i, i + 1).equals(

											"#")) {

								charac = aux.trim().substring(i, i + 1);

								while (Character.isDigit(aux.charAt(i))

										&& !findOrder) {

									order = order + charac;

									i++;

									charac = aux.trim().substring(i, i + 1);

								}

								if (!order.equals("") && !findOrder)

									findOrder = true;

								clausify = clausify + charac;

								i++;

							}

							this.proofs.putProof(Integer.parseInt(order),

									clausify.trim(), "Premisa");

						}

					}

				}

				if (aux.contains("PROCESS INITIAL CLAUSES")) {

					aux = br.readLine();

					String assumptionTreated;

					String assumptionInCurse;

					while (!aux.contains("formulas(sos)."))

						aux = br.readLine();

					aux = br.readLine();

					while (!aux.contains("end_of_list.")) {

						pcLogicClausifyFormula = new PCLogicClausifyFormula();

						if (aux.contains("assumption")) {

							int i = 0;

							clausify = "";

							while (i < aux.trim().length()

									&& !aux.trim().substring(i, i + 1).equals(

											".")) {

								clausify = clausify

										+ aux.trim().substring(i, i + 1);

								i++;

							}

							pcLogicClausifyFormula.putClausify(clausify);

							pcLogicClausifyFormula.putAssumption(true);

							aux = br.readLine();

						} else {

							assumptionTreated = aux.trim().substring(

									aux.trim().length() - 4,

									aux.trim().length() - 3);

							assumptionInCurse = assumptionTreated;

							while (assumptionInCurse.equals(assumptionTreated)

									&& !aux.contains("end_of_list.")) {

								int i = 0;

								clausify = "";



								while (i < aux.trim().length()

										&& !aux.trim().substring(i, i + 1)

												.equals(".")) {

									clausify = clausify

											+ aux.trim().substring(i, i + 1);

									i++;

								}

								pcLogicClausifyFormula.putClausify(clausify);

								aux = br.readLine();

								assumptionInCurse = aux.trim().substring(

										aux.trim().length() - 4,

										aux.trim().length() - 3);

							}

						}

						this.listClausifyFormula

								.putClausifyFormula(pcLogicClausifyFormula);

					}

				}

				if (aux.contains("CLAUSES FOR SEARCH")) {

					aux = br.readLine();

					while (!aux.contains("end_of_list")) {

						aux = br.readLine();

						if (aux.contains("clausify")) {

							findOrder = false;

							order = "";

							int i = 0;

							clausify = "";

							while (i < aux.trim().length()

									&& !aux.trim().substring(i, i + 1).equals(

											".")) {

								charac = aux.trim().substring(i, i + 1);

								while (Character.isDigit(aux.charAt(i))

										&& !findOrder) {

									order = order + charac;

									i++;

									charac = aux.trim().substring(i, i + 1);

								}

								if (!order.equals("") && !findOrder)

									findOrder = true;

								clausify = clausify + charac;

								i++;

							}

							this.proofs.putProof(Integer.parseInt(order),

									clausify.trim(), "Claúsula de la premisa "

											+ aux.trim().substring(

													aux.trim().length() - 4,

													aux.trim().length() - 3));

						}

					}

				}

				if (aux.contains("PROOF") && !findProof) {

					findProof = true; // Por si hubiera más de una prueba se

					// elige la primera

					aux = br.readLine();

					while (!aux.contains("end of proof")) {

						aux = br.readLine();

						if (aux.contains("clausify")) {

							findOrder = false;

							order = "";

							int i = 0;

							clausify = "";

							while (i < aux.trim().length()

									&& !aux.trim().substring(i, i + 1).equals(

											".")) {

								charac = aux.trim().substring(i, i + 1);

								while (Character.isDigit(aux.charAt(i))

										&& !findOrder) {

									order = order + charac;

									i++;

									charac = aux.trim().substring(i, i + 1);

								}

								if (!order.equals("") && !findOrder)

									findOrder = true;

								clausify = clausify + charac;

								i++;

							}

							this.proofs.putProof(Integer.parseInt(order),

									clausify.trim(), "Claúsula de la premisa "

											+ aux.trim().substring(

													aux.trim().length() - 4,

													aux.trim().length() - 3));

						} else if (aux.contains("$F")) {

							findOrder = false;

							order = "";

							int i = 0;

							clausify = "";

							references = "";

							while (i < aux.trim().length()

									&& !aux.trim().substring(i, i + 1).equals(

											".")) {

								charac = aux.trim().substring(i, i + 1);

								while (Character.isDigit(aux.charAt(i))

										&& !findOrder) {

									order = order + charac;

									i++;

									charac = aux.trim().substring(i, i + 1);

								}

								if (!order.equals("") && !findOrder)

									findOrder = true;

								clausify = clausify + charac;

								i++;

							}

							i++;

							// Se buscan las referencias a la dedución en curso

							while (i < aux.trim().length()

									&& !aux.trim().substring(i, i + 1).equals(

											".")) {

								charac = aux.trim().substring(i, i + 1);

								while (Character.isDigit(aux.charAt(i))) {

									references = references + charac;

									i++;

									charac = aux.trim().substring(i, i + 1);

									if (!Character.isDigit(aux.charAt(i)))

										references = references + ",";

								}

								i++;

							}

							this.proofs.putProof(Integer.parseInt(order),

									"[ ]", "Claúsula vacía ("

											+ references.substring(0,

													references.length() - 1)

											+ ")");

						} else if ((aux.contains("[") && !aux

								.contains("assumption"))) {

							findOrder = false;

							order = "";

							int i = 0;

							clausify = "";

							references = "";

							while (i < aux.trim().length()

									&& !aux.trim().substring(i, i + 1).equals(

											".")) {

								charac = aux.trim().substring(i, i + 1);

								while (Character.isDigit(aux.charAt(i))

										&& !findOrder) {

									order = order + charac;

									i++;

									charac = aux.trim().substring(i, i + 1);

								}

								if (!order.equals("") && !findOrder)

									findOrder = true;

								clausify = clausify + charac;

								i++;

							}

							i++;

							// Se buscan las referencias a la dedución en curso

							while (i < aux.trim().length()

									&& !aux.trim().substring(i, i + 1).equals(

											".")) {

								charac = aux.trim().substring(i, i + 1);

								while (Character.isDigit(aux.charAt(i))) {

									references = references + charac;

									i++;

									charac = aux.trim().substring(i, i + 1);

									if (!Character.isDigit(aux.charAt(i)))

										references = references + ",";

								}

								i++;

							}

							this.proofs.putProof(Integer.parseInt(order),

									clausify.trim(), " ("

											+ references.substring(0,

													references.length() - 1)

											+ ")");

						}

					}

				}

				// La siguiente línea se puede descomentar si se quiere

				// visualizar la salida de prover9

				// Interesante para hacer depuraciones

				// System.out.println(aux);

				aux = br.readLine();

				if (aux == null) {

					return EXIT_ERROR;

				}



				out.append(aux + "\n");



			}

		} catch (IOException e) {

			System.out.println(e.getMessage());

			if (e.getMessage().contains("Cannot run program \"prover9.exe\"")) {

				System.out

						.println("Finalizada la ejecucion. Revise la instalación.");

				System.exit(-1);

			}

		} catch (Exception e) {

			// Excepciones si hay algún problema al arrancar el ejecutable o al

			// leer su salida.*/

			System.out.println(e.toString());

			// e.printStackTrace();

			// return EXIT_ERROR;



		}

		// System.out.println(out);

		// if (out.toString().contains("Exiting with failure.")) {-- Es otra

		// posibilidad que se utilizó pero se ha demostrado más eficiente

		// consultar por proofs

		if (out.toString().contains("proofs=0")) { // Es satisfacible

			return EXIT_FALSE;



		} else { // Es insatisfacible

			return EXIT_TRUE;

		}



	}



	public PCLogicListProofs getProofs() {

		this.proofs.reNumberProofs();

		return this.proofs;

	}



	public PCLogicListClausifyFormula getClausifyFormulas() {

		return this.listClausifyFormula;

	}



	private static void readPropertiesFile() {

		final String PROP_FILE = "./properties/configuration.properties";



		try {

			InputStream is = new FileInputStream(PROP_FILE);

			Properties prop = new Properties();

			prop.load(is);

			time = prop.getProperty("tiempoProver9");

			is.close();



		} catch (Exception e) {

			System.out.println("No se ha podido abrir el fichero " + PROP_FILE);

		}

	}

}