package G4ip;

import pizza.util.Hashtable;

import java.util.Vector;

import G4ip.Form.*;

import G4ip.ProofDisplay.*;

import G4ip.Sequent.*;

/** The Gi4p prover.<p>

  * The prover is a thread in order to suspend the proof search

  * after one proof is found and to let the user make a choice 

  * of whether to stop or to continue with the proof search.

  * @author Christian Urban

  */

public class Prover extends Thread

{ ProverApplet  parent;  // the parent of the prover;

  boolean once;          // if true then at least one proof was found

  Sequent sequ;          // the root sequent to be proved

  Vector  frames;        // to record all frames which have been opened

  int index ;

  Hashtable<int,Sequent> proof;      // keeps a record of the proof

  /** The constructor creates a prover which proves a specific sequent.<p>

    * The parameter parent is for access to the applet buttons.

    */

  public Prover(Sequent init_sequ, ProverApplet init_parent) {

    super("Prover");

    parent = init_parent;

    once   = false;

    sequ   = new Sequent(init_sequ);

    frames = new Vector();

    index  = 1;

    proof  = new Hashtable();

  }

  /** Starts the thread; calls prove and stops the thread when 

    * the proof search is finished.

    */

  public void run()

    { prove(1,sequ,initial_sc); 

      if (once == true) { 

	parent.messages.setText("No more proofs.");

	parent.messages.repaint();

	parent.repaint();

      }

      else { 

	parent.messages.setText("Not provable.");

	parent.messages.repaint();

        parent.repaint();	

      }

      parent.switch_into_input_mode();

      this.stop();     // everything is done, stop the thread

    } 

  /** Closes all frames which have been opened.

    */

  public void finalize() { 

    for (int i=0; i<frames.size();i++) { 

      if (frames.elementAt != null) 

	{ ((ProofDisplay)frames.elementAt(i)).dispose(); }

    }

  }

  /** The tactic of the proof search.<p>

    * Method prove first enumerates all formulae on the LHS        

    * as being the principal formula and attempts to apply left-rules,  

    * subsequently it analyses the goal formula.                     

    */ 

  public void prove(int index, Sequent is,(() -> void) sc)  {

    Form principal;

    proof.put(index,new Sequent(is));      // add sequence to proof

    rightrules(index,is,sc);

    for (int i=0;i<is.Gamma.size();i++) {

      principal = (Form)is.Gamma.elementAt(i);

      is.Gamma.removeElement(principal);       // Gamma minus principal formula

      leftrules(index,principal,is,sc);

      is.Gamma.insertElementAt(principal,i);   // put principal formula

    }                                          // back into Gamma 

    //rightrules(index,is,sc);

    proof.remove(index);                   // remove sequence from proof

  }

  /** Analyses the goal formula. 

    */

  public void rightrules(int index, Sequent sequ,(()  -> void) sc)  {

    Context Gamma = sequ.Gamma;

    switch(sequ.G) { 

                          /** And-R

			    *  Gamma => A    Gamma => B  

			    * --------------------------   

			    *      Gamma => A and B     

			    */

    case And(Form A,Form B): 

      prove(2*index,new Sequent(Gamma,A),

            fun() -> void { prove(2*index+1,new Sequent(Gamma,B),sc); }  ); 

      break;

                          /** Imp-R  

			    *   Gamma,A => B   

			    * ----------------- 

			    *  Gamma => A imp B     

			    */ 

    case Imp(Form A,Form B):

      prove(2*index,new Sequent(Gamma.add(A),B),sc); break;

                           /** Or-R 

			     *   Gamma  => A           Gamma => B   

			     * ----------------- or -----------------  

			     *  Gamma => A or B      Gamma => A or B   

			     */

    case Or(Form A,Form B):

      prove(2*index,new Sequent(Gamma,A),sc);

      prove(2*index,new Sequent(Gamma,B),sc); break;

                           /** Equ-R

			     *  Gamma => A -> B  Gamma => B -> A 

			     * -------------------------------- 

			     *          Gamma => A <-> B         

			     */ 

    }

  }

  /** Analyses the principal formula on the LHS. 

    */

  public void leftrules(int index,Form principal,Sequent sequ,(() -> void) sc){

    Context Gamma = sequ.Gamma;

    Form    G     = sequ.G;

    switch(principal) {

                          /** false-L

			    * --------------------  

                            *  false, Gamma => G     

			    */

    case False():  sc(); break;

                           /** Axiom

      			     *  ---------------                  

      			     *   Gamma, G => G     G being atomic 

      			     */

    case Atm(String c):

      if (G instanceof Atm) {

	if (((Atm)G).c.compareTo(c) == 0) { sc(); }

      }

      break;

                          /** And-L

			    *   Gamma, A, B => G    

                            * -------------------- 

                            *  Gamma, A and B => G     

			    */

    case And(Form A, Form B): 

      prove(2*index,new Sequent(Gamma.add(A,B),G),sc); break;

                          /** Or-R

			    *  Gamma, A => G   Gamma, B => G 

                            * ------------------------------- 

                            *      Gamma, A or B => G      

			    */ 

    case Or(Form A, Form B):

      prove(2*index,new Sequent(Gamma.add(A),G),

	    fun() -> void {prove(2*index+1,new Sequent(Gamma.add(B),G),sc);});

      break;

                          /** Imp-L 2         

			    *  Gamma, A imp (B imp C) => G  

                            * ------------------------------

                            *  Gamma, (A and B) imp C => G    

                            */

    case Imp(And(Form A, Form B), Form C):

      prove(2*index,new Sequent(Gamma.add(Imp(A,Imp(B,C))),G),sc); break; 

                          /** Imp-L 3       

                            *  Gamma, (A imp C), (B imp C) => G 

                            * ----------------------------------

                            *   Gamma, (A or B) imp C => G       

			    */

    case Imp(Or(Form A, Form B), Form C):  

      prove(2*index,new Sequent(Gamma.add(Imp(A,C),Imp(B,C)),G),sc); break; 

                          /** Imp-L 4 

			    *  Gamma, (B imp C) => (A imp B)    Gamma, C => G 

                            * ------------------------------------------------

                            *         Gamma, (A imp B) imp C => G                

			    */

    case Imp(Imp(Form A, Form B), Form C): 

      prove(2*index,new Sequent(Gamma.add(Imp(B,C)),Imp(A,B)),

	    fun() -> void { prove(2*index+1,new Sequent(Gamma.add(C),G),sc);});

      break;  

                          /** Imp-L 1         

			    *   Gamma(A), B => G          A being atomic       

                            * ------------------------    Gamma(A) means:

                            *  Gamma(A), A imp B => G     Gamma contains A

			    */ 

    case Imp(Form A, Form B):

      if (A instanceof Atm) { 

	if (Gamma.includes(A)) {

	  { prove(2*index,new Sequent(Gamma.add(B),G),sc); }

	}

      }

      break;    

    }

  }

  /** The initial success continuation. 

    * Suspends the thread when a proof is found. 

    */

  public void initial_sc()  {  

    once = true;

    ProofDisplay p = new ProofDisplay(proof);

    frames.addElement(p);       // keep a record for later disposal

    try {                       // suspend the proof search, 

    suspend(); }           // it might be resumed later on  by the user

    catch(SecurityException sec_exc)

      { /* this catch is neccessary for Netscape 3.0 (Linux) */ }

  }  

}