/*
 * 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.netbeans.lib.v8debug;

import java.util.Map;
import org.json.simple.JSONArray;
import org.json.simple.JSONAware;
import org.json.simple.JSONObject;
import static org.netbeans.lib.v8debug.JSONConstants.*;
import org.netbeans.lib.v8debug.commands.Backtrace;
import org.netbeans.lib.v8debug.commands.ChangeBreakpoint;
import org.netbeans.lib.v8debug.commands.ChangeLive;
import org.netbeans.lib.v8debug.commands.ClearBreakpoint;
import org.netbeans.lib.v8debug.commands.ClearBreakpointGroup;
import org.netbeans.lib.v8debug.commands.Continue;
import org.netbeans.lib.v8debug.commands.Evaluate;
import org.netbeans.lib.v8debug.commands.Flags;
import org.netbeans.lib.v8debug.commands.Frame;
import org.netbeans.lib.v8debug.commands.GC;
import org.netbeans.lib.v8debug.commands.ListBreakpoints;
import org.netbeans.lib.v8debug.commands.Lookup;
import org.netbeans.lib.v8debug.commands.References;
import org.netbeans.lib.v8debug.commands.RestartFrame;
import org.netbeans.lib.v8debug.commands.Scope;
import org.netbeans.lib.v8debug.commands.Scopes;
import org.netbeans.lib.v8debug.commands.Scripts;
import org.netbeans.lib.v8debug.commands.SetBreakpoint;
import org.netbeans.lib.v8debug.commands.SetExceptionBreak;
import org.netbeans.lib.v8debug.commands.SetVariableValue;
import org.netbeans.lib.v8debug.commands.Source;
import org.netbeans.lib.v8debug.commands.Threads;
import org.netbeans.lib.v8debug.commands.V8Flags;
import org.netbeans.lib.v8debug.commands.Version;
import org.netbeans.lib.v8debug.connection.LinkedJSONObject;
import org.netbeans.lib.v8debug.events.AfterCompileEventBody;
import org.netbeans.lib.v8debug.events.BreakEventBody;
import org.netbeans.lib.v8debug.events.CompileErrorEventBody;
import org.netbeans.lib.v8debug.events.ExceptionEventBody;
import org.netbeans.lib.v8debug.events.ScriptCollectedEventBody;
import org.netbeans.lib.v8debug.vars.NewValue;
import org.netbeans.lib.v8debug.vars.ReferencedValue;
import org.netbeans.lib.v8debug.vars.V8Boolean;
import org.netbeans.lib.v8debug.vars.V8Function;
import org.netbeans.lib.v8debug.vars.V8Generator;
import org.netbeans.lib.v8debug.vars.V8Number;
import org.netbeans.lib.v8debug.vars.V8Object;
import org.netbeans.lib.v8debug.vars.V8ScriptValue;
import org.netbeans.lib.v8debug.vars.V8String;
import org.netbeans.lib.v8debug.vars.V8Value;

/**
 * Translator of Java API classes into the corresponding JSON objects.
 * 
 * @author Martin Entlicher
 */
@SuppressWarnings("unchecked")
public class JSONWriter {
    
    private JSONWriter() {}
    
    public static JSONObject store(V8Request request) {
        JSONObject obj = newJSONObject();
        obj.put(SEQ, request.getSequence());
        obj.put(TYPE, V8Type.request.toString());
        V8Command command = request.getCommand();
        obj.put(COMMAND, command.toString());
        V8Arguments arguments = request.getArguments();
        if (arguments != null) {
            obj.put(ARGUMENTS, store(command, arguments));
        }
        return obj;
    }
    
    public static JSONObject store(V8Response response) {
        JSONObject obj = newJSONObject();
        obj.put(SEQ, response.getSequence());
        obj.put(SEQ_REQUEST, response.getRequestSequence());
        obj.put(TYPE, V8Type.response.toString());
        V8Command command = response.getCommand();
        obj.put(COMMAND, command.toString());
        boolean success = response.isSuccess();
        obj.put(SUCCESS, success);
        if (success) {
            V8Body body = response.getBody();
            if (body != null) {
                obj.put(BODY, store(command, body));
            }
        } else {
            obj.put(MESSAGE, response.getErrorMessage());
        }
        ReferencedValue[] referencedValues = response.getReferencedValues();
        if (referencedValues != null) {
            obj.put(REFS, store(referencedValues));
        }
        obj.put(RUNNING, response.isRunning());
        return obj;
    }
    
    public static JSONObject store(V8Event event) {
        JSONObject obj = newJSONObject();
        obj.put(SEQ, event.getSequence());
        obj.put(TYPE, V8Type.event.toString());
        V8Event.Kind eventKind = event.getKind();
        obj.put(EVENT, eventKind.toString());
        V8Body body = event.getBody();
        JSONObject bodyObj = newJSONObject();
        switch (eventKind) {
            case AfterCompile:
                AfterCompileEventBody aceb = (AfterCompileEventBody) body;
                bodyObj.put(EVT_SCRIPT, store(aceb.getScript()));
                break;
            case CompileError:
                CompileErrorEventBody ceeb = (CompileErrorEventBody) body;
                bodyObj.put(EVT_SCRIPT, store(ceeb.getScript()));
                break;
            case ScriptCollected:
                ScriptCollectedEventBody sceb = (ScriptCollectedEventBody) body;
                bodyObj.put(EVT_SCRIPT, sceb.getScriptId());
                break;
            case Break:
                BreakEventBody beb = (BreakEventBody) body;
                storeIf(beb.getInvocationText(), bodyObj, EVT_INVOCATION_TEXT);
                bodyObj.put(EVT_SOURCE_LINE, beb.getSourceLine());
                bodyObj.put(EVT_SOURCE_COLUMN, beb.getSourceColumn());
                storeIf(beb.getSourceLineText(), bodyObj, EVT_SOURCE_LINE_TEXT);
                V8ScriptLocation scriptLocation = beb.getScript();
                if (scriptLocation != null) {
                    bodyObj.put(EVT_SCRIPT, store(scriptLocation));
                }
                long[] breakpoints = beb.getBreakpoints();
                if (breakpoints != null) {
                    bodyObj.put(EVT_BREAKPOINTS, array(breakpoints));
                }
                break;
            case Exception:
                ExceptionEventBody eeb = (ExceptionEventBody) body;
                bodyObj.put(EVT_UNCAUGHT, eeb.isUncaught());
                bodyObj.put(EVT_EXCEPTION, store(eeb.getException()));
                bodyObj.put(EVT_SOURCE_LINE, eeb.getSourceLine());
                bodyObj.put(EVT_SOURCE_COLUMN, eeb.getSourceColumn());
                storeIf(eeb.getSourceLineText(), bodyObj, EVT_SOURCE_LINE_TEXT);
                bodyObj.put(EVT_SCRIPT, store(eeb.getScript(), false));
                break;
            default:
                throw new IllegalArgumentException("Unknown event kind: "+eventKind);
        }
        if (event.getSuccess().hasValue()) {
            obj.put(SUCCESS, event.getSuccess().getValue());
        }
        obj.put(BODY, bodyObj);
        ReferencedValue[] referencedValues = event.getReferencedValues();
        if (referencedValues != null) {
            obj.put(REFS, store(referencedValues));
        }
        PropertyBoolean running = event.isRunning();
        if (running.hasValue()) {
            obj.put(RUNNING, running.getValue());
        }
        return obj;
    }
    
    private static JSONObject newJSONObject() {
        return new LinkedJSONObject();
    }
    
    private static Object store(V8Command command, V8Arguments arguments) {
        JSONObject obj = newJSONObject();
        switch(command) {
            case Backtrace:
                Backtrace.Arguments btargs = (Backtrace.Arguments) arguments;
                storeIf(btargs.getFromFrame(), obj, FROM_FRAME);
                storeIf(btargs.getToFrame(), obj, TO_FRAME);
                storeIf(btargs.isBottom(), obj, BOTTOM);
                storeIf(btargs.isInlineRefs(), obj, INLINE_REFS);
                return obj;
            case Continue:
                Continue.Arguments cargs = (Continue.Arguments) arguments;
                obj.put(ARGS_STEP_ACTION, cargs.getStepAction().toString());
                storeIf(cargs.getStepCount(), obj, ARGS_STEP_COUNT);
                return obj;
            case Setbreakpoint:
                SetBreakpoint.Arguments sbargs = (SetBreakpoint.Arguments) arguments;
                String bpType;
                if (V8Breakpoint.Type.scriptName.equals(sbargs.getType())) {
                    bpType = "script";
                } else {
                    bpType = sbargs.getType().toString();
                }
                obj.put(TYPE, bpType);
                obj.put(TARGET, sbargs.getTarget());
                storeIf(sbargs.getLine(), obj, LINE);
                storeIf(sbargs.getColumn(), obj, COLUMN);
                storeIf(sbargs.isEnabled(), obj, BREAK_ENABLED);
                storeIf(sbargs.getCondition(), obj, BREAK_CONDITION);
                storeIf(sbargs.getIgnoreCount(), obj, BREAK_IGNORE_COUNT);
                storeIf(sbargs.getGroupId(), obj, BREAK_GROUP_ID);
                return obj;
            case Changebreakpoint:
                ChangeBreakpoint.Arguments chbargs = (ChangeBreakpoint.Arguments) arguments;
                obj.put(BREAK_POINT, chbargs.getBreakpoint());
                storeIf(chbargs.isEnabled(), obj, BREAK_ENABLED);
                obj.put(BREAK_CONDITION, chbargs.getCondition());
                storeIf(chbargs.getIgnoreCount(), obj, BREAK_IGNORE_COUNT);
                return obj;
            case Clearbreakpoint:
                ClearBreakpoint.Arguments cbargs = (ClearBreakpoint.Arguments) arguments;
                obj.put(BREAK_POINT, cbargs.getBreakpoint());
                return obj;
            case Clearbreakpointgroup:
                ClearBreakpointGroup.Arguments cbgargs = (ClearBreakpointGroup.Arguments) arguments;
                obj.put(BREAK_GROUP_ID, cbgargs.getGroupId());
                return obj;
            case Setexceptionbreak:
                SetExceptionBreak.Arguments sebargs = (SetExceptionBreak.Arguments) arguments;
                obj.put(TYPE, sebargs.getType().toString());
                obj.put(BREAK_ENABLED, sebargs.isEnabled());
                return obj;
            case Evaluate:
                Evaluate.Arguments eargs = (Evaluate.Arguments) arguments;
                obj.put(EVAL_EXPRESSION, eargs.getExpression());
                storeIf(eargs.getFrame(), obj, FRAME);
                storeIf(eargs.isGlobal(), obj, EVAL_GLOBAL);
                storeIf(eargs.isDisableBreak(), obj, EVAL_DISABLE_BREAK);
                JSONArray additionalContexts = store(eargs.getAdditionalContext());
                if (additionalContexts != null) {
                    obj.put(EVAL_ADDITIONAL_CONTEXT, additionalContexts);
                }
                return obj;
            case Frame:
                Frame.Arguments fargs = (Frame.Arguments) arguments;
                storeIf(fargs.getFrameNumber(), obj, NUMBER);
                return obj;
            case Restartframe:
                RestartFrame.Arguments ra = (RestartFrame.Arguments) arguments;
                PropertyLong frame = ra.getFrame();
                if (frame.hasValue()) {
                    obj.put(FRAME, frame.getValue());
                }
                return obj;
            case Lookup:
                Lookup.Arguments largs = (Lookup.Arguments) arguments;
                obj.put(HANDLES, array(largs.getHandles()));
                storeIf(largs.isIncludeSource(), obj, INCLUDE_SOURCE);
                return obj;
            case References:
                References.Arguments rargs = (References.Arguments) arguments;
                obj.put(TYPE, rargs.getType().name());
                obj.put(HANDLE, rargs.getHandle());
                return obj;
            case Scope:
                Scope.Arguments sargs = (Scope.Arguments) arguments;
                obj.put(NUMBER, sargs.getScopeNumber());
                storeIf(sargs.getFrameNumber(), obj, FRAME_NUMBER);
                return obj;
            case Scopes:
                Scopes.Arguments ssargs = (Scopes.Arguments) arguments;
                storeIf(ssargs.getFrameNumber(), obj, FRAME_NUMBER);
                return obj;
            case Scripts:
                Scripts.Arguments scargs = (Scripts.Arguments) arguments;
                if (scargs.getTypes() != null) {
                    obj.put(TYPES, scargs.getTypes().getIntTypes());
                }
                if (scargs.getIds() != null) {
                    obj.put(IDs, array(scargs.getIds()));
                }
                storeIf(scargs.isIncludeSource(), obj, INCLUDE_SOURCE);
                storeIf(scargs.getNameFilter(), obj, FILTER);
                storeIf(scargs.getIdFilter(), obj, FILTER);
                return obj;
            case Source:
                Source.Arguments srcargs = (Source.Arguments) arguments;
                storeIf(srcargs.getFrame(), obj, FRAME);
                storeIf(srcargs.getFromLine(), obj, FROM_LINE);
                storeIf(srcargs.getToLine(), obj, TO_LINE);
                return obj;
            case SetVariableValue:
                SetVariableValue.Arguments svargs = (SetVariableValue.Arguments) arguments;
                obj.put(NAME, svargs.getName());
                obj.put(NEW_VALUE, store(svargs.getNewValue()));
                JSONObject scope = newJSONObject();
                scope.put(NUMBER, svargs.getScopeNumber());
                storeIf(svargs.getScopeFrameNumber(), scope, FRAME_NUMBER);
                obj.put(SCOPE, scope);
                return obj;
            case Changelive:
                ChangeLive.Arguments chlargs = (ChangeLive.Arguments) arguments;
                obj.put(SCRIPT_ID, chlargs.getScriptId());
                storeIf(chlargs.isPreviewOnly(), obj, PREVIEW_ONLY);
                obj.put(NEW_SOURCE, chlargs.getNewSource());
                return obj;
            case Gc:
                GC.Arguments gcargs = (GC.Arguments) arguments;
                obj.put(TYPE, gcargs.getType());
                return obj;
            case V8flags:
                V8Flags.Arguments v8flargs = (V8Flags.Arguments) arguments;
                obj.put(FLAGS, v8flargs.getFlags());
                return obj;
            case Flags:
                Flags.Arguments flargs = (Flags.Arguments) arguments;
                Map<String, Boolean> flags = flargs.getFlags();
                if (flags != null) {
                    JSONArray arr = new JSONArray();
                    for (Map.Entry<String, Boolean> flagEntry : flags.entrySet()) {
                        JSONObject f = newJSONObject();
                        f.put(NAME, flagEntry.getKey());
                        f.put(VALUE, flagEntry.getValue());
                        arr.add(f);
                    }
                    obj.put(FLAGS, arr);
                }
                return obj;
            default:
                return null;
        }
    }
    
    private static JSONAware store(V8Command command, V8Body body) {
        switch (command) {
            case Listbreakpoints:
                JSONObject obj = newJSONObject();
                ListBreakpoints.ResponseBody lbrb = (ListBreakpoints.ResponseBody) body;
                obj.put(BREAK_POINTS, store(lbrb.getBreakpoints()));
                obj.put(BREAK_ON_EXCEPTIONS, lbrb.isBreakOnExceptions());
                obj.put(BREAK_ON_UNCAUGHT_EXCEPTIONS, lbrb.isBreakOnUncaughtExceptions());
                return obj;
            case Setbreakpoint:
                obj = newJSONObject();
                SetBreakpoint.ResponseBody sbrb = (SetBreakpoint.ResponseBody) body;
                obj.put(TYPE, sbrb.getType().toString());
                obj.put(BREAK_POINT, sbrb.getBreakpoint());
                if (V8Breakpoint.Type.scriptId.equals(sbrb.getType())) {
                    storeIf(sbrb.getScriptName(), obj, SCRIPT_ID);
                } else {
                    storeIf(sbrb.getScriptName(), obj, SCRIPT_NAME);
                }
                obj.put(LINE, getLongOrNull(sbrb.getLine()));
                obj.put(COLUMN, getLongOrNull(sbrb.getColumn()));
                obj.put(BREAK_ACTUAL_LOCATIONS, store(sbrb.getActualLocations()));
                return obj;
            case Setexceptionbreak:
                obj = newJSONObject();
                SetExceptionBreak.ResponseBody sebrb = (SetExceptionBreak.ResponseBody) body;
                obj.put(TYPE, sebrb.getType().toString());
                obj.put(BREAK_ENABLED, sebrb.isEnabled());
                return obj;
            case Clearbreakpoint:
                obj = newJSONObject();
                ClearBreakpoint.ResponseBody cbrb = (ClearBreakpoint.ResponseBody) body;
                obj.put(BREAK_POINT, cbrb.getBreakpoint());
                return obj;
            case Clearbreakpointgroup:
                obj = newJSONObject();
                ClearBreakpointGroup.ResponseBody cbgrb = (ClearBreakpointGroup.ResponseBody) body;
                obj.put(BREAK_POINTS, array(cbgrb.getBreakpointsCleared()));
                return obj;
            case Backtrace:
                obj = newJSONObject();
                Backtrace.ResponseBody brb = (Backtrace.ResponseBody) body;
                obj.put(FROM_FRAME, brb.getFromFrame());
                obj.put(TO_FRAME, brb.getToFrame());
                obj.put(TOTAL_FRAMES, brb.getTotalFrames());
                if (brb.getFrames() != null) {
                    obj.put(FRAMES, store(brb.getFrames()));
                }
                return obj;
            case Frame:
                Frame.ResponseBody frb = (Frame.ResponseBody) body;
                obj = store(frb.getFrame());
                return obj;
            case Restartframe:
                obj = newJSONObject();
                RestartFrame.ResponseBody rfrb = (RestartFrame.ResponseBody) body;
                obj.put(RESULT, store(rfrb.getResult()));
                return obj;
            case Changelive:
                obj = newJSONObject();
                ChangeLive.ResponseBody clrb = (ChangeLive.ResponseBody) body;
                obj.put(CHANGE_LOG, store(clrb.getChangeLog()));
                obj.put(RESULT, store(clrb.getResult()));
                storeIf(clrb.getStepInRecommended(), obj, STEP_IN_RECOMMENDED);
                return obj;
            case Lookup:
                Lookup.ResponseBody lrb = (Lookup.ResponseBody) body;
                obj = storeValues(lrb.getValuesByHandle());
                return obj;
            case Evaluate:
                Evaluate.ResponseBody erb = (Evaluate.ResponseBody) body;
                obj = store(erb.getValue());
                return obj;
            case References:
                References.ResponseBody rrb = (References.ResponseBody) body;
                JSONArray arrayRefs = new JSONArray();
                for (V8Value vr : rrb.getReferences()) {
                    arrayRefs.add(store(vr));
                }
                return arrayRefs;
            case Scripts:
                Scripts.ResponseBody scrrb = (Scripts.ResponseBody) body;
                return store(scrrb.getScripts());
            case SetVariableValue:
                obj = newJSONObject();
                SetVariableValue.ResponseBody svvrb = (SetVariableValue.ResponseBody) body;
                obj.put(NEW_VALUE, store(svvrb.getNewValue()));
                return obj;
            case Scope:
                Scope.ResponseBody srb = (Scope.ResponseBody) body;
                obj = store(srb.getScope());
                return obj;
            case Scopes:
                obj = newJSONObject();
                Scopes.ResponseBody ssrb = (Scopes.ResponseBody) body;
                obj.put(FROM_SCOPE, ssrb.getFromScope());
                obj.put(TO_SCOPE, ssrb.getToScope());
                obj.put(TOTAL_SCOPES, ssrb.getTotalScopes());
                obj.put(SCOPES, store(ssrb.getScopes()));
                return obj;
            case Source:
                obj = newJSONObject();
                Source.ResponseBody srcrb = (Source.ResponseBody) body;
                storeIf(srcrb.getSource(), obj, SOURCE);
                obj.put(FROM_LINE, srcrb.getFromLine());
                obj.put(TO_LINE, srcrb.getToLine());
                obj.put(FROM_POSITION, srcrb.getFromPosition());
                obj.put(TO_POSITION, srcrb.getToPosition());
                obj.put(TOTAL_LINES, srcrb.getTotalLines());
                return obj;
            case Threads:
                obj = newJSONObject();
                Threads.ResponseBody trb = (Threads.ResponseBody) body;
                obj.put(TOTAL_THREADS, trb.getNumThreads());
                obj.put(THREADS, storeThreads(trb.getIds()));
                return obj;
            case Gc:
                obj = newJSONObject();
                GC.ResponseBody gcrb = (GC.ResponseBody) body;
                obj.put(GC_BEFORE, gcrb.getBefore());
                obj.put(GC_AFTER, gcrb.getAfter());
                return obj;
            case Version:
                obj = newJSONObject();
                Version.ResponseBody vrb = (Version.ResponseBody) body;
                obj.put(BODY_VERSION, vrb.getVersion());
                return obj;
            case Flags:
                obj = newJSONObject();
                Flags.ResponseBody flrb = (Flags.ResponseBody) body;
                obj.put(FLAGS, storeFlags(flrb.getFlags()));
                return obj;
        }
        return null;
    }
    
    private static Object getLongOrNull(PropertyLong pl) {
        if (pl.hasValue()) {
            return pl.getValue();
        } else {
            return null;
        }
    }
    
    private static JSONArray store(ReferencedValue[] rvs) {
        JSONArray array = new JSONArray();
        for (ReferencedValue rv : rvs) {
            array.add(store(rv, false, false));
        }
        return array;
    }
    
    private static JSONObject store(ReferencedValue rv, boolean storeRefNotHandle, boolean noTextAndLength) {
        JSONObject obj = newJSONObject();
        //obj.put(REF, rv.getReference());
        if (rv.hasValue()) {
            if (storeRefNotHandle) {
                obj.put(REF, rv.getReference());
                store(rv.getValue(), obj, false, noTextAndLength);
            } else {
                store(rv.getValue(), obj, true, noTextAndLength);
            }
        } else {
            obj.put(REF, rv.getReference());
        }
        return obj;
    }
    
    private static JSONArray store(V8Script[] scripts) {
        JSONArray array = new JSONArray();
        for (V8Script scr : scripts) {
            array.add(store(scr));
        }
        return array;
    }
    
    private static JSONObject store(V8Script script) {
        return store(script, true);
    }
    
    private static JSONObject store(V8Script script, boolean storeHandle) {
        JSONObject obj = newJSONObject();
        storeTo(script, obj, storeHandle);
        return obj;
    }
    
    private static void storeTo(V8Script script, JSONObject obj, boolean storeHandle) {
        if (storeHandle) {
            obj.put(HANDLE, script.getHandle());
            obj.put(TYPE, script.getType().toString());
        }
        if (storeHandle) {
            if (script.getName() != null) {
                obj.put(NAME, script.getName());
            }
            obj.put(ID, script.getId());
        } else { // Just different order for easy comparison with V8 debug protocol.
            obj.put(ID, script.getId());
            if (script.getName() != null) {
                obj.put(NAME, script.getName());
            }
        }
        obj.put(SCRIPT_LINE_OFFSET, script.getLineOffset());
        obj.put(SCRIPT_COLUMN_OFFSET, script.getColumnOffset());
        obj.put(SCRIPT_LINE_COUNT, script.getLineCount());
        if (script.getData() != null) {
            obj.put(DATA, script.getData());
        }
        storeIf(script.getSource(), obj, SOURCE);
        storeIf(script.getSourceStart(), obj, SOURCE_START);
        storeIf(script.getSourceLength(), obj, SOURCE_LENGTH);
        V8Script.Type scriptType = script.getScriptType();
        if (scriptType != null) {
            obj.put(SCRIPT_TYPE, scriptType.ordinal());
        }
        V8Script.CompilationType compilationType = script.getCompilationType();
        if (compilationType != null) {
            obj.put(COMPILATION_TYPE, compilationType.ordinal());
        }
        storeIf(script.getContext(), obj, CONTEXT);
        if (script.getText() != null) {
            obj.put(TEXT, script.getText());
        }
        storeIf(script.getEvalFromScript(), obj, EVAL_FROM_SCRIPT);
        if (V8Script.CompilationType.EVAL.equals(compilationType) && script.getEvalFromLocation() != null) {
            obj.put(LINE, script.getEvalFromLocation().getLine());
            obj.put(COLUMN, script.getEvalFromLocation().getColumn());
        }
    }
    
    private static JSONObject store(V8ScriptLocation scriptLocation) {
        JSONObject obj = newJSONObject();
        obj.put(ID, scriptLocation.getId());
        obj.put(NAME, scriptLocation.getName());
        obj.put(SCRIPT_LINE_OFFSET, scriptLocation.getLine());
        obj.put(SCRIPT_COLUMN_OFFSET, scriptLocation.getColumn());
        obj.put(SCRIPT_LINE_COUNT, scriptLocation.getLineCount());
        return obj;
    }
    
    private static JSONArray store(V8Breakpoint[] breakpoints) {
        JSONArray array = new JSONArray();
        for (V8Breakpoint bp : breakpoints) {
            array.add(store(bp));
        }
        return array;
    }
    
    private static JSONObject store(V8Breakpoint bp) {
        JSONObject obj = newJSONObject();
        obj.put(NUMBER, bp.getNumber());
        storeIf(bp.getLine(), obj, LINE);
        //storeIf(bp.getColumn(), obj, COLUMN);
        obj.put(COLUMN, getLongOrNull(bp.getColumn()));
        PropertyLong groupId = bp.getGroupId();
        obj.put(BREAK_GROUP_ID, getLongOrNull(groupId));
        if (bp.getHitCount() != 0) {
            obj.put(BREAK_HIT_COUNT, bp.getHitCount());
        }
        obj.put(BREAK_ACTIVE, bp.isActive());
        obj.put(BREAK_CONDITION, bp.getCondition());
        if (bp.getIgnoreCount() != 0) {
            obj.put(BREAK_IGNORE_COUNT, bp.getIgnoreCount());
        }
        obj.put(BREAK_ACTUAL_LOCATIONS, store(bp.getActualLocations()));
        obj.put(TYPE, bp.getType().toString());
        storeIf(bp.getScriptId(), obj, SCRIPT_ID);
        storeIf(bp.getScriptName(), obj, SCRIPT_NAME);
        return obj;
    }
    
    private static JSONArray store(V8Breakpoint.ActualLocation[] actualLocations) {
        JSONArray array = new JSONArray();
        if (actualLocations != null) {
            for (V8Breakpoint.ActualLocation al : actualLocations) {
                JSONObject obj = newJSONObject();
                obj.put(LINE, al.getLine());
                obj.put(COLUMN, al.getColumn());
                storeIf(al.getScriptId(), obj, SCRIPT_ID);
                storeIf(al.getScriptName(), obj, SCRIPT_NAME);
                array.add(obj);
            }
        }
        return array;
    }
    
    private static JSONArray store(V8Frame[] frames) {
        JSONArray array = new JSONArray();
        for (V8Frame frame : frames) {
            array.add(store(frame));
        }
        return array;
    }
    
    private static JSONObject store(V8Frame frame) {
        JSONObject obj = newJSONObject();
        obj.put(TYPE, V8Value.Type.Frame.toString());
        PropertyLong index = frame.getIndex();
        obj.put(INDEX, getLongOrNull(index));
        obj.put(FRAME_RECEIVER, store(frame.getReceiver(), true, false));
        obj.put(FRAME_FUNC, store(frame.getFunction(), true, false));
        storeReference(frame.getScriptRef(), obj, SCRIPT);
        obj.put(FRAME_CONSTRUCT_CALL, frame.isConstructCall());
        obj.put(FRAME_AT_RETURN, frame.isAtReturn());
        obj.put(FRAME_DEBUGGER, frame.isDebuggerFrame());
        storeReferences(frame.getArgumentRefs(), obj, FRAME_ARGUMENTS, true);
        storeReferences(frame.getLocalRefs(), obj, FRAME_LOCALS, true);
        obj.put(POSITION, frame.getPosition());
        obj.put(LINE, frame.getLine());
        obj.put(COLUMN, frame.getColumn());
        obj.put(EVT_SOURCE_LINE_TEXT, frame.getSourceLineText());
        obj.put(SCOPES, store(frame.getScopes()));
        obj.put(TEXT, frame.getText());
        return obj;
    }
    
    private static JSONArray store(ChangeLive.ChangeLog changeLog) {
        JSONArray array = new JSONArray();
        if (changeLog != null) {
            ChangeLive.ChangeLog.BreakpointUpdate[] breakpointsUpdate = changeLog.getBreakpointsUpdate();
            if (breakpointsUpdate != null) {
                JSONObject obj = newJSONObject();
                obj.put(BREAK_POINTS_UPDATE, store(breakpointsUpdate));
                array.add(obj);
            }
            String[] droppedFrames = changeLog.getDroppedFrames();
            if (droppedFrames != null) {
                JSONObject obj = newJSONObject();
                obj.put(DROPPED_FROM_STACK, storeStringValues(droppedFrames, NAME));
                array.add(obj);
            }
            String[] namesLinkedToOldScript = changeLog.getNamesLinkedToOldScript();
            if (namesLinkedToOldScript != null) {
                JSONObject obj = newJSONObject();
                obj.put(LINKED_TO_OLD_SCRIPT, storeStringValues(namesLinkedToOldScript, NAME));
                array.add(obj);
            }
            ChangeLive.ChangeLog.FunctionPatched functionPatched = changeLog.getFunctionPatched();
            if (functionPatched != null) {
                JSONObject obj = newJSONObject();
                obj.put(FUNCTION_PATCHED, functionPatched.getFunction());
                storeIf(functionPatched.getFunctionInfoNotFound(), obj, FUNCTION_INFO_NOT_FOUND);
                array.add(obj);
            }
            ChangeLive.ChangeLog.PositionPatched[] patchedPositions = changeLog.getPatchedPositions();
            if (patchedPositions != null) {
                JSONObject obj = newJSONObject();
                obj.put(POSITION_PATCHED, store(patchedPositions));
                array.add(obj);
            }
        }
        return array;
    }
    
    private static JSONArray store(ChangeLive.ChangeLog.BreakpointUpdate[] breakpointsUpdate) {
        JSONArray array = new JSONArray();
        for (ChangeLive.ChangeLog.BreakpointUpdate bpu : breakpointsUpdate) {
            JSONObject obj = newJSONObject();
            obj.put(ID, bpu.getId());
            storeIf(bpu.getNewId(), obj, NEW_ID);
            storeIf(bpu.getNewPositions(), obj, NEW_POSITIONS);
            storeIf(bpu.getOldPositions(), obj, POSITIONS);
            obj.put(TYPE, bpu.getType().toString());
            array.add(obj);
        }
        return array;
    }
    
    private static JSONArray store(ChangeLive.ChangeLog.PositionPatched[] patchedPositions) {
        JSONArray array = new JSONArray();
        for (ChangeLive.ChangeLog.PositionPatched pp : patchedPositions) {
            JSONObject obj = newJSONObject();
            storeIf(pp.getName(), obj, NAME);
            storeIf(pp.getInfoNotFound(), obj, INFO_NOT_FOUND);
            array.add(obj);
        }
        return array;
    }
    
    private static JSONObject store(ChangeLive.Result result) {
        JSONObject obj = newJSONObject();
        obj.put(CHANGE_TREE, store(result.getChangeTree()));
        obj.put(TEXTUAL_DIFF, store(result.getDiff()));
        obj.put(UPDATED, result.isUpdated());
        storeIf(result.getStackModified(), obj, STACK_MODIFIED);
        storeIf(result.getStackUpdateNeedsStepIn(), obj, STACK_UPDATE_NEEDS_STEP_IN);
        storeIf(result.getCreatedScriptName(), obj, CREATED_SCRIPT_NAME);
        return obj;
    }
    
    private static JSONObject store(ChangeLive.Result.ChangeTree changeTree) {
        JSONObject obj = newJSONObject();
        obj.put(NAME, changeTree.getName());
        storeIf(changeTree.getPositions(), obj, POSITIONS);
        if (changeTree.getStatus() != null) {
            obj.put(STATUS, changeTree.getStatus().toString());
        }
        obj.put(CHILDREN, store(changeTree.getChildren()));
        if (changeTree.getNewChildren() != null) {
            obj.put(NEW_CHILDREN, store(changeTree.getNewChildren()));
        }
        storeIf(changeTree.getStatusExplanation(), obj, STATUS_EXPLANATION);
        storeIf(changeTree.getNewPositions(), obj, NEW_POSITIONS);
        return obj;
    }
    
    private static JSONObject store(ChangeLive.Result.TextualDiff diff) {
        JSONObject obj = newJSONObject();
        obj.put(OLD_LEN, diff.getOldLength());
        obj.put(NEW_LEN, diff.getNewLength());
        obj.put(CHUNKS, array(diff.getChunks()));
        return obj;
    }
    
    private static void storeIf(ChangeLive.ChangeLog.BreakpointUpdate.Position position, JSONObject obj, String propName) {
        if (position != null) {
            JSONObject pos = newJSONObject();
            pos.put(POSITION, position.getPosition());
            pos.put(LINE, position.getLine());
            pos.put(COLUMN, position.getColumn());
            obj.put(propName, pos);
        }
    }
    
    private static JSONArray store(ChangeLive.Result.ChangeTree[] children) {
        JSONArray array = new JSONArray();
        if (children != null) {
            for (ChangeLive.Result.ChangeTree ct : children) {
                array.add(store(ct));
            }
        }
        return array;
    }
    
    private static void storeIf(ChangeLive.Result.ChangeTree.Positions positions, JSONObject obj, String propName) {
        if (positions != null) {
            JSONObject pos = newJSONObject();
            pos.put(START_POSITION, positions.getStartPosition());
            pos.put(END_POSITION, positions.getEndPosition());
            obj.put(propName, pos);
        }
    }
    
    private static JSONObject storeValues(Map<Long, V8Value> values) {
        JSONObject obj = newJSONObject();
        for (V8Value vv : values.values()) {
            obj.put(Long.toString(vv.getHandle()), store(vv));
        }
        return obj;
    }
    
    private static JSONArray store(V8Scope[] scopes) {
        JSONArray array = new JSONArray();
        for (V8Scope scope : scopes) {
            array.add(store(scope));
        }
        return array;
    }
    
    private static JSONObject store(V8Scope scope) {
        JSONObject obj = newJSONObject();
        obj.put(TYPE, scope.getType().ordinal());
        obj.put(SCOPE_INDEX, scope.getIndex());
        storeIf(scope.getFrameIndex(), obj, FRAME_INDEX);
        if (scope.getObject() != null) {
            obj.put(OBJECT, store(scope.getObject(), false, true));
        }
        storeIf(scope.getText(), obj, TEXT);
        return obj;
    }
    
    private static JSONArray storeThreads(Map<Long, Boolean> threads) {
        JSONArray array = new JSONArray();
        for (Map.Entry<Long, Boolean> thread : threads.entrySet()) {
            JSONObject obj = newJSONObject();
            obj.put(CURRENT, thread.getValue());
            obj.put(ID, thread.getKey());
            array.add(obj);
        }
        return array;
    }
    
    private static JSONArray storeFlags(Map<String, Boolean> flags) {
        JSONArray array = new JSONArray();
        for (Map.Entry<String, Boolean> flag : flags.entrySet()) {
            JSONObject obj = newJSONObject();
            obj.put(NAME, flag.getKey());
            obj.put(VALUE, flag.getValue());
            array.add(obj);
        }
        return array;
    }
    
    private static JSONObject store(Map<String, Object> map) {
        JSONObject obj = newJSONObject();
        obj.putAll(map);
        return obj;
    }
    
    private static JSONArray array(long[] array) {
        JSONArray jsArray = new JSONArray();
        for (int i = 0; i < array.length; i++) {
            jsArray.add(array[i]);
        }
        return jsArray;
    }
    
    private static JSONArray storeStringValues(String[] ss, String propName) {
        JSONArray array = new JSONArray();
        for (String s : ss) {
            JSONObject obj = newJSONObject();
            obj.put(NAME, s);
            array.add(obj);
        }
        return array;
    }
    
    private static void storeIf(PropertyBoolean prop, JSONObject obj, String propertyName) {
        if (prop.hasValue()) {
            obj.put(propertyName, prop.getValue());
        }
    }
    
    private static void storeIf(PropertyLong prop, JSONObject obj, String propertyName) {
        if (prop.hasValue()) {
            obj.put(propertyName, prop.getValue());
        }
    }
    
    private static void storeIf(String prop, JSONObject obj, String propertyName) {
        if (prop != null) {
            obj.put(propertyName, prop);
        }
    }
    
    private static void storeIf(ReferencedValue rv, JSONObject obj, String propertyName) {
        if (rv == null) {
            return ;
        }
        JSONObject ref = newJSONObject();
        ref.put(REF, rv.getReference());
        if (rv.hasValue()) {
            store(rv.getValue(), ref, false, false);
        }
        obj.put(propertyName, ref);
    }
    
    private static JSONArray store(Evaluate.Arguments.Context[] contexts) {
        if (contexts == null) {
            return null;
        }
        JSONArray array = new JSONArray();
        for (Evaluate.Arguments.Context c : contexts) {
            array.add(store(c));
        }
        return array;
    }
    
    private static JSONObject store(Evaluate.Arguments.Context context) {
        JSONObject obj = newJSONObject();
        obj.put(NAME, context.getName());
        obj.put(HANDLE, context.getHandle());
        return obj;
    }
    
    private static JSONObject store(NewValue value) {
        JSONObject obj = newJSONObject();
        if (value.getHandle().hasValue()) {
            obj.put(HANDLE, value.getHandle().getValue());
        } else {
            obj.put(TYPE, value.getType().toString());
            storeIf(value.getDescription(), obj, STRING_DESCRIPTION);
        }
        return obj;
    }
    
    private static JSONObject store(V8Value value) {
        JSONObject obj = newJSONObject();
        store(value, obj, true, false);
        return obj;
    }
    
    private static void store(V8Value value, JSONObject obj, boolean storeHandle, boolean noTextAndLength) {
        if (storeHandle) {
            obj.put(HANDLE, value.getHandle());
        }
        V8Value.Type type = value.getType();
        obj.put(TYPE, type.toString());
        switch (type) {
            case Boolean:
                V8Boolean vb = (V8Boolean) value;
                obj.put(VALUE, vb.getValue());
                break;
            case Number:
                V8Number vn = (V8Number) value;
                V8Number.Kind kind = vn.getKind();
                switch (kind) {
                    case Double:
                        double dv = vn.getDoubleValue();
                        if (dv == Double.POSITIVE_INFINITY) {
                            obj.put(VALUE, INFINITY);
                        } else if (dv == Double.NEGATIVE_INFINITY) {
                            obj.put(VALUE, "-"+INFINITY);
                        } else if (Double.isNaN(dv)) {
                            obj.put(VALUE, NaN);
                        } else {
                            obj.put(VALUE, dv);
                        }
                        break;
                    case Long:
                        obj.put(VALUE, vn.getLongValue());
                        break;
                    default:
                        throw new IllegalArgumentException("Unhandled number kind: "+kind);
                }
                break;
            case String:
                V8String vs = (V8String) value;
                String vss = vs.getValue();
                obj.put(VALUE, vss);
                if (!noTextAndLength) {
                    obj.put(LENGTH, vss.length());
                }
                break;
            case Function:
                V8Function vf = (V8Function) value;
                if (vf.isResolved().hasValue()) { // Hack to be compliant with original V8 protocol
                    obj.put(VALUE_CLASS_NAME, vf.getClassName());
                }
                storeReferenceIf(vf.getConstructorFunctionHandle(), obj, VALUE_CONSTRUCTOR_FUNCTION);
                storeReferenceIf(vf.getProtoObjectHandle(), obj, VALUE_PROTO_OBJECT);
                storeReferenceIf(vf.getPrototypeObjectHandle(), obj, VALUE_PROTOTYPE_OBJECT);
                storeIf(vf.getName(), obj, NAME);
                storeIf(vf.getInferredName(), obj, FUNCTION_INFERRED_NAME);
                storeIf(vf.isResolved(), obj, FUNCTION_RESOLVED);
                storeIf(vf.getSource(), obj, SOURCE);
                storeReferenceIf(vf.getScriptRef(), obj, SCRIPT);
                storeIf(vf.getScriptId(), obj, SCRIPTID);
                storeIf(vf.getPosition(), obj, POSITION);
                storeIf(vf.getLine(), obj, LINE);
                storeIf(vf.getColumn(), obj, COLUMN);
                V8Scope[] scopes = vf.getScopes();
                if (scopes != null) {
                    obj.put(SCOPES, store(scopes));
                }
                if (vf.getProperties() != null || vf.getArray() != null && vf.getArray().getLength() > 0) {
                    obj.put(VALUE_PROPERTIES, storeProperties(vf.getProperties(), vf.getArray()));
                }
                break;
            case Generator:
                V8Generator gf = (V8Generator) value;
                obj.put(VALUE_CLASS_NAME, gf.getClassName());
                storeReferenceIf(gf.getConstructorFunctionHandle(), obj, VALUE_CONSTRUCTOR_FUNCTION);
                storeReferenceIf(gf.getProtoObjectHandle(), obj, VALUE_PROTO_OBJECT);
                storeReferenceIf(gf.getPrototypeObjectHandle(), obj, VALUE_PROTOTYPE_OBJECT);
                storeReferenceIf(gf.getFunctionHandle(), obj, FRAME_FUNC);
                storeReferenceIf(gf.getReceiverHandle(), obj, FRAME_RECEIVER);
                if (gf.getProperties() != null) {
                    obj.put(VALUE_PROPERTIES, storeProperties(gf.getProperties(), null));
                }
                break;
            case Object:
            case Error:
            case Regexp:
                V8Object vo = (V8Object) value;
                obj.put(VALUE_CLASS_NAME, vo.getClassName());
                storeReferenceIf(vo.getConstructorFunctionHandle(), obj, VALUE_CONSTRUCTOR_FUNCTION);
                storeReferenceIf(vo.getProtoObjectHandle(), obj, VALUE_PROTO_OBJECT);
                storeReferenceIf(vo.getPrototypeObjectHandle(), obj, VALUE_PROTOTYPE_OBJECT);
                if (vo.getProperties() != null || vo.getArray() != null && vo.getArray().getLength() > 0) {
                    obj.put(VALUE_PROPERTIES, storeProperties(vo.getProperties(), vo.getArray()));
                }
                break;
            case Frame:
                // ? TODO
                break;
            case Script:
                V8ScriptValue vsv = (V8ScriptValue) value;
                storeTo(vsv.getScript(), obj, true);
                break;
            case Null:
                if (noTextAndLength) {
                    obj.put(VALUE, null);
                }
                break;
        }
        if (value.getText() != null && !noTextAndLength) {
            obj.put(TEXT, value.getText());
        }
    }
    
    private static void storeReferenceIf(PropertyLong ref, JSONObject obj, String propertyName) {
        if (ref.hasValue()) {
            storeReference(ref.getValue(), obj, propertyName);
        }
    }
    
    private static void storeReference(long ref, JSONObject obj, String propertyName) {
        JSONObject refObj = newJSONObject();
        refObj.put(REF, ref);
        obj.put(propertyName, refObj);
    }
    
    private static void storeReferences(Map<String, ReferencedValue> rvals,
                                        JSONObject obj, String propertyName,
                                        boolean storeRefNotHandle) {
        if (rvals == null) {
            return ;
        }
        JSONArray array = new JSONArray();
        for (Map.Entry<String, ReferencedValue> rval : rvals.entrySet()) {
            JSONObject elm = newJSONObject();
            if (rval.getKey() != null) {
                elm.put(NAME, rval.getKey());
            }
            elm.put(VALUE, store(rval.getValue(), storeRefNotHandle, true));
            array.add(elm);
        }
        obj.put(propertyName, array);
    }
    
    private static JSONArray storeProperties(Map<String, V8Object.Property> properties, V8Object.Array array) {
        JSONArray arrObj = new JSONArray();
        if (properties != null) {
            for (String propName : properties.keySet()) {
                V8Object.Property prop = properties.get(propName);
                JSONObject propObj = newJSONObject();
                propObj.put(NAME, propName);
                if (prop.getAttributes() != 0) {
                    propObj.put(ATTRIBUTES, prop.getAttributes());
                }
                V8Object.Property.Type type = prop.getType();
                if (type != null) {
                    propObj.put(PROPERTY_TYPE, type.ordinal());
                } else {
                    propObj.put(PROPERTY_TYPE, 0);
                }
                propObj.put(REF, prop.getReference());
                arrObj.add(propObj);
            }
        }
        if (array != null) {
            V8Object.IndexIterator indexIterator = array.getIndexIterator();
            while (indexIterator.hasNextIndex()) {
                JSONObject arrElm = newJSONObject();
                long index = indexIterator.nextIndex();
                arrElm.put(NAME, index);
                arrElm.put(PROPERTY_TYPE, 0);
                arrElm.put(REF, array.getReferenceAt(index));
                arrObj.add(arrElm);
            }
        }
        return arrObj;
    }
}