/******************************************************************************
*
* Licensed Materials - Property of IBM
*
* (C) COPYRIGHT IBM Corp. 2006
*
* US Government Users Restricted Rights - Use, duplication or
* disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
*
*
*****************************************************************************/

package itimtools;

import java.rmi.*;
import java.util.*;

import com.ibm.itim.apps.*;
import com.ibm.itim.apps.exception.AppProcessingException;
import com.ibm.itim.apps.jaas.callback.*;
import com.ibm.itim.apps.provisioning.*;
import com.ibm.itim.apps.recon.*;
import com.ibm.itim.apps.search.*;
import com.ibm.itim.dataservices.model.*;
import com.ibm.itim.dataservices.model.domain.*;
import com.ibm.itim.remoteservices.exception.RemoteServicesException;

import javax.security.auth.*;
import javax.security.auth.login.*;

/**
 * Command-line Java class to run a recon immediately for services
 * of a certain profile (mandatory) and a specific service (optional)
 *
 * Usage :
 *   RunRecon ?serviceprofile:ADProfile  [?servicename:AD-F01301]
 * 
**/
public class RunRecon { 

   private static final String LOGIN_CONTEXT   = "ITIM";

   /**
    * Command line argument names (prefixed by "-")
    */
   private static final String SERVICE_PROFILE    = "serviceprofile";
   private static final String SERVICE_NAME       = "servicename";
   private static String SERVICE_FILTER;

   /**
    * Timeout = 5 minutes, wait time = 30 seconds
    */
   private static int TIMEOUT = 300000;
   private static int TIMETOWAIT = 30000;
   private static int counter = 0;
   private static int iteration = 0;

   private static String[] requestStatus = new String[5];   
   /**
    * main method.
    */
   public static void main(String[] args) {

       Hashtable arguments = parseArgs(args);

       try {
           String contextFactory = System.getProperty("apps.context.factory");

           String appServerUrl   = System.getProperty("apps.server.url");
           String ejbUser        = System.getProperty("apps.ejb.user");
           String ejbPswd        = System.getProperty("apps.ejb.pswd");
           String itimUser       = System.getProperty("itim.user");
           String itimPswd       = System.getProperty("itim.pswd");
           String tenantId       = System.getProperty("tenant.id");
           String ldapServerRoot = System.getProperty("ldapserver.root");

           System.out.println("\n Server URL " + appServerUrl + " ejbUser = " + ejbUser + "\n");

           Hashtable env = new Hashtable();
           env.put(InitialPlatformContext.CONTEXT_FACTORY, contextFactory);
           env.put(PlatformContext.PLATFORM_URL, appServerUrl);
           env.put(PlatformContext.PLATFORM_PRINCIPAL, ejbUser);
           env.put(PlatformContext.PLATFORM_CREDENTIALS, ejbPswd);

	   Request request;
    	   requestStatus[Request.NOT_STARTED] = "NOT STARTED";
    	   requestStatus[Request.IN_PROCESS] = "IN PROCESS";
    	   requestStatus[Request.SUCCEEDED] = "SUCCEEDED";
    	   requestStatus[Request.FAILED] = "FAILED";
    	   requestStatus[Request.WARNING] = "WARNING";

           System.out.println("\nCreating new PlatformContext with itimUser = " + itimUser + "\n");
           System.out.println("\nEnv URL = " + appServerUrl + " EJB User " + ejbUser + "\n");
           PlatformContext platform = new InitialPlatformContext(env);
           PlatformCallbackHandler handler = new PlatformCallbackHandler(itimUser, itimPswd);
           handler.setPlatformContext(platform);

           System.out.println("Logging in \n");
           // Associate the CallbackHandler with a LoginContext,
           LoginContext lc = new LoginContext(LOGIN_CONTEXT, handler);
           // Try to authenticate the user with the platform
           lc.login();

           System.out.println("Getting subject \n");
           // Extract the authenticated JAAS Subject from the LoginContext
           Subject subject = lc.getSubject();

           String argServiceName =(String)arguments.get(SERVICE_NAME);
           SERVICE_FILTER = "(erservicename="+ argServiceName + ")";

           System.out.println("Searching for Service \n");
//           System.out.println("Service profile : " + SERVICE_PROFILE +"\n");
//           System.out.println("Service filter " + SERVICE_FILTER +"\n");
           // Use the Search API to locate the the Service instance
           SearchMO searchMO = new SearchMO(platform, subject);
           searchMO.setContext(new CompoundDN(new 
                     DistinguishedName("ou="+tenantId+"," + ldapServerRoot)));
           searchMO.setCategory(ObjectProfileCategory.SERVICE);
//           searchMO.setFilter((String)arguments.get(SERVICE_FILTER));
           searchMO.setFilter(SERVICE_FILTER);
           searchMO.setProfileName((String)arguments.get(SERVICE_PROFILE));
           System.out.println("Service filter " + SERVICE_FILTER +"\n");

           Collection services = searchMO.execute().getResults();
           if(services == null || services.isEmpty()) {

               System.out.println("Unable to find Service.\n");
               System.exit(0);
           }

           System.out.println("Service found  \n");
           Service service = (Service)services.iterator().next();
           ServiceMO serviceMO =
              new ServiceMO(platform, subject, service.getDistinguishedName());

	   String serviceName = service.getName();

           System.out.println("Creating ReconManager for service " + serviceName + "\n");
           ReconManager reconManager = new ReconManager(platform, subject);
           
           // Initialize temporary reconciliation unit
           ReconUnitData newReconUnitData = new ReconUnitData();
	   int DayOfWeek = 1;
	   newReconUnitData.setDayOfWeek(DayOfWeek);
	   newReconUnitData.setName(serviceName + "batch Recon");
	   newReconUnitData.setDescription(serviceName + "batch Reconciliation");
	   newReconUnitData.setHour(0);
	   newReconUnitData.setMinute(0);
	   newReconUnitData.setMonth(0);
	   newReconUnitData.setID(127);
	   newReconUnitData.setMaxDuration(360);
	   newReconUnitData.setReconQueryFilter("(ERUID=*)");
	   newReconUnitData.setLockService(false);

           System.out.println("Add Reconciliation Schedule\n");
	   reconManager.addReconUnitData(serviceMO, newReconUnitData, null);

           Collection reconDataCollection = reconManager.getReconUnits(serviceMO);
           if(reconDataCollection == null || reconDataCollection.isEmpty()) {
                System.out.println("\nNo recon units found");
                System.exit(0);
           }
           System.out.println("\nNumber of recon units found - " + reconDataCollection.size());
           for (Iterator it = reconDataCollection.iterator(); it.hasNext();) {

              ReconUnitData reconData = (ReconUnitData)it.next();
              System.out.println("\n\n" + reconData.toString());
	      if ( reconData.getID() == 127 ) {
           	System.out.println("Running Reconciliation \n");
// Run Reconciliation
           	request = reconManager.runRecon(serviceMO, reconData);

	        System.out.println("Run recon submitted successfully\n");
           	System.out.println("Process ID = " + request.getID());
           	System.out.println("Process Status = " + requestStatus[request.getStatus()]);


//           System.out.println("Removing reconciliation unit..");
                reconManager.removeReconUnitData(serviceMO, newReconUnitData);
                System.out.println("Removed reconciliation unit successfully.");

	   	iteration = TIMEOUT / TIMETOWAIT;
	   	try {
			while ( (request.getStatus() == request.NOT_STARTED || request.getStatus() == request.IN_PROCESS) && (counter < iteration) ) {
// We should wait until process is completed (SUCCEEDED, WARNING, or FAILED).
			System.out.println("Process is still running or starting");
			counter++;
			Thread.sleep(TIMETOWAIT);
			}
	   	}
    	   	catch(InterruptedException ie){
      			System.out.println("Thread interrupted !" + ie);
     	   	}
           	System.out.println("Process Status is now = " + request.getStatus());
           	System.out.println("Reconciliation on service:" + serviceName + ":" + requestStatus[request.getStatus()]);

	      } // end if reconData.getID()
           }

       } catch (RemoteException e) {
           e.printStackTrace();
       } catch (LoginException e) {
           e.printStackTrace();
       } catch (SchemaViolationException e) {
           e.printStackTrace();
       } catch (AuthorizationException e) {
           e.printStackTrace();
       } catch (ApplicationException e) {
           e.printStackTrace();
       } catch (NumberFormatException e) {
           System.out.println("\nInvalid number format, enter valid numbers\n");
//       } catch (AppProcessingException e) {
//           e.printStackTrace();
       } catch (RemoteServicesException e) {
           e.printStackTrace();
       } catch (Exception e) {
           e.printStackTrace();
       

       }
   }

   /**
    * Parses the argument list from the command-line
    */
   public static Hashtable parseArgs(String[] args) {
       Hashtable arguments = new Hashtable();
       String argumentList = "";
       for (int i=0;i<args.length;i++) {
           argumentList += args[i];
       }
       try {
           StringTokenizer tokenizer =
               new StringTokenizer(argumentList, "?");
           while (tokenizer.hasMoreTokens()) {
               String token = (String)tokenizer.nextToken();
               int delim = token.indexOf(":");
               String name = token.substring(0, delim);
               String value = token.substring(delim+1, token.length());
               if (arguments.get(name) != null) {
                   // arg name used previous
                   Object vals = arguments.get(name);
                   if (vals instanceof String) {
                       // convert to String[]
                       Vector values = new Vector(1);
                       values.add((String)vals);
                       values.add(value);
                       arguments.put(name, values);
                   } else if (vals instanceof Vector) {
                       // add new element to String[]
                       Vector values = (Vector)vals;
                       values.add(value);
                       arguments.put(name, vals);
                   }
               } else {
                   arguments.put(name, value);
               }
           }
           if (!checkArguments(arguments))
               System.exit(0);
       } catch (Exception e) {
           e.printStackTrace();
           printUsage("Invalid command syntax");
           System.exit(0);
       }
       return arguments;
   }

   public static boolean checkArguments(Hashtable arguments) {
       if (!arguments.containsKey(SERVICE_PROFILE))
           return printUsage("No Service profile specified");
//       if (!arguments.containsKey(SERVICE_NAME))
//           return printUsage("No servicefilter specified");
       return true;
   }

   public static boolean printUsage(String msg) {
       StringBuffer usage = new StringBuffer();
       usage.append("\nrunRecon: " + msg + "\n");
       usage.append("usage: runRecon ?[argument] : \"[value]\"\n");
       usage.append("\n");
       usage.append("?serviceprofile      Profile Name of the Service");
       usage.append(" (e.g., ADProfile)\n");
       usage.append("[?servicename]        Service Name of a Service instance\n");
       usage.append("Arguments enclosed in [] are optional\n\n");
       usage.append("Example: runRecon ?serviceprofile:ADProfile  ?servicename:AD-F0061");
       System.out.println(usage);
       return false;
   }

}