package com.iddqd.doto.optimization;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;

import java.util.Set;

public class BandWidthOptimizer {

    private ObjectMapper mapper = new ObjectMapper();
    private JSONParser parser = new JSONParser();
    private String lastJSON = "{}";

    private String[] preserveKeys;

    public BandWidthOptimizer() {
        this.preserveKeys = new String[0];
    }

    public BandWidthOptimizer(String[] preserveKeys) {
        this.preserveKeys = preserveKeys;
    }

    public String optimize(Object obj) throws Exception {
        String json = mapper.writeValueAsString(obj);
        Object nobj = parser.parse(json);
        Object oobj = parser.parse(lastJSON);

        JSONObject newJsonObj = (JSONObject)nobj;
        JSONObject oldJsonObj = (JSONObject)oobj;

        JSONObject res = getJSONObjectDiff(newJsonObj, oldJsonObj);

        lastJSON = json;

        return res.toJSONString();
    }

    private JSONObject getJSONObjectDiff(JSONObject obj1, JSONObject obj2) {
        JSONObject res = new JSONObject();
        Set set = obj1.keySet();

        for (Object key : set) {
            // If doesn't exist put it in the diff
            if (!obj2.containsKey(key)) {
                res.put(key, obj1.get(key));
            } else {
                // Get the values from both objects
                Object val1 = obj1.get(key);
                Object val2 = obj2.get(key);
                // If their instances are of the same type
                if(val1 == null) {
                    continue;
                }
                if(val2 == null) {
                    res.put(key, val1);
                    continue;
                }
                if (val1.getClass().equals(val2.getClass())) {
                    // If they are JSONObject
                    if (val1 instanceof JSONObject) {
                        // Recursively parse JSONObject with all of it's properties
                        JSONObject nested = getJSONObjectDiff((JSONObject) obj1.get(key), (JSONObject) obj2.get(key));
                        // If it contains any keys
                        if(nested.keySet().size() > 0) {
                            // Store the diff into final diff
                            res.put(key, nested);
                        }
                    // If they are JSONArrays
                    } else if (val1 instanceof JSONArray) {
                        // If val1 contains some values (is not empty)
                        if(((JSONArray) val1).size() > 0) {
                            // Get their diff
                            JSONArray arr = getJSONArrayDiff((JSONArray) val1, (JSONArray) val2);
                            // If array is not empty
                            if (arr.size() > 0) {
                                // put it into the diff
                                res.put(key, arr);
                            }
                        }
                    // If they are just a pure values
                    } else {
                        // Compare them - If they're not equal
                        if(!val1.equals(val2)) {
                            // put the val1 into diff
                            res.put(key, val1);
                        }
                    }
                } else {
                    res.put(key, val1);
                }
            }
        }
        return res;
    }

    private JSONArray getJSONArrayDiff(JSONArray arr1, JSONArray arr2) {

        JSONArray res = new JSONArray();

        // For every element
        for(int i = 0; i < arr1.size(); i++) {
            Object val1 = arr1.get(i);
            // If i is out of arr2 bounds
            if(i > arr2.size()) {
                // put the arr1 item into the diff
                res.add(val1);
            }

            Object val2 = arr2.get(i);

            if(val1 == null) {
                continue;
            }

            if(val2 == null) {
                res.add(val1);
                continue;
            }

            // If their types are equal
            if(val1.getClass().equals(val2.getClass())) {
                // If they are JSONObjects
                if(val1 instanceof JSONObject) {
                    // Get their diff
                    JSONObject obj = getJSONObjectDiff((JSONObject) val1, (JSONObject) val2);
                    // If it contains any keys
                    if(obj.keySet().size() > 0) {
                        // Store the diff into final diff
                        res.add(obj);
                    }
                // If they are JSONArrays
                } else if (val1 instanceof JSONArray) {
                    // Get their diff
                    JSONArray arr = getJSONArrayDiff((JSONArray) val1, (JSONArray) val2);
                    // If array is not empty
                    if(arr.size() > 0) {
                        // put it into the diff
                        res.add(arr);
                    }
                // If they are just a pure values
                } else {
                    // Compare them - If they're not equal
                    if(val1 != val2) {
                        // add the val1 into diff
                        res.add(val1);
                    }
                }
            } else {
                res.add(val1);
            }
        }
        return res;
    }
}