/**
    * This file Copyright (c) 2011 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.module.groovy.remote;
  
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.UnsupportedEncodingException;
  import java.util.ArrayList;
  import java.util.List;
  
  import org.apache.http.HttpEntity;
  import org.apache.http.HttpResponse;
  import org.apache.http.NameValuePair;
  import org.apache.http.client.ClientProtocolException;
  import org.apache.http.client.entity.UrlEncodedFormEntity;
  import org.apache.http.client.methods.HttpGet;
  import org.apache.http.client.methods.HttpPost;
  import org.apache.http.impl.client.DefaultHttpClient;
  import org.apache.http.message.BasicNameValuePair;
  import org.apache.http.protocol.HTTP;
  import org.apache.http.util.EntityUtils;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  /**
   * Remote client application connecting and executing Groovy Script against a
   * Magnolia server instance.
   * @version $Id$
   *
   */
  public class RemoteClientConsole {
  
      /*Log*/
      private static final Logger log = LoggerFactory.getLogger(RemoteClientConsole.class);
  
      /*Constants*/
      private final String logingUri = "/.magnolia/pages/adminCentral.html?";
      private final String groovyUri = "/.magnolia/pages/groovyInteractiveConsole.html?";
  
      /*Global Variable */
      private DefaultHttpClient httpclient;
      private String magnoliaUri;
      private String user;
      private String password;
  
      /**
       * Parameter constructor.
       * @param magnoliaUri: Magnolia uri like http://localhost:8080/magnolia-empty-webapp
       * @param user: Mgnolia admin user
       * @param password: Magnolia admin user password
       */
      public RemoteClientConsole(String magnoliaUri, String user, String password) {
          super();
          connect(magnoliaUri, user, password);
      }
  
      /**
       * Create a HTTP connection to the Magnolia server using a
       * HTTP Form user/password authentification mechanism.
       *
       * @param magnoliaUri: Magnolia uri like http://localhost:8080/magnolia-empty-webapp
       * @param user: Mgnolia admin user
       * @param password: Magnolia admin user password
       */
     public boolean connect(String magnoliaUri, String user, String password) {
         this.user = user;
         this.password = password;
         this.magnoliaUri = magnoliaUri;
         log.debug("set private global variable magnoliaUri='"+magnoliaUri+"', user='"+user+"', passwoed='"+password+"'");
         return connect();
      }
 
     /**
      * Create a HTTP connection to the Magnolia server using a
      * HTTP Form user/password authentification mechanism.
      */
     private boolean connect() {
         // init
         boolean res = false;
         HttpPost httpost = null;
         HttpResponse response = null;
         HttpEntity entity = null;
         log.debug("Try to connect to magnoliaUri='"+magnoliaUri);
         //If still connected, Reconnect
         if(isConnected()){
             log.warn("Still connected as we try to create a new connection. Will be disconnected first");
             disconnect();
         }
 
         try {
             httpclient = new DefaultHttpClient();
             // login post uri
             httpost = new HttpPost(this.magnoliaUri + logingUri);
             // in Parameter
             List<NameValuePair> nvps = new ArrayList<NameValuePair>();
             nvps.add(new BasicNameValuePair("mgnlUserId", this.user));
             nvps.add(new BasicNameValuePair("mgnlUserPSWD", this.password));
             httpost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
             // request post
             response = httpclient.execute(httpost);
             // check and log result
             System.out.println("Login form get: " + response.getStatusLine());
             if (response.getStatusLine().toString().endsWith("200 OK")) {
                 res = true;
                 log.debug("Correctly connected to  magnoliaUri='"+magnoliaUri);
             }else{
                 log.warn("Could not establish a connection to magnoliaUri='"+magnoliaUri);
             }
             // Consume entity
             entity = response.getEntity();
             EntityUtils.consume(entity);
 
         }
         catch (ClientProtocolException cpe) {
             log.error("", cpe);
             /*As this is called by a standalone java application, error log will also be redirect to the console*/
             cpe.printStackTrace();
         }
         catch (UnsupportedEncodingException uee) {
             log.error("", uee);
             /*As this is called by a standalone java application, error log will also be redirect to the console*/
             uee.printStackTrace();
         }
         catch (IOException ioe) {
             log.error("", ioe);
             /*As this is called by a standalone java application, error log will also be redirect to the console*/
             ioe.printStackTrace();
         }
 
         return res;
     }
 
     /**
      * Disconnect from Magnolia remote instance.
      * @return: true if correctly disconnected
      */
     public boolean disconnect() {
         boolean res = false;
         if (httpclient != null && httpclient.getConnectionManager() != null) {
             httpclient.getConnectionManager().shutdown();
             log.debug("Correctly disconnected from magnoliaUri='"+magnoliaUri);
             res = true;
         }
         return res;
     }
 
     /**
      * Check if still connected and authorized.
      * @return: true if connected and authorized
      */
     public boolean isConnected() {
         // init
         boolean res = false;
         HttpGet httpget = null;
         HttpEntity entity = null;
         try {
             httpget = new HttpGet(magnoliaUri);
             if (httpclient == null)
                 return res;
             HttpResponse response = httpclient.execute(httpget);
 
             // check if ended with 401 Unauthorized
             if (!response.getStatusLine().toString().endsWith("401 Unauthorized")) {
                 res = true;
             }
             // Consume entity
             entity = response.getEntity();
             EntityUtils.consume(entity);
 
         }
         catch (ClientProtocolException cpe) {
             log.error("",cpe);
             /*As this is called by a standalone java application, error log will also be redirect to the console*/
             cpe.printStackTrace();
         }
         catch (UnsupportedEncodingException uee) {
             log.error("",uee);
             /*As this is called by a standalone java application, error log will also be redirect to the console*/
             uee.printStackTrace();
         }
         catch (IOException ioe) {
             log.error("",ioe);
             /*As this is called by a standalone java application, error log will also be redirect to the console*/
             ioe.printStackTrace();
         }
 
         return res;
     }
 
     /**
      * Execute the Groovy script defined in the incoming file in
      * the Magnolia Groovy server environment.
      *
      * @param inputFile absolute file name
      * @return the script result as String
      */
     public String execute(Object inputObject) {
         // init
         HttpPost httpost = null;
         HttpResponse response = null;
         StringBuffer sb = new StringBuffer();
         BufferedReader rd = null;
         HttpEntity entity = null;
 
         try {
             // login post uri
             httpost = new HttpPost(magnoliaUri + groovyUri);
             // in Parameter
             List<NameValuePair> nvps = new ArrayList<NameValuePair>();
             if(inputObject instanceof File){
                 nvps.add(new BasicNameValuePair("code", readFileAsString((File)inputObject)));
             }else if(inputObject instanceof String){
                 nvps.add(new BasicNameValuePair("code", (String)inputObject));
             }else{
                 return "Input parameter is not a String or a File";
             }
             nvps.add(new BasicNameValuePair("command", "evaluateGroovy"));
             httpost.setEntity(new UrlEncodedFormEntity(nvps, HTTP.UTF_8));
             // request post
             response = httpclient.execute(httpost);
 
             // Get the output
             entity = response.getEntity();
             if (entity != null) {
                 // Get the response
                 rd = new BufferedReader(new InputStreamReader(entity.getContent()));
                 String line;
                 while ((line = rd.readLine()) != null) {
                     sb.append(line);
                 }
                 EntityUtils.consume(entity);
             }
             else {
                 sb.append("No result");
             }
 
         }
         catch (ClientProtocolException cpe) {
             log.error("",cpe);
             /*As this is called by a standalone java application, error log will also be redirect to the console*/
             cpe.printStackTrace();
         }
         catch (UnsupportedEncodingException uee) {
             log.error("",uee);
             /*As this is called by a standalone java application, error log will also be redirect to the console*/
             uee.printStackTrace();
         }
         catch (IOException ioe) {
             log.error("",ioe);
             /*As this is called by a standalone java application, error log will also be redirect to the console*/
             ioe.printStackTrace();
         }
         finally {
             if (rd != null) {
                 try {
                     rd.close();
                 }
                 catch (IOException e) {
                     /*As this is called by a standalone java application, error log will also be redirect to the console*/
                     e.printStackTrace();
                 }
             }
         }
         return sb.toString();
 
     }
 
     /**
      * Get a String representing the file content.
      * @throws java.io.IOException
      */
     private String readFileAsString(File file) throws java.io.IOException {
         StringBuffer fileData = new StringBuffer(1000);
         BufferedReader reader = null;
         try{
             reader = new BufferedReader(new FileReader(file));
             char[] buf = new char[1024];
             int numRead = 0;
             while ((numRead = reader.read(buf)) != -1) {
                 fileData.append(buf, 0, numRead);
             }
         }finally{
             reader.close();
         }
 
         return fileData.toString();
     }
 }