/*
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.nAdminAPI.apps;

import com.pcbsys.foundation.utils.fEnvironment;
import com.pcbsys.nirvana.client.*;
import com.pcbsys.nirvana.nAdminAPI.*;

import java.util.Enumeration;
import java.util.Observer;
import java.util.Observable;
import java.io.*;

/**
 * This class demonstrates how to watch for connections to a realm and be notified of
 * new connections, or connections closing
 */

public class nConnectionWatch implements Observer {

    private String realmUrl = null;

    /**
     * Constructor takes a realm URL
     */
    public nConnectionWatch(String[] args) {
        try {
            processArgs(args);
            System.out.println("Connecting to " + realmUrl);
            // construct the session attributes for the realm
            nSessionAttributes attr = new nSessionAttributes(realmUrl);
            // construct the real node
            nRealmNode node = new nRealmNode(attr);
            if (!node.isAuthorised()) {
                System.out.println("User not authorised on this node " + realmUrl);
                return;
            }

            // add a new Realm watch instance as a watcher for connections to this root realm
            // call the method to add listeners to the channel and queue nodes
            register(node);
            System.out.println("Press any key to quit !");
            BufferedInputStream bis = new BufferedInputStream(System.in);
            try {
                bis.read();
            } catch (Exception read) {
            } //Ignore this
            node.close();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static void main(String[] args) {
        //Process Environment Variables
        processEnvironmentVariable("RNAME");
        processEnvironmentVariable("LOGLEVEL");
        processEnvironmentVariable("HPROXY");
        processEnvironmentVariable("HAUTH");
        processEnvironmentVariable("CKEYSTORE");
        processEnvironmentVariable("CKEYSTOREPASSWD");
        processEnvironmentVariable("CAKEYSTORE");
        processEnvironmentVariable("CAKEYSTOREPASSWD");

        // Install any proxy server settings
        fEnvironment.setProxyEnvironments();

        // Install JSSE SSL Environement settings
        fEnvironment.setSSLEnvironments();

        nConnectionWatch dump = new nConnectionWatch(args);
    }

    private void processArgs(String[] args) {
        switch (args.length) {
            case 1:
                if (args[0].equals("-?")) UsageEnv();
                getOptions(null);
                break;
            default:
                getOptions(args);
        }
    }


    private static void processEnvironmentVariable(String variable) {
        String laxVAR = System.getProperty("lax.nl.env." + variable);
        if (laxVAR != null) System.setProperty(variable, laxVAR);
    }

    /**
     * Set the program variables and flags based on command line args
     */
    public void getOptions(String args[]) {
        realmUrl = System.getProperty("RNAME", null);
        if (realmUrl == null) {
            Usage();
            System.exit(1);
        }
    }


    /**
     * Search the enumeration of child nodes, and add realm watchers to all child realms,
     * and watchers to all channel and queue nodes
     */
    private void register(Enumeration enum1) throws nBaseAdminException {
        while (enum1.hasMoreElements()) {
            Object obj = enum1.nextElement();
            if (obj instanceof nLeafNode) {
                ((nLeafNode) obj).addListener(new nChannelWatch((nLeafNode) obj));
            } else if (obj instanceof nContainer) {
                register(((nContainer) obj).getNodes());
            } else if (obj instanceof nServiceNode) {
                nServiceNode sNode = (nServiceNode) obj;
                sNode.addListener(new nServiceWatch(sNode));
            } else if (obj instanceof nRealmNode) {
                // add a new realm watch instance as a watcher for connections to this realm
                register((nRealmNode) obj);
            }
        }
    }

    private synchronized void newConnection(String target, nConnectionDetails cd) {
        System.out.println(target);
        if (cd.getSubject().length == 1) {
            System.out.println(new java.util.Date(System.currentTimeMillis()) + " User [" + cd.getSubject()[0] + "] New Connection: " + cd.getId() + " Subject: " + cd.getSubject()[0]);
            System.out.println("Java Version: " + cd.getLanguageVersion());
            System.out.println("OS: " + cd.getOSName() + ", version " + cd.getOSVersion());
            System.out.println("Build Name: " + cd.getBuildNumber() + " Build Date: " + cd.getBuildDate());

        } else {
            System.out.println(new java.util.Date(System.currentTimeMillis()) + " User [" + cd.getSubject()[0] + "] New Connection :" + cd.getId());

            for (int x = 0; x < cd.getSubject().length; x++) {
                System.out.println(new java.util.Date(System.currentTimeMillis()) + " Subject[" + x + "] " + cd.getSubject()[x]);
            }

            System.out.println("Java Version: " + cd.getLanguageVersion());
            System.out.println("OS: " + cd.getOSName() + ", version " + cd.getOSVersion());
            System.out.println("Build Name: " + cd.getBuildNumber() + " Build Date: " + cd.getBuildDate());
        }
        System.out.println();
    }

    private void delConnection(String target, nConnectionDetails cd) {
        System.out.println(target);
        System.out.println(new java.util.Date(System.currentTimeMillis()) + " User [" + cd.getSubject()[0] + "] Del Connection : " + cd.getId() + " Subject: " + cd.getSubject()[0]);
        System.out.println("Java Version: " + cd.getLanguageVersion());
        System.out.println("OS: " + cd.getOSName() + ", version " + cd.getOSVersion());
        System.out.println("Build Name: " + cd.getBuildNumber() + " Build Date: " + cd.getBuildDate());
        System.out.println();
    }

    private void register(nRealmNode node) throws nBaseAdminException {
        nRealmNode rNode = (nRealmNode) node;
        rNode.addObserver(this);
        rNode.addConnectionListener(new nRealmWatch());
        register(rNode.getNodes());
    }

    public void update(Observable obs) {
        update(obs, null);
    }

    public void update(Observable obs, Object obj) {
        try {
            if (obj instanceof nLeafNode) {
                ((nLeafNode) obj).addListener(new nChannelWatch((nLeafNode) obj));
            } else if (obj instanceof nContainer) {
                register(((nContainer) obj).getNodes());
            } else if (obj instanceof nServiceNode) {
                nServiceNode sNode = (nServiceNode) obj;
                sNode.addListener(new nServiceWatch(sNode));
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    /**
     * Class that implements the connection lister interface.
     * This internal class will receive notifications when a sesison is added to
     * or removed from a channel
     */
    public class nChannelWatch implements nConnectionListener {

        nLeafNode myChannel;

        /**
         * Construct the channel watch with the channel leaf node
         */
        public nChannelWatch(nLeafNode chan) {
            myChannel = chan;
        }

        /**
         * Notification of a new channel connection
         */
        public void add(nConnectionDetails cd) {
            if (cd instanceof nChannelConnectionDetails) {
                nChannelConnectionDetails ccd = (nChannelConnectionDetails) cd;
                nConnectionWatch.this.newConnection("Chan: " + myChannel.getAbsolutePath() + " with name [" + ccd.getNamedSubscriber() + "]", ccd);
            }
        }

        /**
         * Notification of a channel connection being removed
         */
        public void del(nConnectionDetails cd) {
            nConnectionWatch.this.delConnection("Chan: " + myChannel.getAbsolutePath(), cd);
        }
    }

    /**
     * Class that implements the connection lister interface.
     * This internal class will receive notifications when a sesison is added to
     * or removed from a channel
     */
    public class nServiceWatch implements nConnectionListener {

        nServiceNode myService;

        /**
         * Construct the channel watch with the channel leaf node
         */
        public nServiceWatch(nServiceNode service) {
            myService = service;
        }

        /**
         * Notification of a new channel connection
         */
        public void add(nConnectionDetails cd) {
            nConnectionWatch.this.newConnection("Service: " + myService.getName(), cd);
        }

        /**
         * Notification of a channel connection being removed
         */
        public void del(nConnectionDetails cd) {
            nConnectionWatch.this.delConnection("Service: " + myService.getName(), cd);
        }
    }

    /**
     * Class that implements the connection lister interface.
     * This internal class will receive notifications when a subject connection
     * is added or removed from the realm
     */
    public class nRealmWatch implements nConnectionListener {

        /**
         * Notification of a new session connection to the realm
         */
        public void add(nConnectionDetails cd) {
            nConnectionWatch.this.newConnection("Realm: New Connection : ", cd);
        }

        /**
         * Notification of a session connection being removed from the realm
         */
        public void del(nConnectionDetails cd) {
            nConnectionWatch.this.delConnection("Realm: Del Connection : ", cd);
        }
    }

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

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

    private static void UsageEnv() {
        System.out.println(
                "\n\n(Environment Variables) \n");

        System.out.println(
                "(RNAME) - One or more RNAME entries in the form protocol://host:port");
        System.out.println(
                "   protocol - Can be one of nsp, nhp, nsps, or nhps, where:");
        System.out.println(
                "   nsp - Specifies Nirvana Socket Protocol (nsp)");
        System.out.println(
                "   nhp - Specifies Nirvana HTTP Protocol (nhp)");
        System.out.println(
                "   nsps - Specifies Nirvana Socket Protocol Secure (nsps), i.e. using SSL/TLS");
        System.out.println(
                "   nhps - Specifies Nirvana HTTP Protocol Secure (nhps), i.e. using SSL/TLS");
        System.out.println(
                "   port - The port number of the server");
        System.out.println(
                "\nHint: - For multiple RNAME entries, use comma separated values which will be attempted in connection weight order\n");

        System.out.println(
                "(LOGLEVEL) - This determines how much information the nirvana api will output 0 = verbose 7 = quiet\n");

        System.out.println(
                "(CKEYSTORE) - If using SSL, the location of the keystore containing the client cert\n");
        System.out.println(
                "(CKEYSTOREPASSWD) - If using SSL, the password for the keystore containing the client cert\n");
        System.out.println(
                "(CAKEYSTORE) - If using SSL, the location of the ca truststore\n");
        System.out.println(
                "(CAKEYSTOREPASSWD) - If using SSL, the password for the ca truststore\n");

        System.out.println(
                "(HPROXY) - HTTP Proxy details in the form proxyhost:proxyport, where:");
        System.out.println(
                "   proxyhost - The HTTP proxy host");
        System.out.println(
                "   proxyport - The HTTP proxy port\n");
        System.out.println(
                "(HAUTH) - HTTP Proxy authentication details in the form user:pass, where:");
        System.out.println(
                "   user - The HTTP proxy authentication username");
        System.out.println(
                "   pass - The HTTP proxy authentication password\n");
        System.exit(1);
    }


}