/*
 * Copyright 2012-2017 Red Hat, Inc.
 *
 * This file is part of Thermostat.
 *
 * Thermostat is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published
 * by the Free Software Foundation; either version 2, or (at your
 * option) any later version.
 *
 * Thermostat 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 for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Thermostat; see the file COPYING.  If not see
 * <http://www.gnu.org/licenses/>.
 *
 * Linking this code with other modules is making a combined work
 * based on this code.  Thus, the terms and conditions of the GNU
 * General Public License cover the whole combination.
 *
 * As a special exception, the copyright holders of this code give
 * you permission to link this code with independent modules to
 * produce an executable, regardless of the license terms of these
 * independent modules, and to copy and distribute the resulting
 * executable under terms of your choice, provided that you also
 * meet, for each linked independent module, the terms and conditions
 * of the license of that module.  An independent module is a module
 * which is not derived from or based on this code.  If you modify
 * this code, you may extend this exception to your version of the
 * library, but you are not obligated to do so.  If you do not wish
 * to do so, delete this exception statement from your version.
 */

package com.redhat.thermostat.common.json;

import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;

import java.util.Map;
import java.util.NoSuchElementException;

/**
 * misc GSON utility classes
 */
public class JsonUtil {

    public static String capitalize(final String s) {
        return s.substring(0, 1).toUpperCase() + s.substring(1);
    }

    /**
     * access a nested JSON object via a path string<br>
     * "foo.bar.2.fred" is equivalent to<br>
     * root.getAsJsonObject().get("foo").getAsJsonObject().get("bar").getAsJsonArray().get(2).getAsJsonObject().get("fred")
     *
     * @param root object to access
     * @param path path into object
     * @return element within root
     */
    public static JsonElement fetch(final JsonElement root, final String path) {
        // NOTE - it would be nice to parse foo[N] to foo.N to allow normal subscripting
        return fetch(root, path, "[.]");
    }

    /**
     * access a nested JSON object via a path string<br>
     * "foo.bar.2.fred" is equivalent to<br>
     * root.getAsJsonObject().get("foo").getAsJsonObject().get("bar").getAsJsonArray().get(2).getAsJsonObject().get("fred")
     *
     * @param root      object to access
     * @param path      path into object
     * @param delimiter delimiter regex for path entries (default '.')
     * @return element within root
     */
    public static JsonElement fetch(final JsonElement root, final String path, final String delimiter) {
        String[] pathelements = path.split(delimiter);
        return fetch(root, pathelements, 0);
    }

    private static JsonElement fetch(final JsonElement e, final String[] pathelements, int idx) {
        if (idx == pathelements.length) {
            // we've fallen off the end of the input path - now it's time to return the current object.
            return e;
        } else if (idx > pathelements.length) {
            throw new IndexOutOfBoundsException("Internal error in JsonUtil.fetch() - index = " + idx);
        } else {
            if (e.isJsonObject()) {
                JsonObject obj = e.getAsJsonObject();
                JsonElement next = obj.get(pathelements[idx]);
                if (next == null) {
                    throw new NoSuchElementException(pathelements[idx]);
                } else {
                    return fetch(next, pathelements, idx + 1);
                }
            } else if (e.isJsonArray()) {
                JsonArray arr = e.getAsJsonArray();
                int n = Integer.parseInt(pathelements[idx]);
                if (arr.size() <= n) {
                    throw new ArrayIndexOutOfBoundsException(n);
                } else {
                    return fetch(arr.get(n), pathelements, idx + 1);
                }
            } else {
                throw new NoSuchElementException(pathelements[idx]);
            }
        }
    }

    /**
     * perform a deep copy of a JsonElement
     *
     * @param jsonElement element to copy
     * @return deep copy of the element tree
     */
    // why isn't JsonElement.deepCopy() public?
    public static JsonElement deepCopy(JsonElement jsonElement) {
        if (jsonElement.isJsonPrimitive() || jsonElement.isJsonNull()) {
            return jsonElement;       // these are immutables anyway
        } else if (jsonElement.isJsonObject()) {
            return deepCopy(jsonElement.getAsJsonObject());
        } else if (jsonElement.isJsonArray()) {
            return deepCopy(jsonElement.getAsJsonArray());
        } else {
            throw new UnsupportedOperationException("Unsupported element: " + jsonElement);
        }
    }

    private static JsonObject deepCopy(JsonObject jsonObject) {
        JsonObject result = new JsonObject();
        for (Map.Entry<String, JsonElement> entry : jsonObject.entrySet()) {
            result.add(entry.getKey(), deepCopy(entry.getValue()));
        }
        return result;
    }

    private static JsonArray deepCopy(JsonArray jsonArray) {
        JsonArray result = new JsonArray();
        for (JsonElement e : jsonArray) {
            result.add(deepCopy(e));
        }
        return result;
    }

    /**
     * add all properties from one object to another object
     * @param dest the destination object
     * @param src the source object
     * @param overwrite if true, overwrite existing elements with same key
     * @return dest, now with the union of (dest, src) members
     */
    public static JsonObject addAll(JsonObject dest, JsonObject src, boolean overwrite) {
        for (Map.Entry<String, JsonElement> entry : src.entrySet()) {
            if (overwrite || !dest.has(entry.getKey())) {
                dest.add(entry.getKey(), entry.getValue());
            }
        }
        return dest;
    }
}