/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.camel.commands.jolokia;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
import javax.management.InstanceNotFoundException;
import javax.management.ObjectName;

import org.apache.camel.commands.AbstractCamelController;

import org.jolokia.client.J4pClient;
import org.jolokia.client.exception.J4pException;
import org.jolokia.client.exception.J4pRemoteException;
import org.jolokia.client.request.J4pExecRequest;
import org.jolokia.client.request.J4pExecResponse;
import org.jolokia.client.request.J4pReadRequest;
import org.jolokia.client.request.J4pReadResponse;
import org.jolokia.client.request.J4pSearchRequest;
import org.jolokia.client.request.J4pSearchResponse;
import org.jolokia.client.request.J4pVersionRequest;
import org.jolokia.client.request.J4pVersionResponse;
import org.json.simple.JSONObject;

/**
 * A {@link org.apache.camel.commands.CamelController} that uses Jolokia Client to connect to remote JVMs which
 * has an Jolokia agent running.
 */
public class DefaultJolokiaCamelController extends AbstractCamelController implements JolokiaCamelController {

    private Map<String, ObjectName> cache = new HashMap<String, ObjectName>(100);

    private J4pClient jolokia;
    private String url;

    private ObjectName lookupCamelContext(String camelContextName) throws Exception {
        ObjectName on = cache.get(camelContextName);
        if (on == null) {
            ObjectName found = null;
            J4pSearchResponse sr = jolokia.execute(new J4pSearchRequest("*:type=context,*"));
            if (sr != null) {
                for (ObjectName name : sr.getObjectNames()) {
                    String id = name.getKeyProperty("name");
                    id = removeLeadingAndEndingQuotes(id);
                    if (camelContextName.equals(id)) {
                        found = name;
                        break;
                    }
                }
            }
            if (found != null) {
                on = found;
                cache.put(camelContextName, on);
            }
        }
        return on;
    }

    @Override
    public void using(J4pClient client) {
        this.jolokia = client;
        this.url = null;
    }

    @Override
    public void connect(String url, String username, String password) throws Exception {
        this.jolokia = JolokiaClientFactory.createJolokiaClient(url, username, password);
        this.url = url;
    }

    @Override
    public boolean ping() {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        J4pVersionResponse vr;
        try {
            vr = jolokia.execute(new J4pVersionRequest());
            return vr != null && vr.getValue() != null;
        } catch (J4pException e) {
            return false;
        }
    }

    @Override
    public Map<String, Object> getCamelContextInformation(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

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

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {

            String pattern = String.format("%s:context=%s,type=services,name=DefaultTypeConverter", found.getDomain(), found.getKeyProperty("context"));
            ObjectName tc = ObjectName.getInstance(pattern);

            String pattern2 = String.format("%s:context=%s,type=services,name=DefaultAsyncProcessorAwaitManager", found.getDomain(), found.getKeyProperty("context"));
            ObjectName am = ObjectName.getInstance(pattern2);

            List<J4pReadRequest> list = new ArrayList<J4pReadRequest>();
            list.add(new J4pReadRequest(found));
            list.add(new J4pReadRequest(tc));
            list.add(new J4pReadRequest(am));

            List<J4pReadResponse> rr = jolokia.execute(list);
            if (rr != null && rr.size() > 0) {
                // camel context attributes
                J4pReadResponse first = rr.get(0);
                for (String key : first.getAttributes()) {
                    answer.put(asKey(key), first.getValue(key));
                }

                // type converter attributes
                if (rr.size() >= 2) {
                    J4pReadResponse second = rr.get(1);
                    for (String key : second.getAttributes()) {
                        answer.put("typeConverter." + asKey(key), second.getValue(key));
                    }
                }

                // async processor await manager attributes
                if (rr.size() >= 3) {
                    J4pReadResponse second = rr.get(2);
                    for (String key : second.getAttributes()) {
                        answer.put("asyncProcessorAwaitManager." + asKey(key), second.getValue(key));
                    }
                }
            }

            // would be great if there was an api in jolokia to read optional (eg ignore if an mbean does not exists)
            answer.put("streamCachingEnabled", false);
            try {
                pattern = String.format("%s:context=%s,type=services,name=DefaultStreamCachingStrategy", found.getDomain(), found.getKeyProperty("context"));
                ObjectName sc = ObjectName.getInstance(pattern);

                // there is only a mbean if stream caching is enabled
                J4pReadResponse rsc = jolokia.execute(new J4pReadRequest(sc));
                if (rsc != null) {
                    for (String key : rsc.getAttributes()) {
                        answer.put("streamCaching." + asKey(key), rsc.getValue(key));
                    }
                }
                answer.put("streamCachingEnabled", true);
            } catch (J4pRemoteException e) {
                // ignore
                boolean ignore = InstanceNotFoundException.class.getName().equals(e.getErrorType());
                if (!ignore) {
                    throw e;
                }
            }

            // store some data using special names as that is what the core-commands expects
            answer.put("name", answer.get("camelId"));
            answer.put("status", answer.get("state"));
            answer.put("version", answer.get("camelVersion"));
            answer.put("suspended", "Suspended".equals(answer.get("state")));
            TimeUnit unit = TimeUnit.valueOf((String) answer.get("timeUnit"));
            long timeout = (Long) answer.get("timeout");
            answer.put("shutdownTimeout", "" + unit.toSeconds(timeout));
            answer.put("applicationContextClassLoader", answer.get("applicationContextClassName"));
        }

        return answer;
    }

    @Override
    public List<Map<String, String>> getCamelContexts() throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        List<Map<String, String>> answer = new ArrayList<Map<String, String>>();

        J4pSearchResponse sr = jolokia.execute(new J4pSearchRequest("*:type=context,*"));

        List<J4pReadRequest> list = new ArrayList<J4pReadRequest>();
        for (ObjectName on : sr.getObjectNames()) {
            list.add(new J4pReadRequest(on, "CamelId", "State", "Uptime", "ExchangesTotal", "ExchangesInflight", "ExchangesFailed"));
        }

        List<J4pReadResponse> lrr = jolokia.execute(list);
        for (J4pReadResponse rr : lrr) {
            Map<String, String> row = new LinkedHashMap<String, String>();
            row.put("name", rr.getValue("CamelId").toString());
            row.put("state", rr.getValue("State").toString());
            row.put("uptime", rr.getValue("Uptime").toString());
            row.put("exchangesTotal", rr.getValue("ExchangesTotal").toString());
            row.put("exchangesInflight", rr.getValue("ExchangesInflight").toString());
            row.put("exchangesFailed", rr.getValue("ExchangesFailed").toString());
            answer.add(row);
        }

        return answer;
    }

    @Override
    public String getCamelContextStatsAsXml(String camelContextName, boolean fullStats, boolean includeProcessors) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            J4pExecResponse er = jolokia.execute(new J4pExecRequest(found, "dumpRoutesStatsAsXml(boolean,boolean)", fullStats, includeProcessors));
            if (er != null) {
                String xml = er.getValue();
                return xml;
            }
        }

        return null;
    }

    @Override
    public List<Map<String, Object>> browseInflightExchanges(String camelContextName, int limit, boolean sortByLongestDuration) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        List<Map<String, Object>> answer = new ArrayList<Map<String, Object>>();

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=services,name=DefaultInflightRepository", found.getDomain(), found.getKeyProperty("context"));
            ObjectName on = ObjectName.getInstance(pattern);
            J4pExecResponse er = jolokia.execute(new J4pExecRequest(on, "browse(int,boolean)", limit, sortByLongestDuration));
            if (er != null) {
                JSONObject data = er.getValue();
                if (data != null) {
                    for (Object obj : data.values()) {
                        JSONObject inflight = (JSONObject) obj;

                        Map<String, Object> row = new LinkedHashMap<String, Object>();
                        row.put("exchangeId", asString(inflight.get("exchangeId")));
                        row.put("fromRouteId", asString(inflight.get("fromRouteId")));
                        row.put("routeId", asString(inflight.get("routeId")));
                        row.put("nodeId", asString(inflight.get("nodeId")));
                        row.put("elapsed", asString(inflight.get("elapsed")));
                        row.put("duration", asString(inflight.get("duration")));
                        answer.add(row);
                    }
                }
            }
        }

        return answer;
    }

    @Override
    public void startContext(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            jolokia.execute(new J4pExecRequest(found, "start"));
        }
    }

    @Override
    public void stopContext(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            jolokia.execute(new J4pExecRequest(found, "stop"));
        }
    }

    @Override
    public void suspendContext(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            jolokia.execute(new J4pExecRequest(found, "suspend"));
        }
    }

    @Override
    public void resumeContext(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            jolokia.execute(new J4pExecRequest(found, "resume"));
        }
    }

    @Override
    public List<Map<String, String>> getRoutes(String camelContextName) throws Exception {
        return getRoutes(camelContextName, null);
    }

    @Override
    public List<Map<String, String>> getRoutes(String camelContextName, String filter) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        List<Map<String, String>> answer = new ArrayList<Map<String, String>>();

        ObjectName found = camelContextName != null ? lookupCamelContext(camelContextName) : null;
        if (found != null) {

            String pattern = String.format("%s:context=%s,type=routes,*", found.getDomain(), found.getKeyProperty("context"));
            J4pSearchResponse sr = jolokia.execute(new J4pSearchRequest(pattern));

            List<J4pReadRequest> list = new ArrayList<J4pReadRequest>();
            for (ObjectName on : sr.getObjectNames()) {
                list.add(new J4pReadRequest(on, "CamelId", "RouteId", "State", "Uptime", "ExchangesTotal", "ExchangesInflight", "ExchangesFailed"));
            }

            List<J4pReadResponse> lrr = jolokia.execute(list);
            for (J4pReadResponse rr : lrr) {
                String routeId = rr.getValue("RouteId").toString();
                if (filter == null || routeId.matches(filter)) {
                    Map<String, String> row = new LinkedHashMap<String, String>();
                    row.put("camelContextName", rr.getValue("CamelId").toString());
                    row.put("routeId", routeId);
                    row.put("state", rr.getValue("State").toString());
                    row.put("uptime", rr.getValue("Uptime").toString());
                    row.put("exchangesTotal", rr.getValue("ExchangesTotal").toString());
                    row.put("exchangesInflight", rr.getValue("ExchangesInflight").toString());
                    row.put("exchangesFailed", rr.getValue("ExchangesFailed").toString());
                    answer.add(row);
                }
            }

        } else {
            List<Map<String, String>> camelContexts = this.getCamelContexts();
            for (Map<String, String> row : camelContexts) {
                List<Map<String, String>> routes = getRoutes(row.get("name"), filter);
                answer.addAll(routes);
            }
        }

        // sort the list
        Collections.sort(answer, new Comparator<Map<String, String>>() {
            @Override
            public int compare(Map<String, String> o1, Map<String, String> o2) {
                // group by camel context first, then by route name
                String c1 = o1.get("camelContextName");
                String c2 = o2.get("camelContextName");

                int answer = c1.compareTo(c2);
                if (answer == 0) {
                    // okay from same camel context, then sort by route id
                    answer = o1.get("routeId").compareTo(o2.get("routeId"));
                }
                return answer;
            }
        });
        return answer;
    }

    @Override
    public void resetRouteStats(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);

        if (found != null) {
            String pattern = String.format("%s:context=%s,type=routes,name=*", found.getDomain(), found.getKeyProperty("context"));
            J4pSearchResponse sr = jolokia.execute(new J4pSearchRequest(pattern));

            List<J4pExecRequest> list = new ArrayList<J4pExecRequest>();
            for (ObjectName on : sr.getObjectNames()) {
                list.add(new J4pExecRequest(on, "reset(boolean)", true));
            }

            jolokia.execute(list);
        }
    }

    @Override
    public void startRoute(String camelContextName, String routeId) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=routes,name=\"%s\"", found.getDomain(), found.getKeyProperty("context"), routeId);
            ObjectName on = ObjectName.getInstance(pattern);
            jolokia.execute(new J4pExecRequest(on, "start()"));
        }
    }

    @Override
    public void stopRoute(String camelContextName, String routeId) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=routes,name=\"%s\"", found.getDomain(), found.getKeyProperty("context"), routeId);
            ObjectName on = ObjectName.getInstance(pattern);
            jolokia.execute(new J4pExecRequest(on, "stop()"));
        }
    }

    @Override
    public void suspendRoute(String camelContextName, String routeId) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=routes,name=\"%s\"", found.getDomain(), found.getKeyProperty("context"), routeId);
            ObjectName on = ObjectName.getInstance(pattern);
            jolokia.execute(new J4pExecRequest(on, "suspend()"));
        }
    }

    @Override
    public void resumeRoute(String camelContextName, String routeId) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=routes,name=\"%s\"", found.getDomain(), found.getKeyProperty("context"), routeId);
            ObjectName on = ObjectName.getInstance(pattern);
            jolokia.execute(new J4pExecRequest(on, "resume()"));
        }
    }

    @Override
    public String getRouteModelAsXml(String routeId, String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=routes,name=\"%s\"", found.getDomain(), found.getKeyProperty("context"), routeId);
            ObjectName on = ObjectName.getInstance(pattern);
            J4pExecResponse response = jolokia.execute(new J4pExecRequest(on, "dumpRouteAsXml()"));
            if (response != null) {
                String xml = response.getValue();
                return xml;
            }
        }

        return null;
    }

    @Override
    public String getRouteStatsAsXml(String routeId, String camelContextName, boolean fullStats, boolean includeProcessors) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=routes,name=\"%s\"", found.getDomain(), found.getKeyProperty("context"), routeId);
            ObjectName on = ObjectName.getInstance(pattern);
            J4pExecResponse response = jolokia.execute(new J4pExecRequest(on, "dumpRouteStatsAsXml(boolean,boolean)", fullStats, includeProcessors));
            if (response != null) {
                String xml = response.getValue();
                return xml;
            }
        }

        return null;
    }

    @Override
    public String getRestModelAsXml(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            J4pExecResponse response = jolokia.execute(new J4pExecRequest(found, "dumpRestsAsXml()"));
            if (response != null) {
                String xml = response.getValue();
                return xml;
            }
        }

        return null;
    }

    @Override
    public String getRestApiDocAsJson(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=services,name=DefaultRestRegistry", found.getDomain(), found.getKeyProperty("context"));
            ObjectName on = ObjectName.getInstance(pattern);

            J4pExecResponse response = jolokia.execute(new J4pExecRequest(on, "apiDocAsJson()"));
            if (response != null) {
                String json = response.getValue();
                return json;
            }
        }

        return null;
    }

    @Override
    public List<Map<String, String>> getEndpoints(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        List<Map<String, String>> answer = new ArrayList<Map<String, String>>();

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=endpoints,*", found.getDomain(), found.getKeyProperty("context"));
            J4pSearchResponse sr = jolokia.execute(new J4pSearchRequest(pattern));

            List<J4pReadRequest> list = new ArrayList<J4pReadRequest>();
            for (ObjectName on : sr.getObjectNames()) {
                list.add(new J4pReadRequest(on, "CamelId", "EndpointUri", "State"));
            }

            List<J4pReadResponse> lrr = jolokia.execute(list);
            for (J4pReadResponse rr : lrr) {
                Map<String, String> row = new LinkedHashMap<String, String>();
                row.put("camelContextName", rr.getValue("CamelId").toString());
                row.put("uri", rr.getValue("EndpointUri").toString());
                row.put("state", rr.getValue("State").toString());
                answer.add(row);
            }
        }

        return answer;
    }

    @Override
    public List<Map<String, String>> getEndpointRuntimeStatistics(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        List<Map<String, String>> answer = new ArrayList<Map<String, String>>();

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=services,name=DefaultRuntimeEndpointRegistry", found.getDomain(), found.getKeyProperty("context"));
            ObjectName on = ObjectName.getInstance(pattern);

            J4pExecResponse response = jolokia.execute(new J4pExecRequest(on, "endpointStatistics()"));
            if (response != null) {
                JSONObject data = response.getValue();
                for (Object obj : data.values()) {
                    JSONObject data2 = (JSONObject) obj;
                    JSONObject service = (JSONObject) data2.values().iterator().next();

                    Map<String, String> row = new LinkedHashMap<String, String>();
                    row.put("index", asString(service.get("index")));
                    row.put("url", asString(service.get("url")));
                    row.put("routeId", asString(service.get("routeId")));
                    row.put("direction", asString(service.get("direction")));
                    row.put("static", asString(service.get("static")));
                    row.put("dynamic", asString(service.get("dynamic")));
                    row.put("hits", asString(service.get("hits")));
                    answer.add(row);
                }
            }

            // sort the list
            Collections.sort(answer, new Comparator<Map<String, String>>() {
                @Override
                public int compare(Map<String, String> endpoint1, Map<String, String> endpoint2) {
                    // sort by route id
                    String route1 = endpoint1.get("routeId");
                    String route2 = endpoint2.get("routeId");
                    int num = route1.compareTo(route2);
                    if (num == 0) {
                        // we want in before out
                        String dir1 = endpoint1.get("direction");
                        String dir2 = endpoint2.get("direction");
                        num = dir1.compareTo(dir2);
                    }
                    return num;
                }

            });
        }

        return answer;
    }

    @Override
    public List<Map<String, String>> getRestServices(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        List<Map<String, String>> answer = new ArrayList<Map<String, String>>();

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            String pattern = String.format("%s:context=%s,type=services,name=DefaultRestRegistry", found.getDomain(), found.getKeyProperty("context"));
            ObjectName on = ObjectName.getInstance(pattern);

            J4pExecResponse response = jolokia.execute(new J4pExecRequest(on, "listRestServices()"));
            if (response != null) {
                JSONObject data = response.getValue();
                if (data != null) {
                    for (Object obj : data.values()) {
                        JSONObject data2 = (JSONObject) obj;
                        JSONObject service = (JSONObject) data2.values().iterator().next();

                        Map<String, String> row = new LinkedHashMap<String, String>();
                        row.put("basePath", asString(service.get("basePath")));
                        row.put("baseUrl", asString(service.get("baseUrl")));
                        row.put("consumes", asString(service.get("consumes")));
                        row.put("description", asString(service.get("description")));
                        row.put("inType", asString(service.get("inType")));
                        row.put("method", asString(service.get("method")));
                        row.put("outType", asString(service.get("outType")));
                        row.put("produces", asString(service.get("produces")));
                        row.put("routeId", asString(service.get("routeId")));
                        row.put("state", asString(service.get("state")));
                        row.put("uriTemplate", asString(service.get("uriTemplate")));
                        row.put("url", asString(service.get("url")));
                        answer.add(row);
                    }
                }
            }

            // sort the list
            Collections.sort(answer, new Comparator<Map<String, String>>() {
                @Override
                public int compare(Map<String, String> service1, Map<String, String> service2) {
                    String url1 = service1.get("url");
                    String url2 = service2.get("url");
                    return url1.compareTo(url2);
                }
            });
        }

        return answer;
    }

    @Override
    public String explainEndpointAsJSon(String camelContextName, String uri, boolean allOptions) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            J4pExecResponse response = jolokia.execute(new J4pExecRequest(found, "explainEndpointJson(java.lang.String,boolean)", uri, allOptions));
            if (response != null) {
                String json = response.getValue();
                return json;
            }
        }

        return null;
    }

    @Override
    public String explainEipAsJSon(String camelContextName, String nameOrId, boolean allOptions) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            J4pExecResponse response = jolokia.execute(new J4pExecRequest(found, "explainEipJson(java.lang.String,boolean)", nameOrId, allOptions));
            if (response != null) {
                String json = response.getValue();
                return json;
            }
        }

        return null;
    }

    @Override
    public List<Map<String, String>> listComponents(String camelContextName) throws Exception {
        if (jolokia == null) {
            throw new IllegalStateException("Need to connect to remote jolokia first");
        }

        List<Map<String, String>> answer = new ArrayList<Map<String, String>>();

        ObjectName found = lookupCamelContext(camelContextName);
        if (found != null) {
            J4pExecResponse response = jolokia.execute(new J4pExecRequest(found, "listComponents()"));
            if (response != null) {
                JSONObject data = response.getValue();
                for (Object obj : data.values()) {
                    JSONObject component = (JSONObject) obj;

                    Map<String, String> row = new LinkedHashMap<String, String>();
                    row.put("artifactId", asString(component.get("artifactId")));
                    row.put("title", asString(component.get("title")));
                    row.put("description", asString(component.get("description")));
                    row.put("groupId", asString(component.get("groupId")));
                    row.put("label", asString(component.get("label")));
                    row.put("name", asString(component.get("name")));
                    row.put("status", asString(component.get("status")));
                    row.put("type", asString(component.get("type")));
                    row.put("version", asString(component.get("version")));
                    answer.add(row);
                }
            }

            // sort the list
            Collections.sort(answer, new Comparator<Map<String, String>>() {
                @Override
                public int compare(Map<String, String> component1, Map<String, String> component2) {
                    String name1 = component1.get("name");
                    String name2 = component2.get("name");
                    return name1.compareTo(name2);
                }
            });
        }

        return answer;
    }

    private static String asKey(String attributeKey) {
        char ch = Character.toLowerCase(attributeKey.charAt(0));
        return ch + attributeKey.substring(1);
    }

    private static String asString(Object basePath) {
        if (basePath == null) {
            return null;
        } else {
            return basePath.toString();
        }
    }

    private static String removeLeadingAndEndingQuotes(String s) {
        if (s == null || s.isEmpty()) {
            return s;
        }

        String copy = s.trim();
        if (copy.startsWith("'") && copy.endsWith("'")) {
            return copy.substring(1, copy.length() - 1);
        }
        if (copy.startsWith("\"") && copy.endsWith("\"")) {
            return copy.substring(1, copy.length() - 1);
        }

        // no quotes, so return as-is
        return s;
    }

}