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

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

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

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

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

import com.oracle.jmx.remote.rest.json.parser.JSONParser;

import com.oracle.jmx.remote.rest.json.parser.ParseException;

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

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

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

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

import com.sun.net.httpserver.HttpExchange;

import javax.management.*;

import javax.management.openmbean.OpenMBeanAttributeInfo;

import javax.management.openmbean.OpenMBeanParameterInfo;

import javax.management.openmbean.OpenType;

import javax.management.remote.rest.PlatformRestAdapter;

import java.io.IOException;

import java.net.HttpURLConnection;

import java.util.*;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import static javax.management.MBeanOperationInfo.*;

public class MBeanResource implements RestResource {

    private final ObjectName objectName;

    private final MBeanServer mBeanServer;

    private static final String pathPrefix = "^/?jmx/servers/[^/]+/mbeans/[^/]+";

    private final static Map<String, Class<?>> primitiveToObject = new HashMap<>();

    static {

        primitiveToObject.put("int", Integer.TYPE);

        primitiveToObject.put("long", Long.TYPE);

        primitiveToObject.put("double", Double.TYPE);

        primitiveToObject.put("float", Float.TYPE);

        primitiveToObject.put("boolean", Boolean.TYPE);

        primitiveToObject.put("char", Character.TYPE);

        primitiveToObject.put("byte", Byte.TYPE);

        primitiveToObject.put("void", Void.TYPE);

        primitiveToObject.put("short", Short.TYPE);

    }

    public MBeanResource(MBeanServer mBeanServer, ObjectName objectName) {

        this.mBeanServer = mBeanServer;

        this.objectName = objectName;

    }

    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("name", attr.getName());

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

            jobj1.put("access", access);

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

            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("name", constructor.getName());

            JSONArray jarr1 = new JSONArray();

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

                jarr1.add(getParamJSON(paramInfo));

            }

            jobj1.put("signature", jarr1);

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

            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("name", op.getName());

            JSONArray jarr1 = new JSONArray();

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

                jarr1.add(getParamJSON(paramInfo));

            }

            jobj1.put("signature", jarr1);

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

            jobj1.put("impact", impactString);

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

            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("name", notification.getName());

            JSONArray jarr1 = new JSONArray();

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

                jarr1.add(new JSONPrimitive(notifType));

            }

            jobj1.put("notifTypes", jarr1);

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

            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;

    }

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

        } else {

        }

        return result;

    }

    private Map<String, Object> getAllAttributes() throws IntrospectionException,

            InstanceNotFoundException, ReflectionException, AttributeNotFoundException, MBeanException {

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

        MBeanInfo mInfo = mBeanServer.getMBeanInfo(objectName);

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

                .map(MBeanAttributeInfo::getName)

                .toArray(String[]::new);

        AttributeList attrVals = mBeanServer.getAttributes(objectName, 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(objectName, 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());

            });

        }

        return result;

    }

        if (attrMap == null || attrMap.isEmpty()) {

            throw new JSONDataException("Null arguments for set attribute");

        }

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

        for (String attrName : attrMap.keySet()) {

            MBeanInfo mBeanInfo = mBeanServer.getMBeanInfo(objectName);

            MBeanAttributeInfo attrInfo = Arrays.stream(mBeanInfo.getAttributes()).filter(a -> a.getName().equals(attrName)).findFirst().orElse(null);

            if (attrInfo == null) {

                result.put(attrName, "<Attribute not found>");

            } else if (!attrInfo.isWritable()) {

                result.put(attrName, "<Attribute is read-only>");

            } else {

                JSONMapper mapper;

                if (attrInfo instanceof OpenMBeanAttributeInfo) {

                    OpenType<?> type = ((OpenMBeanAttributeInfo) attrInfo).getOpenType();

                    mapper = JSONMappingFactory.INSTANCE.getTypeMapper(type);

                } else {

                    Class<?> inputCls = primitiveToObject.get(attrInfo.getType());

                    try {

                        if (inputCls == null) {

                            inputCls = Class.forName(attrInfo.getType());

                        }

                    } catch (ClassNotFoundException | ClassCastException ex) {

                        throw new IllegalArgumentException("Invalid parameters : " + attrMap.get(attrName).toJsonString() + " cannot be mapped to : " + attrInfo.getType());

                    }

                    mapper = JSONMappingFactory.INSTANCE.getTypeMapper(inputCls);

                }

                try {

                    Object attrValue = mapper.toJavaObject(attrMap.get(attrName));

                    Attribute attrObj = new Attribute(attrName, attrValue);

                    mBeanServer.setAttribute(objectName, attrObj);

                    result.put(attrName, "success");

                } catch (InvalidAttributeValueException | JSONDataException e) {

                    result.put(attrName, "<Invalid value for the attribute>");

                } catch (AttributeNotFoundException e) {

                    result.put(attrName, "<Attribute not found>");

                }

            }

        }

        return result;

    }

    private Object mapJsonToType(JSONElement jsonElement, MBeanParameterInfo type) {

        if (type instanceof OpenMBeanParameterInfo) {

            OpenType<?> openType = ((OpenMBeanParameterInfo) type).getOpenType();

            JSONMapper typeMapper = JSONMappingFactory.INSTANCE.getTypeMapper(openType);

            try {

                return typeMapper.toJavaObject(jsonElement);

            } catch (JSONDataException ex) {

                throw new IllegalArgumentException("Invalid JSON String : " + jsonElement.toJsonString() + " for arguments");

            }

        } else {

            Class<?> inputCls = primitiveToObject.get(type.getType());

            try {

                if (inputCls == null) {

                    inputCls = Class.forName(type.getType());

                }

            } catch (ClassNotFoundException | ClassCastException ex) {

                throw new IllegalArgumentException("Invalid parameters : " + jsonElement.toJsonString() + " cannot be mapped to : " + type.getType());

            }

            JSONMapper typeMapper = JSONMappingFactory.INSTANCE.getTypeMapper(inputCls);

            if (typeMapper == null) {

                throw new IllegalArgumentException("Invalid parameters : " + jsonElement.toJsonString() + " cannot be mapped to : " + type.getType());

            }

            try {

                return typeMapper.toJavaObject(jsonElement);

            } catch (JSONDataException ex) {

                throw new IllegalArgumentException("Invalid JSON String : " + jsonElement.toJsonString() + " for arguments");

            }

        }

    }

    private Map<String, Object> getParameters(Map<String, JSONElement> jsonValues, Map<String, MBeanParameterInfo> typeMap) {

        if (jsonValues.size() != typeMap.size()) {

            throw new IllegalArgumentException("Invalid parameters : expected - " + typeMap.size() + " parameters, got - " + jsonValues.size());

        }

            throw new IllegalArgumentException("Invalid parameters - expected : " + Arrays.toString(typeMap.keySet().toArray()));

        }

        Map<String, Object> parameters = new LinkedHashMap<>();

        if (typeMap.size() == 0 && jsonValues.isEmpty()) {

            return parameters;

        }

        for (String name : typeMap.keySet()) {

            MBeanParameterInfo type = typeMap.get(name);

            JSONElement jsonVal = jsonValues.get(name);

            Object obj = mapJsonToType(jsonVal, type);

            parameters.put(name, obj);

        }

        return parameters;

    }

    private JSONElement execOperation(String opstr, JSONObject params)

            throws MBeanException, IntrospectionException, ReflectionException, InstanceNotFoundException {

        if (params == null) {

            params = new JSONObject();

        }

        MBeanInfo mBeanInfo;

        try {

            mBeanInfo = mBeanServer.getMBeanInfo(objectName);

        } catch (InstanceNotFoundException ex) {

            throw new IllegalArgumentException("MBean does not exist");

        }

        MBeanOperationInfo[] opinfos = Arrays.stream(mBeanInfo.getOperations()).

                filter(a -> a.getName().equals(opstr)).toArray(MBeanOperationInfo[]::new);

        if (opinfos.length == 0) {

            throw new IllegalArgumentException("Invalid Operation String");

        }

        String[] signature = null;

        Object[] parameters = null;

        if (opinfos.length == 1) {

            MBeanParameterInfo[] sig = opinfos[0].getSignature();

            Map<String, MBeanParameterInfo> typeMap = new LinkedHashMap<>();

            Arrays.stream(sig).forEach(e -> typeMap.put(e.getName(), e));

            parameters = getParameters(params, typeMap).values().toArray();

            signature = Arrays.asList(sig).stream().map(a -> a.getType()).toArray(a -> new String[a]);

        } else if (opinfos.length > 1) {

            IllegalArgumentException exception = null;

            for (MBeanOperationInfo opInfo : opinfos) {

                MBeanParameterInfo[] sig = opInfo.getSignature();

                try {

                    Map<String, MBeanParameterInfo> typeMap = new LinkedHashMap<>();

                    Arrays.stream(sig).forEach(e -> typeMap.put(e.getName(), e));

                    parameters = getParameters(params, typeMap).values().toArray();

                    signature = Arrays.asList(sig).stream().map(a -> a.getType()).toArray(a -> new String[a]);

                    exception = null;

                    break;

                } catch (IllegalArgumentException ex) {

                    exception = ex;

                }

            }

            if (exception != null) {

                throw exception;

            }

        }

        Object invoke = null;

        try {

            invoke = mBeanServer.invoke(objectName, opstr, parameters, signature);

            if (invoke != null) {

                JSONMapper typeMapper = JSONMappingFactory.INSTANCE.getTypeMapper(invoke);

                if (typeMapper != null) {

                    return typeMapper.toJsonValue(invoke);

                } else {

                    return new JSONPrimitive("<Unable to map result to JSON>");

                }

            } else {

                return new JSONPrimitive("void");

            }

        } catch (JSONMappingException e) {

            return new JSONPrimitive("<Unable to map result to JSON>");

        }

    }

    private HttpResponse doMBeanInfo(HttpExchange exchange) {

        try {

            JSONObject mBeanInfo = getMBeanInfo(mBeanServer, objectName);

            return new HttpResponse(200, mBeanInfo.toJsonString());

        } catch (RuntimeOperationsException | IntrospectionException | ReflectionException e) {

            return new HttpResponse(HttpResponse.SERVER_ERROR, HttpResponse.getErrorMessage(e));

        } catch (InstanceNotFoundException e) {

            return new HttpResponse(HttpResponse.BAD_REQUEST, "Specified MBean does not exist");

        } catch (Exception e) {

            return new HttpResponse(HttpResponse.SERVER_ERROR, HttpResponse.getErrorMessage(e));

        }

    }

    @Override

    public void handle(HttpExchange exchange) throws IOException {

        String path = exchange.getRequestURI().getPath();

        if (path.matches(pathPrefix + "/?$")) {

            RestResource.super.handle(exchange);

        } else if (path.matches(pathPrefix + "/info$") && exchange.getRequestMethod().equalsIgnoreCase("GET")) {

            RestResource.super.handle(exchange);

        } else if (path.matches(pathPrefix + "/[^/]+/?$") && exchange.getRequestMethod().equalsIgnoreCase("POST")) {

            RestResource.super.handle(exchange);

        } else {

            HttpUtil.sendResponse(exchange, new HttpResponse(404, "Not found"));

        }

    }

    @Override

    public HttpResponse doGet(HttpExchange exchange) {

        if (exchange.getRequestURI().getPath().endsWith("info")) {

            return doMBeanInfo(exchange);

        }

        String path = PlatformRestAdapter.getAuthority() + exchange.getRequestURI().getPath().replaceAll("\\/$", "");

        String info = path + "/info";

        try {

            Map<String, Object> allAttributes = getAllAttributes();

            Map<String, String> _links = new LinkedHashMap<>();

            _links.put("info", HttpUtil.escapeUrl(info));

            MBeanOperationInfo[] opInfo = mBeanServer.getMBeanInfo(objectName).getOperations();

            JSONArray jarr = new JSONArray();

            for (MBeanOperationInfo op : opInfo) {

                JSONObject jobj1 = new JSONObject();

                JSONArray jarr1 = new JSONArray();

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

                jobj1.put("href", HttpUtil.escapeUrl(path + "/" + op.getName()));

                jobj1.put("method", "POST");

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

                    JSONObject jobj = new JSONObject();

                    jobj.put("name", paramInfo.getName());

                    jobj.put("type", paramInfo.getType());

                    jarr1.add(jobj);

                }

                jobj1.put("arguments", jarr1);

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

                jarr.add(jobj1);

            }

            JSONMapper typeMapper = JSONMappingFactory.INSTANCE.getTypeMapper(allAttributes);

            if (typeMapper != null) {

                JSONElement jsonElement1 = typeMapper.toJsonValue(allAttributes);

                JSONElement jsonElement2 = typeMapper.toJsonValue(_links);

                JSONObject jobj = new JSONObject();

                jobj.put("attributes", jsonElement1);

                jobj.put("operations", jarr);

                jobj.put("_links", jsonElement2);

                return new HttpResponse(200, jobj.toJsonString());

            } else {

                return new HttpResponse(HttpResponse.SERVER_ERROR, "Unable to find JSONMapper");

            }

        } catch (RuntimeOperationsException | IntrospectionException | ReflectionException | JSONMappingException e) {

            return new HttpResponse(HttpResponse.SERVER_ERROR, HttpResponse.getErrorMessage(e));

        } catch (InstanceNotFoundException e) {

            return new HttpResponse(HttpResponse.BAD_REQUEST, "Specified MBean does not exist");

        } catch (AttributeNotFoundException e) {

            return new HttpResponse(HttpResponse.BAD_REQUEST, "Specified Attribute does not exist");

        } catch (MBeanException e) {

            Throwable cause = e.getCause();

            return new HttpResponse(HttpResponse.SERVER_ERROR, HttpResponse.getErrorMessage(e));

        } catch (Exception e) {

            return new HttpResponse(HttpResponse.SERVER_ERROR, HttpResponse.getErrorMessage(e));

        }

    }

    /*

    HTTP POST for this MBean's URL allows setting of attributes and execution of operations.

    POST request body can follow one of the below formats

    1. { name : value}

    Set a single attribute

    2. { name1 : value1, name2 : value2 }

    Sets multiple attributes

    3. {attributes : {read : [name]} , {write : {name : value}}, operations : {op_name : {param_name:name, param_value:value}}}