/*
Copyright 1999-2011 (c) My-Channels
Copyright (c) 2012-2015 Software AG, Darmstadt, Germany and/or Software AG USA Inc., Reston, VA, USA, and/or its subsidiaries and/or its affiliates and/or their licensors.

Use, reproduction, transfer, publication or disclosure is prohibited except as specifically provided for in your License Agreement with Software AG.
*/
package com.pcbsys.nirvana.apps;

import com.pcbsys.nirvana.client.nChannel;
import com.pcbsys.nirvana.client.nChannelAttributes;
import com.pcbsys.nirvana.client.nChannelPublishKeys;
import com.pcbsys.nirvana.client.nFindResult;
import com.pcbsys.nirvana.client.nQueue;
import com.pcbsys.nirvana.client.nRealmUnreachableException;
import com.pcbsys.nirvana.client.nSessionFactory;
import com.pcbsys.nirvana.client.nSessionPausedException;
import com.pcbsys.nirvana.client.nStoreProperties;

public class findChannelsAndQueues extends nSampleApp {

  private static findChannelsAndQueues mySelf=null;

  private static final int sChannels = 0;
  private static final int sQueues   = 1;

  private static final int sPersist = 0;
  private static final int sMixed = 1;
  private static final int sReliable = 2;
  private static final int sSimple = 3;
  private static final int sTransient = 4;

  private static int[][] mySummary = new int[2][5];

  /**
   * This class demonstrates the Nirvana API calls necessary to locate multiple nChannel and nQueue objects in 1 method call
   *
   * @param realmDetails a String[] containing the possible RNAME values
   * @param names a String[] containing the names of the channels / queue objects
   *
   */
  private void doit(String[] realmDetails, String[] names)throws nRealmUnreachableException {

    mySelf.constructSession(realmDetails);

    try{
      nChannelAttributes[] att = new nChannelAttributes[names.length];
      for(int x=0;x<att.length;x++){
        att[x] = new nChannelAttributes(names[x]);
      }
      nFindResult[] arr = mySession.find(att);
      if(arr != null){
        for(int x =0; x<arr.length;x++){
          displayFindResultDetails(arr[x]);
        }
      }
    }
    //Handle errors
    catch (nSessionPausedException ex1){}
    catch (Exception se) {
      System.out.println("Insufficient permissions for the requested operation.");
      System.out.println("Please check the ACL settings on the server.");
      return;
    }
    try{
      nSessionFactory.close(mySession);
    }
    catch(Exception ex){
      ex.printStackTrace();
    }
  }

  protected void processArgs(String[] args){
    switch (args.length){
      case 0:
        Usage();
        UsageEnv();
        System.exit(0);
      case 1:
        if (args[0].equals("-?")) {
          Usage();
          UsageEnv();
          System.exit(0);
        }
    }
  }

  public static void main( String[] args ) {

    //Create an instance for this class
    mySelf = new findChannelsAndQueues();

    //Process Environment Variables
    nSampleApp.processEnvironmentVariables();

    //Check the local realm details
    int idx;
    String RNAME=null;
    if ( System.getProperty( "RNAME" ) != null )
      RNAME= System.getProperty( "RNAME" ) ;
    else{
      Usage();
      System.exit( 1 );
    }
    //Process the local REALM RNAME details
    String[] rproperties = parseRealmProperties(RNAME);

    try{
      //Display the details of channels and queues in all known realm
      mySelf.doit(rproperties, args );
      nSessionFactory.shutdown();
    }
    catch(Exception ex){
    }
    int grandTotal;
    int count = 0;

    System.out.println("\nSummary\n");
    idx = sQueues;
    System.out.println("Queue Summary");
    System.out.println("  Transient  : "+mySummary[idx][sTransient]);
    System.out.println("  Simple     : "+mySummary[idx][sSimple]);
    System.out.println("  Reliable   : "+mySummary[idx][sReliable]);
    System.out.println("  Persistent : "+mySummary[idx][sPersist]);
    System.out.println("  Mixed      : "+mySummary[idx][sMixed]);
    System.out.print("\nTotal Queues = ");
    for(int x=0;x<5;x++){
      count += mySummary[sQueues][x];
    }
    grandTotal = count;
    System.out.println(count);
    idx = sChannels;
    System.out.println("\nChannel Summary");
    System.out.println("  Transient  : "+mySummary[idx][sTransient]);
    System.out.println("  Simple     : "+mySummary[idx][sSimple]);
    System.out.println("  Reliable   : "+mySummary[idx][sReliable]);
    System.out.println("  Persistent : "+mySummary[idx][sPersist]);
    System.out.println("  Mixed      : "+mySummary[idx][sMixed]);
    System.out.print("\nTotal Channels = ");
    count = 0;
    for(int x=0;x<5;x++){
      count += mySummary[sChannels][x];
    }
    System.out.println(count);
    grandTotal += count;
    System.out.println("\n\nGrand Total    = "+grandTotal+"\n\n");
  }

  /**
   * This method displays the details of a channel found in a realm
   *
   * @param results the attributes for the channel
   */
  private void displayFindResultDetails(nFindResult results){
    if(!results.wasSuccessful()){
      displayException(results);
    }
    else if(results.isChannel()){
      nChannel chan = results.getChannel();
      displayChannelDetails(chan.getChannelAttributes());
    }
    else if(results.isQueue()){
      nQueue queue = results.getQueue();
      displayChannelDetails(queue.getQueueAttributes());
    }
  }


  private void displayChannelDetails(nChannelAttributes attr){
    int idx = sChannels;
    String type = "Channel";
    if(attr.getChannelMode() == nChannelAttributes.QUEUE_MODE){
      type = "Queue  ";
      idx = sQueues;
    }
    System.out.println("******************************");
    System.out.println("  Type is a "+type);
    System.out.println("  "+type+" Name         : "+attr.getName());
    System.out.println("  "+type+" Capacity     : "+attr.getMaxEvents());
    System.out.println("  "+type+" Time to live : "+attr.getTTL());
    String store = "";
    switch(attr.getType()){
      case nChannelAttributes.MIXED_TYPE:
        store = "MIXED";
        mySummary[idx][sMixed]++;
        break;
      case nChannelAttributes.PERSISTENT_TYPE:
        store = "PERSISTENT";
        mySummary[idx][sPersist]++;
        break;
      case nChannelAttributes.RELIABLE_TYPE:
        store = "RELIABLE";
        mySummary[idx][sReliable]++;
        break;
      case nChannelAttributes.SIMPLE_TYPE:
        store = "SIMPLE";
        mySummary[idx][sSimple]++;
        break;
      case nChannelAttributes.TRANSIENT_TYPE:
        store = "TRANSIENT";
        mySummary[idx][sTransient]++;
        break;
    }
    System.out.println("  "+type+" Storage type : "+store);
    nStoreProperties props = attr.getProperties();
    System.out.println("Displaying Store Properties:");
    if(props.getClientMergeEngineClassname() != null) System.out.println("\tClient Merge Engine Classname : "+props.getClientMergeEngineClassname());
    if(props.getFanoutArchiveTarget() != null) System.out.println("\tFanout Archive Target : "+props.getFanoutArchiveTarget());
    System.out.println("\tCache on reload : "+props.getCacheOnReload());
    if(props.canSyncOnEachWrite()){
      System.out.println("\tSync file system on write : "+props.canSyncOnEachWrite());
      System.out.println("\tSync batch size : "+props.getSyncMaxBatchSize());
      System.out.println("\tSync batch time : "+props.getSyncBatchTime());
    }

    System.out.println("\tCache enabled : "+props.getEnableCaching());
    if(props.getEnableReadBuffering()){
      System.out.println("\tBuffered read enabled : "+props.getEnableReadBuffering());
      System.out.println("\tRead Buffer size : "+props.getReadBufferSize());
    }

    System.out.println("\tHonour capacity when full : "+props.getHonorCapacityWhenFull());
    System.out.println("\tAutomatic maintenance enabled : "+props.getPerformAutomaticMaintenance());


    System.out.println("  Displaying Publish Keys");
    nChannelPublishKeys keys[] = attr.getPublishKeys();
    if (keys != null && keys.length > 0) {
      for (int x = 0; x < keys.length; x++) {
        System.out.println("    Key "+keys[x].getName()+" depth "+keys[x].getDepth());
      }
    }
    System.out.println("  End Of Publish Keys");
    System.out.println("******************************");
    System.out.println("");
  }

  private void displayException(nFindResult result){
    System.err.println("******************************");
    System.err.println("  Request generated an exception for "+result.getAttributes().getName());
    System.err.println("   : "+result.getException().getMessage());
    System.err.println("******************************");
    System.err.println("");
  }

  /**
   * Prints the usage string for this class
   */
  private static void Usage() {

    System.out.println( "Usage ...\n" );
    System.out.println("findChannelsAndQueues <name> <name> <name>.....\n");

    System.out.println(
      "<Arguments> \n");
    System.out.println(
      "<name> - The name(s) of the channels to find" );

    System.out.println(
      "\n\nNote: -? provides help on environment variables \n");
  }

} // End of getChannels Class