package com.thetransactioncompany.jsonrpc2.server;


import java.util.Hashtable;

import com.thetransactioncompany.jsonrpc2.JSONRPC2Error;
import com.thetransactioncompany.jsonrpc2.JSONRPC2Notification;
import com.thetransactioncompany.jsonrpc2.JSONRPC2Request;
import com.thetransactioncompany.jsonrpc2.JSONRPC2Response;


/**
 * Dispatcher for JSON-RPC 2.0 requests and notifications. This class is
 * tread-safe.
 *
 * <p>Use the {@code register()} methods to add a request or notification
 * handler for an RPC method.
 *
 * <p>Use the {@code process()} methods to have an incoming request or
 * notification processed by the matching handler.
 *
 * <p>The {@code reportProcTime()} method enables reporting of request 
 * processing time (in microseconds) by appending a non-standard "xProcTime" 
 * attribute to the resulting JSON-RPC 2.0 response message.
 *
 * <p>Example:
 *
 * <pre>
 * { 
 *   "result"    : "xyz",
 *   "id"        : 1,
 *   "jsonrpc"   : "2.0",
 *   "xProcTime" : "189 us"
 * }
 * </pre>
 *
 * <p>Note: The dispatch(...) methods were deprecated in version 1.7. Use 
 * process(...) instead.
 *
 * @author Vladimir Dzhuvinov
 */
public class Dispatcher implements RequestHandler, NotificationHandler {
        
        
        /** 
         * Hashtable of request name / handler pairs. 
         */
        private final Hashtable<String,RequestHandler> requestHandlers;
        
        
        /**
         * Hashtable of notification name / handler pairs.
         */
        private final Hashtable<String,NotificationHandler> notificationHandlers;
        
        
        /**
         * Controls reporting of request processing time by appending a 
         * non-standard "xProcTime" attribute to the JSON-RPC 2.0 response.
         */
        private boolean reportProcTime = false;
        
        
        /**
         * Creates a new dispatcher with no registered handlers.
         */
        public Dispatcher() {
        
                requestHandlers = new Hashtable<String,RequestHandler>();
                notificationHandlers = new Hashtable<String,NotificationHandler>();
        }
        
        
        /**
         * Registers a new JSON-RPC 2.0 request handler.
         *
         * @param handler The request handler to register. Must not be 
         *                {@code null}.
         *
         * @throws IllegalArgumentException On attempting to register a handler
         *                                  that duplicates an existing request
         *                                  name.
         */
        public void register(final RequestHandler handler) {
        
                for (String name: handler.handledRequests()) {
                
                        if (requestHandlers.containsKey(name))
                                throw new IllegalArgumentException("Cannot register a duplicate JSON-RPC 2.0 handler for request " + name);
                
                        requestHandlers.put(name, handler);
                }
        }
        
        
        /**
         * Registers a new JSON-RPC 2.0 notification handler.
         *
         * @param handler The notification handler to register. Must not be
         *                {@code null}.
         *
         * @throws IllegalArgumentException On attempting to register a handler
         *                                  that duplicates an existing
         *                                  notification name.
         */
        public void register(final NotificationHandler handler) {
        
                for (String name: handler.handledNotifications()) {
                
                        if (notificationHandlers.containsKey(name))
                                throw new IllegalArgumentException("Cannot register a duplicate JSON-RPC 2.0 handler for notification " + name);
                
                        notificationHandlers.put(name, handler);
                }
        }
        
        
        @Override
        public String[] handledRequests() {

                java.util.Set<String> var = requestHandlers.keySet();
                return var.toArray(new String[var.size()]);
        }
        
        
        @Override
        public String[] handledNotifications() {

                java.util.Set<String> var = notificationHandlers.keySet();
                return var.toArray(new String[var.size()]);
        }
        
        
        /**
         * Gets the handler for the specified JSON-RPC 2.0 request name.
         *
         * @param requestName The request name to lookup.
         *
         * @return The corresponding request handler or {@code null} if none 
         *         was found.
         */
        public RequestHandler getRequestHandler(final String requestName) {
        
                return requestHandlers.get(requestName);
        }
        
        
        /**
         * Gets the handler for the specified JSON-RPC 2.0 notification name.
         *
         * @param notificationName The notification name to lookup.
         *
         * @return The corresponding notification handler or {@code null} if
         *         none was found.
         */
        public NotificationHandler getNotificationHandler(final String notificationName) {
        
                return notificationHandlers.get(notificationName);
        }
        
        
        /**
         * @deprecated
         */
        public JSONRPC2Response dispatch(final JSONRPC2Request request, final MessageContext requestCtx) {
        
                return process(request, requestCtx);
        }
        
        
        @Override
        public JSONRPC2Response process(final JSONRPC2Request request, final MessageContext requestCtx) {
        
                long startNanosec = 0;
                
                // Measure request processing time?
                if (reportProcTime)
                        startNanosec = System.nanoTime();
                
        
                final String method = request.getMethod();
                
                RequestHandler handler = getRequestHandler(method);
                
                if (handler == null) {
                
                        // We didn't find a handler for the requested RPC
                
                        Object id = request.getID();
                        
                        return new JSONRPC2Response(JSONRPC2Error.METHOD_NOT_FOUND, id);
                }
                        
                // Process the request
                
                JSONRPC2Response response = handler.process(request, requestCtx);
                
                if (reportProcTime) {
                
                        final long procTimeNanosec = System.nanoTime() - startNanosec;
                        
                        response.appendNonStdAttribute("xProcTime", procTimeNanosec / 1000 + " us");
                }
                
                return response;
        }
        
        
        /**
         * @deprecated
         */
        public void dispatch(final JSONRPC2Notification notification, final MessageContext notificationCtx) {
        
                process(notification, notificationCtx);
        }
        
        
        @Override
        public void process(final JSONRPC2Notification notification, final MessageContext notificationCtx) {
        
                final String method = notification.getMethod();
                
                NotificationHandler handler = getNotificationHandler(method);
                
                if (handler == null) {
                
                        // We didn't find a handler for the requested RPC
                        return;
                }
                        
                // Process the notification
                
                handler.process(notification, notificationCtx);
        }
        
        
        /**
         * Controls reporting of request processing time by appending a 
         * non-standard "xProcTime" attribute to the JSON-RPC 2.0 response.
         * Reporting is disabled by default.
         *
         * @param enable {@code true} to enable proccessing time reporting, 
         *               {@code false} to disable it.
         */
        public void reportProcTime(final boolean enable) {
        
                reportProcTime = enable;
        }
        
        
        /**
         * Returns {@code true} if reporting of request processing time is 
         * enabled. See the {@link #reportProcTime} description for more
         * information.
         *
         * @return {@code true} if reporting of request processing time is 
         *         enabled, else {@code false}.
         */
        public boolean reportsProcTime() {
        
                return reportProcTime;
        }
}