/*
 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package jdk.internal.management.remote.rest.http;

import jdk.internal.management.remote.rest.json.JSONArray;
import jdk.internal.management.remote.rest.json.JSONElement;
import jdk.internal.management.remote.rest.json.JSONObject;
import jdk.internal.management.remote.rest.json.JSONPrimitive;
import jdk.internal.management.remote.rest.json.parser.JSONParser;
import jdk.internal.management.remote.rest.json.parser.ParseException;
import jdk.internal.management.remote.rest.mapper.JSONMapper;
import jdk.internal.management.remote.rest.mapper.JSONMappingException;
import jdk.internal.management.remote.rest.mapper.JSONMappingFactory;
import com.sun.net.httpserver.HttpExchange;

import javax.management.*;
import jdk.internal.management.remote.rest.PlatformRestAdapter;

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class MBeanCollectionResource implements RestResource, NotificationListener {

    private List<ObjectName> allowedMbeans;
    private final MBeanServer mBeanServer;
    private final Map<ObjectName, MBeanResource> mBeanResourceMap = new ConcurrentHashMap<>();
    private static final int pageSize = 10;
    private static final String pathPrefix = "^/?jmx/servers/[a-zA-Z0-9\\-\\.]+/mbeans";

    // Only MXBean or any other MBean that uses types
    // that have a valid mapper functions
    private boolean isMBeanAllowed(ObjectName objName) {
        try {
            MBeanInfo mInfo = mBeanServer.getMBeanInfo(objName);

            // Return true for MXbean
            Descriptor desc = mInfo.getDescriptor();
            String isMxBean = (String) desc.getFieldValue("mxbean");
            if (isMxBean != null && isMxBean.equalsIgnoreCase("true"))
                return true;

            // Check attribute types
            MBeanAttributeInfo[] attrsInfo = mInfo.getAttributes();
            for (MBeanAttributeInfo attrInfo : attrsInfo) {
                String type = attrInfo.getType();
                if (!JSONMappingFactory.INSTANCE.isTypeMapped(type)) {
                    return false;
                }
            }

            // Check operation parameters and return types
            MBeanOperationInfo[] operations = mInfo.getOperations();
            for (MBeanOperationInfo opInfo : operations) {
                MBeanParameterInfo[] signature = opInfo.getSignature();
                for (MBeanParameterInfo sig : signature) {
                    if (!JSONMappingFactory.INSTANCE.isTypeMapped(sig.getType())) {
                        return false;
                    }
                }
                if (!JSONMappingFactory.INSTANCE.isTypeMapped(opInfo.getReturnType())) {
                    return false;
                }
            }
            return true;
        } catch (InstanceNotFoundException | IntrospectionException |
                ReflectionException | ClassNotFoundException ex) {
            ex.printStackTrace();
            return false;
        }
    }

    private void introspectMBeanTypes(MBeanServer server) {
        if (allowedMbeans.isEmpty()) {
            Set<ObjectInstance> allMBeans = server.queryMBeans(null, null); // get all Mbeans
            allMBeans.stream().filter((objIns) -> (isMBeanAllowed(objIns.getObjectName())))
                    .forEachOrdered(objIns -> allowedMbeans.add(objIns.getObjectName()));
        }
    }

    @Override
    public void handleNotification(Notification notification, Object handback) {
        try {
            MBeanServerNotification mbs = (MBeanServerNotification) notification;
            if (MBeanServerNotification.REGISTRATION_NOTIFICATION.equals(mbs.getType())) {
                ObjectName mBeanName = mbs.getMBeanName();
                if (isMBeanAllowed(mBeanName)) {
                    allowedMbeans.add(mBeanName);
                }
            } else if (MBeanServerNotification.UNREGISTRATION_NOTIFICATION.equals(mbs.getType())) {
                if (allowedMbeans.contains(mbs.getMBeanName())) {
                    allowedMbeans.remove(mbs.getMBeanName());
                }
            }
        } catch (Exception e) {
        }
    }

    public MBeanCollectionResource(MBeanServer mBeanServer) {
        this.mBeanServer = mBeanServer;
        allowedMbeans = new ArrayList<>();
        introspectMBeanTypes(mBeanServer);
        allowedMbeans = new CopyOnWriteArrayList<>(allowedMbeans);

        // Create a REST handler for each MBean
        allowedMbeans.forEach(objectName -> mBeanResourceMap.put(objectName,
                new MBeanResource(mBeanServer, objectName)));
    }

    @Override
    public void handle(HttpExchange exchange) throws IOException {
        String path = URLDecoder.decode(exchange.getRequestURI().getPath(), StandardCharsets.UTF_8.name());

        if (path.matches(pathPrefix + "/?$")) {
            RestResource.super.handle(exchange);
        } else if (path.matches(pathPrefix + "/[^/]+/?.*")) {
            // Extract mbean name
            // Forward the request to its corresponding rest resource
            Pattern mbeans = Pattern.compile(pathPrefix + "/");
            Matcher matcher = mbeans.matcher(path);

            if (matcher.find()) {
                String ss = path.substring(matcher.end());
                String mBeanName = ss;
                if (ss.indexOf('/') != -1) {
                    mBeanName = ss.substring(0, ss.indexOf('/'));
                }
                try {
                    MBeanResource mBeanResource = mBeanResourceMap.get(new ObjectName(mBeanName));
                    if (mBeanResource == null) {
                        HttpUtil.sendResponse(exchange, HttpResponse.REQUEST_NOT_FOUND);
                        return;
                    }
                    mBeanResource.handle(exchange);
                } catch (MalformedObjectNameException e) {
                    HttpUtil.sendResponse(exchange, HttpResponse.BAD_REQUEST);
                }

            }
        }
    }

    @Override
    public HttpResponse doGet(HttpExchange exchange) {
        try {
            final String path = PlatformRestAdapter.getDomain()
                    + URLDecoder.decode(exchange.getRequestURI().getPath(), StandardCharsets.UTF_8.displayName())
                    .replaceAll("/$", "");
            List<ObjectName> filteredMBeans = allowedMbeans;
            Map<String, String> queryMap = HttpUtil.getGetRequestQueryMap(exchange);
            String query = exchange.getRequestURI().getQuery();
            if (query != null && queryMap.isEmpty()) {
                return new HttpResponse(HttpResponse.BAD_REQUEST,
                        "Invalid query params : Allowed query keys [objectname,page]");
            } else if (query != null && !queryMap.isEmpty()) {
                Map<String, String> newMap = new HashMap<>(queryMap);
                newMap.remove("objectname");
                newMap.remove("page");
                if (!newMap.isEmpty()) { // Invalid query params
                    return new HttpResponse(HttpResponse.BAD_REQUEST,
                            "Invalid query params : Allowed query keys [objectname,page]");
                }
            }
            if (queryMap.containsKey("objectname")) {        // Filter based on ObjectName query
                Set<ObjectName> queryMBeans = mBeanServer
                        .queryNames(new ObjectName(queryMap.get("objectname")), null);
                queryMBeans.retainAll(allowedMbeans);   // Intersection of two lists
                filteredMBeans = new ArrayList<>(queryMBeans);
            }

            JSONObject _links = HttpUtil.getPaginationLinks(exchange, filteredMBeans, pageSize);
            List<ObjectName> mbeanPage = HttpUtil.filterByPage(exchange, filteredMBeans, pageSize);

            List<Map<String, String>> items = new ArrayList<>(filteredMBeans.size());
            for (ObjectName objectName : mbeanPage) {
                Map<String, String> item = new LinkedHashMap<>();
                item.put("name", objectName.getCanonicalName());
                MBeanResource mBeanResource = mBeanResourceMap.get(objectName);
                try {
                    JSONObject mBeanInfo = mBeanResource.getMBeanInfo(mBeanServer, objectName);
                    JSONElement element = mBeanInfo.get("descriptor");
                    if (element != null) {
                        JSONElement element1 = ((JSONObject) element).get("interfaceClassName");
                        if (element1 != null) {
                            String intfName = (String) ((JSONPrimitive) element1).getValue();
                            item.put("interfaceClassName", intfName);
                        }
                    }
                    element = mBeanInfo.get("className");
                    if (element != null) {
                        String className = (String) ((JSONPrimitive) element).getValue();
                        item.put("className", className);
                    }
                    element = mBeanInfo.get("description");
                    if (element != null) {
                        String description = (String) ((JSONPrimitive) element).getValue();
                        item.put("description", description);
                    }
                    element = mBeanInfo.get("attributeInfo");
                    if (element != null) {
                        item.put("attributeCount", ((JSONArray) element).size() + "");
                    }
                    element = mBeanInfo.get("operationInfo");
                    if (element != null) {
                        item.put("operationCount", ((JSONArray) element).size() + "");
                    }

                } catch (InstanceNotFoundException | IntrospectionException | ReflectionException e) {
                }

                String href = path + "/" + objectName.toString();
                href = HttpUtil.escapeUrl(href);
                item.put("href", href);
                items.add(item);
                String info = HttpUtil.escapeUrl(href + "/info");
                item.put("info", info);
            }

            Map<String, String> properties = new HashMap<>();

            properties.put("mbeanCount", Integer.toString(filteredMBeans.size()));

            JSONMapper typeMapper1 = JSONMappingFactory.INSTANCE.getTypeMapper(items);
            JSONMapper typeMapper2 = JSONMappingFactory.INSTANCE.getTypeMapper(properties);

            JSONElement linkElem = typeMapper1.toJsonValue(items);
            JSONElement propElem = typeMapper2.toJsonValue(properties);
            JSONObject jobj = new JSONObject();

            jobj.putAll((JSONObject) propElem);
            jobj.put("mbeans", linkElem);

            if (_links != null && !_links.isEmpty()) {
                jobj.put("_links", _links);
            }
            return new HttpResponse(jobj.toJsonString());
        } catch (JSONMappingException e) {
            return HttpResponse.SERVER_ERROR;
        } catch (UnsupportedEncodingException e) {
            return HttpResponse.BAD_REQUEST;
        } catch (MalformedObjectNameException e) {
            return new HttpResponse(HttpResponse.BAD_REQUEST, "Invalid query string");
        }
    }

    @Override
    public HttpResponse doPost(HttpExchange exchange) {
        try {
            String path = URLDecoder.decode(exchange.getRequestURI().getPath(),StandardCharsets.UTF_8.displayName());
            String reqBody = null;
            if (path.matches(pathPrefix + "/?$")) { // POST to current URL
                reqBody = HttpUtil.readRequestBody(exchange);
                if (reqBody == null || reqBody.isEmpty()) { // No Parameters
                    return HttpResponse.BAD_REQUEST;
                }

                JSONParser parser = new JSONParser(reqBody);
                JSONElement jsonElement = parser.parse();
                if (!(jsonElement instanceof JSONObject)) {
                    return new HttpResponse(HttpResponse.BAD_REQUEST,
                            "Invalid parameters : [" + reqBody + "]");
                }

                JSONObject jsonObject = (JSONObject) jsonElement;
                JSONObject normalizedObject = new JSONObject(jsonObject);

                // Normalize the input MBean names
                for (String objectNameString : jsonObject.keySet()) {
                    if (!objectNameString.startsWith("?")) { // Ignore object name patterns
                        JSONElement element = jsonObject.get(objectNameString);
                        normalizedObject.remove(objectNameString);
                        normalizedObject.put(new ObjectName(objectNameString).getCanonicalName(), element);
                    }
                }

                jsonObject.clear();
                jsonObject = normalizedObject;

                Set<String> objectNamePatterns = jsonObject.keySet()
                        .stream()
                        .filter(a -> a.startsWith("?"))
                        .collect(Collectors.toSet());

                if (!objectNamePatterns.isEmpty()) {
                    for (String pattern : objectNamePatterns) {
                        Set<ObjectName> queryMBeans = mBeanServer
                                .queryNames(new ObjectName(pattern.substring(1)), null);
                        queryMBeans.retainAll(allowedMbeans);
                        JSONElement patternNode = jsonObject.get(pattern);
                        jsonObject.remove(pattern);
                        for (ObjectName queryMBean : queryMBeans) {
                            String name = queryMBean.getCanonicalName();
                            if (jsonObject.containsKey(name)) {
                                JSONObject obj = new JSONObject();
                                obj.put(name, patternNode);
                                deepMerge(jsonObject, obj);
                            } else {
                                jsonObject.put(name, patternNode);
                            }
                        }
                    }
                }

                JSONObject result = new JSONObject();
                for (String mBeanName : jsonObject.keySet()) {
                    MBeanResource mBeanResource = mBeanResourceMap.get(new ObjectName(mBeanName));
                    if (mBeanResource != null) {
                        JSONElement element = jsonObject.get(mBeanName);
                        if (element instanceof JSONObject) {
                            JSONElement res = mBeanResource.handleBulkRequest
                                    ((JSONObject) element);
                            result.put(mBeanName, res);
                        } else {
                            result.put(mBeanName, "Invalid input");
                        }
                    } else {
                        result.put(mBeanName, "Invalid MBean");
                    }
                }
                return new HttpResponse(result.toJsonString());
            } else {
                return HttpResponse.METHOD_NOT_ALLOWED;
            }
        } catch (ParseException e) {
            return new HttpResponse(HttpResponse.BAD_REQUEST, "Invalid JSON String for request body");
        } catch (IOException e) {
            return HttpResponse.BAD_REQUEST;
        } catch (MalformedObjectNameException e) {
            return new HttpResponse(HttpResponse.BAD_REQUEST, "Invalid query string");
        }
    }

    private JSONObject deepMerge(JSONObject jsonObject1, JSONObject jsonObject2) {
        for (String key : jsonObject2.keySet()) {
            if (jsonObject1.containsKey(key)) {
                if (jsonObject2.get(key) instanceof JSONObject && jsonObject1.get(key) instanceof JSONObject) {
                    JSONObject jobj1 = (JSONObject) jsonObject1.get(key);
                    JSONObject jobj2 = (JSONObject) jsonObject2.get(key);
                    jsonObject1.put(key, deepMerge(jobj1, jobj2));
                } else if (jsonObject2.get(key) instanceof JSONArray && jsonObject1.get(key) instanceof JSONArray) {
                    JSONArray array1 = (JSONArray) jsonObject1.get(key);
                    JSONArray array2 = (JSONArray) jsonObject2.get(key);
                    for (JSONElement each : array2) {
                        if (!array1.contains(each)) {
                            array1.add(each);
                        }
                    }
                } else {
                    JSONArray array = new JSONArray();
                    array.add(jsonObject1.get(key));
                    array.add(jsonObject2.get(key));
                    jsonObject1.put(key, array);
                }
            } else {
                jsonObject1.put(key, jsonObject2.get(key));
            }
        }
        return jsonObject1;
    }
}