/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package com.oracle.jmx.remote.rest.http;

import javax.management.*;

import com.oracle.jmx.remote.rest.json.JSONArray;

import com.oracle.jmx.remote.rest.json.JSONObject;

import com.oracle.jmx.remote.rest.json.JSONPrimitive;

import com.oracle.jmx.remote.rest.mapper.JSONMappingException;

import com.oracle.jmx.remote.rest.mapper.JSONMappingFactory;

import java.net.HttpURLConnection;

import java.util.*;

import static javax.management.MBeanOperationInfo.*;

/**

 * @author harsha

 */

public class GetRequestHandler {

    private final MBeanServer mbeanServer;

    private final List<String> allowedMBeans;

    public GetRequestHandler(MBeanServer mServer, List<String> allowedMBeans) {

        this.mbeanServer = mServer;

        this.allowedMBeans = allowedMBeans;

    }

    public synchronized JSONObject handle(String resource, String query) {

        System.out.println("Resource = " + resource + ", Body = " + query);

        try {

            if ((query == null || query.isEmpty()) && (resource == null || resource.isEmpty())) {

                return HttpResponse.getJsonObject(HttpURLConnection.HTTP_OK,

                        new JSONPrimitive(resource + (query == null ? "" : query)),

                        new JSONPrimitive("Nothing to see here.. move along"));

            }

            if (query != null && resource.isEmpty()) { // Handle default domain

                String[] tokens = query.split(Tokens.FORWARD_SLASH);

                if (tokens.length == 1 && tokens[0].equalsIgnoreCase(Tokens.DEFAULT_DOMAIN)) {

                    // Get default domain

                    return HttpResponse.getJsonObject(HttpURLConnection.HTTP_OK,

                            new JSONPrimitive(resource + (query == null ? "" : query)),

                            new JSONPrimitive(mbeanServer.getDefaultDomain()));

                } else { // Get mbeans belonging to a domain

                }

            } else {

                // handle string escaping for '/'

                String[] tokens = resource.split("/");

                switch (tokens[0]) {

                    case Tokens.DOMAINS:

                        String[] domains = mbeanServer.getDomains();

                        JSONArray jarr = new JSONArray();

                        Arrays.stream(domains).forEach(a -> jarr.add(new JSONPrimitive(a)));

                        return HttpResponse.getJsonObject(HttpURLConnection.HTTP_OK,

                                new JSONPrimitive(resource + (query == null ? "" : query)),

                                jarr);

                    case Tokens.MBEANS:

                        //Set<ObjectInstance> mbeans = mbeanServer.queryMBeans(null, null);

                        jarr = new JSONArray();

                        //mbeans.stream()

                        //.map(objIns -> objIns.getObjectName().toString())

                        allowedMBeans.stream().forEach(a -> jarr.add(new JSONPrimitive(a)));

                        return HttpResponse.getJsonObject(HttpURLConnection.HTTP_OK,

                                new JSONPrimitive(resource + (query == null ? "" : query)),

                                jarr);

                    default:

                        if (tokens.length == 2) {

                            if (!allowedMBeans.contains(tokens[0])) {

                                throw new InstanceNotFoundException("Invalid MBean");

                            }

                            ObjectName mbean = ObjectName.getInstance(tokens[0]);

                            JSONObject jsonObject = getJSONObject(readAttributes(mbeanServer, mbean, tokens[1]));

                            return HttpResponse.getJsonObject(HttpURLConnection.HTTP_OK,

                                    new JSONPrimitive(resource + (query == null ? "" : query)),

                                    jsonObject);

                        } else if (tokens.length == 1 && query != null && !query.isEmpty()) {

                            if (!allowedMBeans.contains(tokens[0])) {

                                throw new InstanceNotFoundException("Invalid MBean");

                            }

                            ObjectName mbean = ObjectName.getInstance(tokens[0]);

                            if (query.startsWith(Tokens.ATTRS)) {

                                String attrs = query.split(Tokens.EQUALS)[1];

                                JSONObject jsonObject = getJSONObject(readAttributes(mbeanServer, mbean, attrs));

                                return HttpResponse.getJsonObject(HttpURLConnection.HTTP_OK,

                                        new JSONPrimitive(resource + (query == null ? "" : query)),

                                        jsonObject);

                            }

                        } else if (tokens.length == 1 && (query == null || query.isEmpty())) {

                            if (!allowedMBeans.contains(tokens[0])) {

                                throw new InstanceNotFoundException("Invalid MBean");

                            }

                            // We get MBeanInfo

                            ObjectName mbeanObj = ObjectName.getInstance(tokens[0]);

                            return HttpResponse.getJsonObject(HttpURLConnection.HTTP_OK,

                                    new JSONPrimitive(resource + (query == null ? "" : query)),

                                    getMBeanInfo(mbeanServer, mbeanObj));

                        }

                        System.out.println("Unrecognized token : " + tokens[0]);

                }

            }

        } catch (MBeanException | JSONMappingException | IntrospectionException ex) {

            return HttpResponse.getJsonObject(HttpResponse.getHttpErrorCode(ex),

                    new JSONPrimitive(resource + (query == null ? "" : query)),

                    new JSONPrimitive("Invalid Mbean attribute"));

        } catch (AttributeNotFoundException ex) {

            return HttpResponse.getJsonObject(HttpResponse.getHttpErrorCode(ex),

                    new JSONPrimitive(resource + (query == null ? "" : query)),

                    new JSONPrimitive(ex.getMessage()));

        } catch (InstanceNotFoundException | ReflectionException | MalformedObjectNameException ex) {

            return HttpResponse.getJsonObject(HttpResponse.getHttpErrorCode(ex),

                    new JSONPrimitive(resource + (query == null ? "" : query)),

                    new JSONPrimitive("Invalid Mbean"));

        }

        return HttpResponse.getJsonObject(HttpURLConnection.HTTP_OK,

                new JSONPrimitive(resource + (query == null ? "" : query)),

                new JSONPrimitive("Nothing to see here.. move along"));

    }

    private JSONObject getMBeanInfo(MBeanServer mbeanServer, ObjectName mbean) throws InstanceNotFoundException, IntrospectionException, ReflectionException {

        JSONObject jobj = new JSONObject();

        MBeanInfo mBeanInfo = mbeanServer.getMBeanInfo(mbean);

        if (mBeanInfo == null) {

            return jobj;

        }

        jobj.put("description", mBeanInfo.getDescription());

        // Populate Attribute Info

        MBeanAttributeInfo[] attributes = mBeanInfo.getAttributes();

        JSONArray jarr = new JSONArray();

        for (MBeanAttributeInfo attr : attributes) {

            String access;

            if (attr.isReadable()) {

                if (attr.isWritable()) {

                    access = "read/write";

                } else {

                    access = "read-only";

                }

            } else if (attr.isWritable()) {

                access = "write-only";

            } else {

                access = "no-access";

            }

            JSONObject jobj1 = new JSONObject();

            jobj1.put("description", attr.getDescription());

            jobj1.put("name", attr.getName());

            jobj1.put("type", attr.getType());

            jobj1.put("access", access);

            jobj1.put("descriptor", getDescriptorJSON(attr.getDescriptor()));

            jarr.add(jobj1);

        }

        jobj.put("attributeInfo", jarr);

        // Add constructor Info

        MBeanConstructorInfo[] constructorInfo = mBeanInfo.getConstructors();

        jarr = new JSONArray();

        for (MBeanConstructorInfo constructor : constructorInfo) {

            JSONObject jobj1 = new JSONObject();

            jobj1.put("description", constructor.getDescription());

            jobj1.put("name", constructor.getName());

            JSONArray jarr1 = new JSONArray();

            for (MBeanParameterInfo paramInfo : constructor.getSignature()) {

                jarr1.add(getParamJSON(paramInfo));

            }

            jobj1.put("signature", jarr1);

            if (constructor.getDescriptor().getFieldNames().length > 1) {

                jobj1.put("descriptor", getDescriptorJSON(constructor.getDescriptor()));

            }

            jarr.add(jobj1);

        }

        jobj.put("constructorInfo", jarr);

        MBeanOperationInfo[] opInfo = mBeanInfo.getOperations();

        jarr = new JSONArray();

        for (MBeanOperationInfo op : opInfo) {

            String impactString;

            switch (op.getImpact()) {

                case ACTION:

                    impactString = "action";

                    break;

                case ACTION_INFO:

                    impactString = "action/info";

                    break;

                case INFO:

                    impactString = "info";

                    break;

                case UNKNOWN:

                    impactString = "unknown";

                    break;

                default:

                    impactString = "(" + op.getImpact() + ")";

            }

            JSONObject jobj1 = new JSONObject();

            jobj1.put("description", op.getDescription());

            jobj1.put("name", op.getName());

            jobj1.put("returnType", op.getReturnType());

            JSONArray jarr1 = new JSONArray();

            for (MBeanParameterInfo paramInfo : op.getSignature()) {

                jarr1.add(getParamJSON(paramInfo));

            }

            jobj1.put("signature", jarr1);

            jobj1.put("impact", impactString);

            if (op.getDescriptor().getFieldNames().length > 1) {

                jobj1.put("descriptor", getDescriptorJSON(op.getDescriptor()));

            }

            jarr.add(jobj1);

        }

        jobj.put("operationInfo", jarr);

        MBeanNotificationInfo[] notifications = mBeanInfo.getNotifications();

        jarr = new JSONArray();

        for (MBeanNotificationInfo notification : notifications) {

            JSONObject jobj1 = new JSONObject();

            jobj1.put("description", notification.getDescription());

            jobj1.put("name", notification.getName());

            JSONArray jarr1 = new JSONArray();

            for (String notifType : notification.getNotifTypes()) {

                jarr1.add(new JSONPrimitive(notifType));

            }

            jobj1.put("notifTypes", jarr1);

            if (notification.getDescriptor().getFieldNames().length > 1) {

                jobj1.put("descriptor", getDescriptorJSON(notification.getDescriptor()));

            }

            jarr.add(jobj1);

        }

        jobj.put("notificationInfo", jarr);

        jobj.put("descriptor", getDescriptorJSON(mBeanInfo.getDescriptor()));

        return jobj;

    }

    private JSONObject getParamJSON(MBeanParameterInfo mParamInfo) {

        JSONObject jobj1 = new JSONObject();

        if (mParamInfo.getDescription() != null && !mParamInfo.getDescription().isEmpty()) {

            jobj1.put("description", mParamInfo.getDescription());

        }

        jobj1.put("name", mParamInfo.getName());

        jobj1.put("type", mParamInfo.getType());

        if (mParamInfo.getDescriptor() != null && mParamInfo.getDescriptor().getFieldNames().length > 1) {

            jobj1.put("descriptor", getDescriptorJSON(mParamInfo.getDescriptor()));

        }

        return jobj1;

    }

    private JSONObject getDescriptorJSON(Descriptor descriptor) {

        JSONObject jobj2 = new JSONObject();

        try {

            String[] descNames = descriptor.getFieldNames();

            for (String descName : descNames) {

                Object fieldValue = descriptor.getFieldValue(descName);

                jobj2.put(descName, fieldValue != null ? fieldValue.toString() : null);

            }

        } catch (Throwable t) {

            t.printStackTrace();

        }

        return jobj2;

    }

    private Map<String, Object> readAttributes(MBeanServer mbeanServer,

                                               ObjectName objName, String requestStr)

            throws InstanceNotFoundException, IntrospectionException,

            ReflectionException, MBeanException, AttributeNotFoundException {

        requestStr = requestStr.trim();

        Map<String, Object> result = new HashMap<>();

        if (requestStr.trim().equalsIgnoreCase("all")) {

            MBeanInfo mInfo = mbeanServer.getMBeanInfo(objName);

            String[] attrs = Arrays.stream(mInfo.getAttributes())

                    .map(MBeanAttributeInfo::getName)

                    .toArray(String[]::new);

            AttributeList attrVals = mbeanServer.getAttributes(objName, attrs);

            if (attrVals.size() != attrs.length) {

                List<String> missingAttrs = new ArrayList<>(Arrays.asList(attrs));

                for (Attribute a : attrVals.asList()) {

                    missingAttrs.remove(a.getName());

                    result.put(a.getName(), a.getValue());

                }

                for (String attr : missingAttrs) {

                    try {

                        Object attribute = mbeanServer.getAttribute(objName, attr);

                    } catch (RuntimeException ex) {

                        if (ex.getCause() instanceof UnsupportedOperationException) {

                            result.put(attr, "< Attribute not supported >");

                        } else if (ex.getCause() instanceof IllegalArgumentException) {

                            result.put(attr, "< Invalid attributes >");

                        }

                        continue;

                    }

                    result.put(attr, "< Error: No such attribute >");

                }

            } else {

                attrVals.asList().forEach((a) -> {

                    result.put(a.getName(), a.getValue());

                });

            }

        } else {

            String[] attrs = Arrays.stream(requestStr.split(Tokens.COMMA))

                    .map(String::trim)

                    .toArray(String[]::new);

            if (attrs.length == 1) {

                result.put(attrs[0], mbeanServer.getAttribute(objName, attrs[0]));

            } else {

                AttributeList attrVals = mbeanServer.getAttributes(objName, attrs);

                if (attrVals.size() != attrs.length) {

                    List<String> missingAttrs = new ArrayList<>(Arrays.asList(attrs));

                    for (Attribute a : attrVals.asList()) {

                        missingAttrs.remove(a.getName());

                        result.put(a.getName(), a.getValue());

                    }

                    for (String attr : missingAttrs) {

                        result.put(attr, "< Error: No such attribute >");

                    }

                } else {

                    attrVals.asList().forEach((a) -> {

                        result.put(a.getName(), a.getValue());

                    });

                }

            }

        }

        return result;

    }

    private JSONObject getJSONObject(Map<String, Object> attributeMap) throws JSONMappingException {

        JSONObject jobject = new JSONObject();

        JSONMappingFactory mappingFactory = JSONMappingFactory.INSTANCE;

        for (String key : attributeMap.keySet()) {

            Object attrVal = attributeMap.get(key);

            if (attrVal == null) {

                jobject.put(key, new JSONPrimitive());

            } else if (mappingFactory.getTypeMapper(attrVal) != null) {

                jobject.put(key, mappingFactory.getTypeMapper(attrVal).toJsonValue(attrVal));

            }

        }

        return jobject;

    }

    private interface Tokens {

        public static final String DOMAINS = "domains";

        public static final String MBEANS = "mbeans";

        public static final String ATTRS = "attributes";

        public static final String DOMAIN = "domain";

        public static final String DEFAULT_DOMAIN = "domain=default";

        public static final String ALL = "all";

        public static final String EQUALS = "=";

        public static final String COMMA = ",";

        public static final String FORWARD_SLASH = "/";

    }

}