//This file is part of SECONDO.

//Copyright (C) 2004, University in Hagen, Department of Computer Science, 
//Database Systems for New Applications.

//SECONDO is free software; you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation; either version 2 of the License, or
//(at your option) any later version.

//SECONDO is distributed in the hope that it will be useful,
//but WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//GNU General Public License for more details.

//You should have received a copy of the GNU General Public License
//along with SECONDO; if not, write to the Free Software
//Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

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

import jpl.JPL;
import jpl.Atom;
import jpl.Query;
import jpl.Term;
import jpl.Variable;
import jpl.fli.*;
import jpl.Compound;
import jpl.Util;


public class OptimizerServer extends Thread{

static {
    System.loadLibrary( "jpl" );
    System.loadLibrary("regSecondo");
  }


  public static native int registerSecondo();
   


   /** shows a prompt at the console
     */
    private static void showPrompt(){
       System.out.print("\n opt-server > ");
    }


    /** init  prolog
      * register the secondo predicate
      * loads the optimizer prolog code
      */
    private boolean initialize(){
      // later here is to invoke the init function which
      // registers the Secondo(command,Result) predicate to prolog
    if(registerSecondo()!=0){
       System.err.println("error in registering the secondo predicate ");
       return false;
    }
    try{
      System.out.println("call JPL.init()");
      JPL.init();
      System.out.println("initialisation successful");

      // VTA - 18.09.2006
      // I added this piece of code in order to run with newer versions
      // of prolog. Without this code, the libraries (e.g. lists.pl) are
      // not automatically loaded. It seems that something in our code
      // (auxiliary.pl and calloptimizer.pl) prevents them to be
      // automatically loaded. In order to solve this problem I added
      // a call to 'member(x, [x]).' so that the libraries are loaded
      // before running our scripts.
      Term[] args = new Term[2];
      args[0] = new Atom("x");
      args[1] = jpl.Util.termArrayToList( new Term[] { new Atom("x") } );
      Query q = new Query("member",args);
      if(!q.query()){
         System.out.println("error in the member call'");
         return false;
      }

      args = new Term[1];
      args[0] = new Atom("auxiliary");
      q = new Query("consult",args);
      if(!q.query()){
         System.out.println("error in loading 'auxiliary.pl'");
         return false;
      }

      args = new Term[1];
      args[0] = new Atom("calloptimizer");
      q = new Query("consult",args);
      if(!q.query()){
         System.out.println("error in loading 'calloptimizer.pl'");
         return false;
       }
       return true;
     } catch(Exception e){
          System.out.println("Exception in initialization "+e);
          return false;
     }
    }


    /** invokes a prolog predicate
      * all terms in variables must be contained in arguments
      * variables and results can be null if no result is desired
      */
    synchronized private static boolean command(Query pl_query, NamedVariable[] variables,Vector results){
      if(pl_query==null)
         return false;
      try{
         if(trace){
           System.out.println("execute query: "+pl_query);
         }
         String ret ="";
         int number =0; // the number of solutions
         if(results!=null)
            results.clear();
         while(pl_query.hasMoreSolutions(Prolog.Q_NODEBUG)){
            number++;
            Hashtable solution = pl_query.nextSolution();
            if(results!=null){
               ret = "";
               if(variables==null || variables.length==0)
                   results.add("yes");
               else{
                  for(int i=0;i<variables.length;i++){
                      NamedVariable P = variables[i];
                      if (i>0) ret += " $$$ ";
                      ret += ( P.getName() + " = " + solution.get(P.getVariable()));
                  }
                  results.add(ret);
               }
            }
         }
         if(number == 0){
            if(trace)
               System.out.println("no solution found for' "+pl_query.atom() +"/"+pl_query.args().length);
            return false;
         } else{
             // check if a new database is opened
             Variable X = new Variable();
             
             Query dbQuery = new Query("databaseName",X);
             Hashtable sol = dbQuery.oneSolution();
             if(sol==null){
                System.out.println("Error in getting database name ");
                return false;
             }
             String name = sol.get(X).toString();  
             if(!name.equals(openedDatabase)){
                 if(trace){
                   System.out.println("use database "+name);
                 }
                 openedDatabase = name;
             }
             return true;
        }
        } catch(Exception e){
           if(trace)
              System.out.println("exception in calling the "+pl_query.atom()+"-predicate"+e);
           return false;
        }
    }


    /** analyzed the given string and extract the command and the argumentlist
      * <br> then the given command is executed
      * all Solutions are stored into the Vector Solution
      */
    private synchronized static boolean execute(String command,Vector Solution){
          if(Solution!=null)
              Solution.clear();
              
          // clients should not have the possibility
          // to shut down the Optimizer-Server
          command = command.trim();
          if(command.startsWith("halt ") || command.equals("halt"))
             return false;

          Vector TMPVars = new Vector();
          if(trace){
            System.out.println("analyse command: "+command);
          }
          Query pl_query = Parser.parse(command,TMPVars);
          if(pl_query==null){
             if(trace)
                System.out.println("error in parsing command: "+command);
             return  false;
          }

          NamedVariable[] variables = new NamedVariable[TMPVars.size()];
          for(int i=0;i<TMPVars.size();i++)
               variables[i] = (NamedVariable) TMPVars.get(i);

          boolean res = command(pl_query,variables,Solution);

          if(res & trace & Solution!=null){ // successful
             if(Solution.size()==0)
                System.out.println("Yes");
             else
               for(int i=0;i<Solution.size();i++){
                 System.out.println("*** Solution "+(i+1)+"  ****");
                 System.out.println(Solution.get(i));
               }

          }
          return res;
     }



    /** return the optimized query
      * if no optimization is found, query is returned
      * otherwise the result will be the best query plan
      */
    private synchronized String optimize(String query){
      try{
          if(trace)
               System.out.println("\n optimization-input : "+query+"\n");
          Term[] args = new Term[2];
          Variable X = new Variable();
          args[0] = new Atom(query);
          args[1] = X;
          Query pl_query = new Query(new Atom("sqlToPlan"),args);

          String ret ="";
          int number =0;
          while(pl_query.hasMoreSolutions(Prolog.Q_NODEBUG)){
                number++;
                Hashtable solution = pl_query.nextSolution();
                // ret = ret+" "+solution.get(X);
                ret = ""+solution.get(X);
          }
          if(number==0){
             if(trace)
                 System.out.println("optimization failed - no solution found");
             return query;
          }
          else{
             if(trace)
                 System.out.println("\n optimization-result : "+ret+"\n");
             return ret;
          }
         } catch(Exception e){
             if(trace)
                System.out.println("\n Exception :"+e);
             showPrompt();
           return  query;
         }

    }

    /** if Name is not the database currenty used,
      * the opened database is closed and the database
      * Name is opened
      */
    private synchronized boolean useDatabase(String Name){
       if(openedDatabase.equals(Name))
          return true;
       Term[] arg = new Term[1];
       if(!openedDatabase.equals("")){
          if(trace)
             System.out.println("close the opened database");
          arg[0] = new Atom("close database");
          Query Q = new Query(new Atom("secondo"),arg);
          command(Q,null,null);
       }
       
       arg[0] = new Atom("open database "+Name);
       Query Q_open = new Query(new Atom("secondo"),arg);
       showPrompt();
       return command(Q_open,null,null);
   }



   /** a class for communicate with a client */
   private class Server extends Thread{

      /** creates a new Server from given socket */
      public Server(Socket S){
         this.S = S;
         //System.out.println("requesting from client");
         try{
            in = new BufferedReader(new InputStreamReader(S.getInputStream()));
            out = new BufferedWriter(new OutputStreamWriter(S.getOutputStream()));
            String First = in.readLine();
            //System.out.println("receive :"+First);
            if(First==null){
               if(trace)
                  System.out.println("connection broken");
                showPrompt();
                running=false;
                return;
            }
            if(First.equals("<who>")){
               out.write("<optimizer>\n",0,12);
               out.flush();
               running = true;
             }else{
                if(trace)
                   System.out.println("protocol-error , close connection (expect: <who>, received :"+First);
                showPrompt();
                running = false;
             }
         }catch(Exception e){
             if(trace){
                System.out.println("Exception occured "+e);
                e.printStackTrace();
             }
             showPrompt();
             running = false;
         }
      }

      /** disconnect this server from a client */
      private void disconnect(){
        // close Connection if possible
        try{
           if(S!=null)
              S.close();
        }catch(Exception e){
            if(trace){
               System.out.println("Exception in closing connection "+e);
               e.printStackTrace();
            }
        }
        OptimizerServer.Clients--;
        if(trace){
           System.out.println("\nbye client");
           System.out.println("number of clients is :"+ OptimizerServer.Clients);
        }
        showPrompt();
      }




       /**  processes requests from clients until the client
        *  finish the connection or an error occurs
        */
      public void run(){
         if(!running){
           disconnect();
           return;
         }

         boolean execFlag=false; // flags for control execute or optimize request
         try{
             String input = in.readLine();
             if(input==null){
                if(trace)
                   System.out.println("connection is broken");
                disconnect();
                return;
             }
             while(!input.equals("<end connection>")){

               if(!input.equals("<optimize>") && !input.equals("<execute>") ){ // protocol_error
                   if(trace)
                      System.out.println("protocol error( expect: <optimize> or <execute> , found:"+input);
                   disconnect();
                   return;
               }
               execFlag = input.equals("<execute>");
               // read the database name
               input = in.readLine();
               if(input==null){
                  if(trace)
                     System.out.println("connection is broken");
                  disconnect();
                  return;
               }
               if(!input.equals("<database>")){ // protocol_error
                  if(trace)
                     System.out.println("protocol error( expect: <database> , found:"+input);
                  disconnect();
                  return;
               }
               String Database = in.readLine();
               if(Database==null){
                  System.out.println("connection is broken");
                  disconnect();
                  return;
               }else {
                 Database = Database.trim();
               }
               input = in.readLine();
               if(input==null){
                if(trace)
                   System.out.println("connection is broken");
                disconnect();
                return;
               }else{
                 input = input.trim();
               }
               if(!input.equals("</database>")){ // protocol error
                   if(trace)
                      System.out.println("protocol error( expect: </database> , found:"+input);
                   disconnect();
                   return;
               }
               input = in.readLine();
               if(input==null){
                if(trace)
                   System.out.println("connection is broken");
                disconnect();
                return;
                }else{
                  input = input.trim();
                }
               if(!input.equals("<query>")){ // protocol error
                   if(trace)
                        System.out.println("protocol error( expect: <query> , found:"+input);
                    disconnect();
                   return;
               }

               StringBuffer res = new StringBuffer();
               // build the query from the next lines
               input = in.readLine();
               //System.out.println("receive"+input);
               if(input==null){
                if(trace)
                   System.out.println("connection is broken");
                disconnect();
                return;
               }
               while(!input.equals("</query>")){
                  res.append(input + "\n");
                  input = in.readLine();
                  //System.out.println("receive"+input);
                  if(input==null){
                    if(trace)
                       System.out.println("connection is broken");
                    disconnect();
                    return;
                  }
               }

               input = in.readLine();
               if(input==null){
                  System.out.println("connection is broken");
                  disconnect();
                  return;
               }

               if(! (input.equals("</optimize>") & !execFlag)  & !(input.equals("</execute>") & execFlag)){ //protocol-error
                   if(trace)
                     System.out.println("protocol error( expect: </optimize> or </execute>, found:"+input);
                   disconnect();
                   return;
               }

               String Request = res.toString().trim();
               Vector V = new Vector();
               synchronized(SyncObj){
                  useDatabase(Database);
                  if(!execFlag){
                         String opt = OptimizerServer.this.optimize(Request);
                      if(!opt.equals(Request))
                         V.add(opt);
                  }else{
                     execute(Request,V);
                  }
               }

               showPrompt();

               out.write("<answer>\n",0,9);
               String answer;
               for(int i=0;i<V.size();i++){
                  answer = (String) V.get(i);
                  out.write(answer+"\n",0,answer.length()+1);
               }
               out.write("</answer>\n",0,10);
               out.flush();
               input = in.readLine().trim();
               if (input==null){
                    System.out.println("connection broken");
                  showPrompt();
                  disconnect();
                  return;
               }
             } // while
             System.out.println("connection ended normally");
             showPrompt();
           }catch(IOException e){
              System.out.println("error in socket-communication");
              disconnect();
              showPrompt();
              return;
           }
             disconnect();
         }

      private BufferedReader in;
      private BufferedWriter out;
      private boolean running;
      private Socket S;
    }



   /** creates the server process */
   private boolean createServer(){
     SS=null;
     try{
        SS = new ServerSocket(PortNr);
     } catch(Exception e){
       System.out.println("unable to create a ServerSocket");
       e.printStackTrace();
       return false;
     }
     return true;
   }

   /**  waits for request from clients
    *   for each new client a new socket communicationis created
    */
   public void run(){
      System.out.println("\nwaiting for requests");
      showPrompt();
      while(running){
       try{
           Socket S = SS.accept();
           Clients++;
           if(trace){
               System.out.println("\na new client is connected");
               System.out.println("number of clients :"+Clients);
               showPrompt();
           }
           (new Server(S)).start();
          } catch(Exception e){
         System.out.println("error in communication");
         showPrompt();
       }
     }

   }



   /** creates a new server object
     * process inputs from the user
     * available commands are
     * client : prints out the number of connected clients
     * quit   : shuts down the server
     */
   public static void main(String[] args){
       if(args.length<1){
        System.err.println("usage:  java OptimizerServer -classpath .:<jplclasses> OptimizerServer  PortNumber");
              System.exit(1);
       }
       // process options
       Runtime rt = Runtime.getRuntime();
       int pos = 1;
       while(pos<args.length){
           if(args[pos].equals("-trace_methods")){
               rt.traceMethodCalls(true); 
               System.out.println("enable method tracing");
               pos++;
           } else if(args[pos].equals("-trace_instructions")){
               rt.traceInstructions(true);
               System.out.println("enable instruction tracing");
               pos++;
           } else{
               System.out.println("unknown option " + args[pos]);
               System.exit(-1);
           }
       }





       System.out.println("\n\n");
       printLicence(System.out);
       System.out.println("\n");
       String arg = args[0];
       OptimizerServer OS = new OptimizerServer();
       try{
          int P = Integer.parseInt(arg);
          if(P<=0){
            System.err.println("the Portnumber must be greater then zero");
            System.exit(1);
          }
          OS.PortNr=P;
        }catch(Exception e){
          System.err.println("the Portnumber must be an integer");
          System.exit(1);
       }

       try{
         Class.forName("jpl.fli.Prolog"); // ensure to load the jpl library
        } catch(Exception e){
           System.err.println("loading prolog class failed");
           System.exit(1);
        }

       if(! OS.initialize()){
          System.out.println("initialization failed");
          System.exit(1);
       }
       if(!OS.createServer()){
         System.out.println("creating Server failed");
         System.exit(1);
       }
       OS.running = true;
       OS.start();
       try{
         BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
         System.out.print("optserver >");
         String command = "";
         Vector ResVector = new Vector();
         while(!command.equals("quit")){
           command = in.readLine().trim();
           if(command.equals("clients")){
              System.out.println("Number of Clients: "+ Clients);
           }else if(command.equals("quit")){
              if( Clients > 0){
                 System.out.print("clients exists ! shutdown anyway (y/n) >");
                 String answer = in.readLine().trim().toLowerCase();
                 if(!answer.startsWith("y"))
                     command="";
              }
           } else if(command.equals("trace-on")){
               trace=true;
               System.out.println("tracing is activated");
           } else if(command.equals("trace-off")){
               trace=false;
               System.out.println("tracing is deactivated");
           } else if(command.equals("help") | command.equals("?") ){
                System.out.println("quit      : quits the server ");
                System.out.println("clients   : prints out the number of connected clients");
                System.out.println("trace-on  : prints out messages about command, optimized command, open database");
                System.out.println("trace-off : disable messages");
           } else if(command.startsWith("exec")){
             String cmdline = command.substring(4,command.length()).trim();
             execute(cmdline,ResVector);
           }else{
              System.out.println("unknow command, try help show a list of valid commands");
           }
           if(!command.equals("quit"))
              showPrompt();

         }
         OS.running = false;
       }catch(Exception e){
          OS.running = false;
          System.out.println("error in reading commands");
          if(trace)
             e.printStackTrace();
       }
       try{
          JPL.halt();
       } catch(Exception e){
          System.err.println(" error in shutting down the prolog engine");
       }

   }


   /** Prints out the licence information of this software **/
   public static void printLicence(PrintStream out){
       out.println(" Copyright (C) 2004, University in Hagen, ");
       out.println(" Department of Computer Science,  ");
       out.println(" Database Systems for New Applications. \n");

       out.println(" This is free software; see the source for copying conditions.");
       out.println(" There is NO warranty; not even for MERCHANTABILITY or FITNESS ");
       out.println(" FOR A PARTICULAR PURPOSE.");
   }


   private static PrologParser Parser = new PrologParser();
   private boolean optimizer_loaded = false;
   private int PortNr = 1235;
   private static int Clients = 0;
   private ServerSocket SS;
   private boolean running;
   private static String openedDatabase ="";
   private static boolean trace = true;
   private static Object SyncObj = new Object();

}