/*
 * 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.modules.debugger.jpda.truffle;

import com.sun.jdi.BooleanValue;
import com.sun.jdi.ClassNotLoadedException;
import com.sun.jdi.ClassObjectReference;
import com.sun.jdi.ClassType;
import com.sun.jdi.Field;
import com.sun.jdi.IncompatibleThreadStateException;
import com.sun.jdi.InvalidTypeException;
import com.sun.jdi.InvocationException;
import com.sun.jdi.Method;
import com.sun.jdi.ObjectReference;
import com.sun.jdi.ThreadReference;
import com.sun.jdi.Value;
import com.sun.jdi.VirtualMachine;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyVetoException;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.Lock;
import java.util.logging.Level;
import java.util.logging.Logger;

import org.netbeans.api.debugger.jpda.JPDAClassType;
import org.netbeans.api.debugger.jpda.JPDADebugger;
import org.netbeans.api.debugger.jpda.JPDAThread;
import org.netbeans.modules.debugger.jpda.JPDADebuggerImpl;
import org.netbeans.modules.debugger.jpda.expr.InvocationExceptionTranslated;
import org.netbeans.modules.debugger.jpda.jdi.ClassNotPreparedExceptionWrapper;
import org.netbeans.modules.debugger.jpda.jdi.ClassObjectReferenceWrapper;
import org.netbeans.modules.debugger.jpda.jdi.ClassTypeWrapper;
import org.netbeans.modules.debugger.jpda.jdi.InternalExceptionWrapper;
import org.netbeans.modules.debugger.jpda.jdi.ObjectCollectedExceptionWrapper;
import org.netbeans.modules.debugger.jpda.jdi.ObjectReferenceWrapper;
import org.netbeans.modules.debugger.jpda.jdi.ReferenceTypeWrapper;
import org.netbeans.modules.debugger.jpda.jdi.UnsupportedOperationExceptionWrapper;
import org.netbeans.modules.debugger.jpda.jdi.VMDisconnectedExceptionWrapper;
import org.netbeans.modules.debugger.jpda.jdi.VirtualMachineWrapper;
import org.netbeans.modules.debugger.jpda.models.JPDAThreadImpl;
import org.netbeans.modules.debugger.jpda.truffle.access.TruffleAccess;
import static org.netbeans.modules.debugger.jpda.truffle.access.TruffleAccess.BASIC_CLASS_NAME;
import org.netbeans.modules.debugger.jpda.truffle.breakpoints.TruffleBreakpointsHandler;
import org.netbeans.modules.debugger.jpda.truffle.options.TruffleOptions;
import org.netbeans.modules.javascript2.debug.breakpoints.JSLineBreakpoint;
import org.openide.util.Exceptions;

/**
 * Handles remote JPDATruffleDebugManager.
 */
final class DebugManagerHandler {
    
    private static final Logger LOG = Logger.getLogger(DebugManagerHandler.class.getName());
    
    private static final String ACCESSOR_START_ACCESS_LOOP = "startAccessLoop"; // NOI18N
    private static final String ACCESSOR_LOOP_RUNNING_FIELD = "accessLoopRunning";  // NOI18N
    private static final String ACCESSOR_SET_UP_DEBUG_MANAGER_FOR = "setUpDebugManagerFor"; // NOI18N
    private static final String ACCESSOR_SET_UP_DEBUG_MANAGER_FOR_SGN =
            "(L"+Object.class.getName().replace('.', '/')+";ZZ)"+                // NOI18N
            "Lorg/netbeans/modules/debugger/jpda/backend/truffle/JPDATruffleDebugManager;"; // NOI18N
    private static final String ACCESSOR_SET_INCLUDE_INTERNAL = "setIncludeInternal"; // NOI18N
    private static final String ACCESSOR_SET_INCLUDE_INTERNAL_SGN = "(Z)V"; // NOI18N
    
    private static final Map<JPDADebugger, Boolean> dbgStepInto = Collections.synchronizedMap(new WeakHashMap<JPDADebugger, Boolean>());

    private final JPDADebugger debugger;
    private final AtomicBoolean inited = new AtomicBoolean(false);
    private ClassType accessorClass;
    private JPDAClassType accessorJPDAClass;
    private final Object accessorClassLock = new Object();
    //private ObjectReference debugManager;
    private final TruffleBreakpointsHandler breakpointsHandler;
    private final PropertyChangeListener optionsChangeListener = new OptionsChangeListener();
    
    public DebugManagerHandler(JPDADebugger debugger) {
        this.debugger = debugger;
        this.breakpointsHandler = new TruffleBreakpointsHandler(debugger);
        TruffleOptions.onLanguageDeveloperModeChange(optionsChangeListener);
    }
    
    static void execStepInto(JPDADebugger debugger, boolean doStepInto) {
        if (doStepInto) {
            dbgStepInto.put(debugger, doStepInto);
        } else {
            dbgStepInto.remove(debugger);
        }
    }
    
    private boolean isStepInto() {
        Boolean stepInto = dbgStepInto.get(debugger);
        return stepInto != null && stepInto;
    }
    
    void newPolyglotEngineInstance(ObjectReference engine, JPDAThreadImpl thread) {
        LOG.log(Level.FINE, "Engine created breakpoint hit: engine = {0} in thread = {1}", new Object[] { engine, thread.getThreadReference()});
        if (inited.compareAndSet(false, true)) {
            initDebuggerRemoteService(thread);
        }
        if (accessorClass == null) {
            // No accessor
            return ;
        }
        InvocationExceptionTranslated iextr = null;
        try {
            // Create an instance of JPDATruffleDebugManager in the backend
            // and submit breakpoints:
            thread.notifyMethodInvoking();
            VirtualMachine vm = ((JPDADebuggerImpl) debugger).getVirtualMachine();
            if (vm == null) {
                return ;
            }
            BooleanValue includeInternal = vm.mirrorOf(TruffleOptions.isLanguageDeveloperMode());
            BooleanValue doStepInto = vm.mirrorOf(isStepInto());
            Method debugManagerMethod = ClassTypeWrapper.concreteMethodByName(
                    accessorClass,
                    ACCESSOR_SET_UP_DEBUG_MANAGER_FOR,
                    ACCESSOR_SET_UP_DEBUG_MANAGER_FOR_SGN);
            ThreadReference tr = thread.getThreadReference();
            List<Value> dmArgs = Arrays.asList(engine, includeInternal, doStepInto);
            LOG.log(Level.FINE, "Setting engine and step into = {0}", isStepInto());
            Object ret = ClassTypeWrapper.invokeMethod(accessorClass, tr, debugManagerMethod, dmArgs, ObjectReference.INVOKE_SINGLE_THREADED);
            if (ret instanceof ObjectReference) {   // Can be null when an existing debug manager is reused.
                //debugManager = (ObjectReference) ret;
                breakpointsHandler.submitBreakpoints(accessorClass, (ObjectReference) ret, thread);
            }
        } catch (VMDisconnectedExceptionWrapper vmd) {
        } catch (InvocationException iex) {
            iextr = new InvocationExceptionTranslated(iex, thread.getDebugger());
            Exceptions.printStackTrace(iex);
        } catch (Exception ex) {
            Exceptions.printStackTrace(ex);
        } finally {
            thread.notifyMethodInvokeDone();
        }
        if (iextr != null) {
            iextr.preload(thread);
            Exceptions.printStackTrace(iextr);
        }
    }

    private void initDebuggerRemoteService(JPDAThread thread) {
        if (LOG.isLoggable(Level.FINE)) {
            LOG.log(Level.FINE, "initDebuggerRemoteService({0})", thread);
        }
        JPDAThreadImpl t = (JPDAThreadImpl) thread;
        Lock writeLock = t.accessLock.writeLock();
        writeLock.lock();
        try {
            ClassObjectReference cor = null;
            try {
                cor = RemoteServices.uploadBasicClasses(t, BASIC_CLASS_NAME);
            } catch (PropertyVetoException |
                     InvalidTypeException |
                     ClassNotLoadedException |
                     IncompatibleThreadStateException |
                     IOException pvex) {
                Exceptions.printStackTrace(pvex);
            } catch (InvocationException ex) {
                Exceptions.printStackTrace(ex);
                final InvocationExceptionTranslated iextr = new InvocationExceptionTranslated(ex, t.getDebugger());
                iextr.preload(t);
                Exceptions.printStackTrace(iextr);
            }
            if (LOG.isLoggable(Level.FINE)) {
                LOG.log(Level.FINE, "Uploaded class = {0}", cor);
            }
            if (cor == null) {
                return ;
            }
            ThreadReference tr = t.getThreadReference();
            
            ClassType serviceClass = (ClassType) ClassObjectReferenceWrapper.reflectedType(cor);//RemoteServices.getClass(vm, "org.netbeans.modules.debugger.jpda.visual.remote.RemoteService");

            InvocationExceptionTranslated iextr = null;
            Method startMethod = ClassTypeWrapper.concreteMethodByName(serviceClass, ACCESSOR_START_ACCESS_LOOP, "()Ljava/lang/Thread;");
            if (startMethod == null) {
                LOG.log(Level.WARNING, "Could not start the access loop of "+serviceClass+", no "+ACCESSOR_START_ACCESS_LOOP+" method.");
                return ;
            }
            try {
                t.notifyMethodInvoking();
                Value ret = ClassTypeWrapper.invokeMethod(serviceClass, tr, startMethod, Collections.emptyList(), ObjectReference.INVOKE_SINGLE_THREADED);
                if (ret instanceof ThreadReference) {
                    RemoteServices.setAccessLoopStarted(t.getDebugger(), (ThreadReference) ret);
                } else {
                    LOG.log(Level.WARNING, "Could not start the access loop of "+serviceClass);
                    return ;
                }
                TruffleAccess.assureBPSet(debugger, serviceClass);
                JPDAClassType serviceJPDAClass = ((JPDADebuggerImpl) debugger).getClassType(serviceClass);
                synchronized (accessorClassLock) {
                    accessorClass = serviceClass;
                    accessorJPDAClass = serviceJPDAClass;
                }
            } catch (InvocationException iex) {
                iextr = new InvocationExceptionTranslated(iex, t.getDebugger());
                Exceptions.printStackTrace(iex);
            } catch (ClassNotLoadedException |
                     IncompatibleThreadStateException |
                     InvalidTypeException |
                     PropertyVetoException |
                     InternalExceptionWrapper |
                     ObjectCollectedExceptionWrapper ex) {
                Exceptions.printStackTrace(ex);
            } finally {
                t.notifyMethodInvokeDone();
                ObjectReferenceWrapper.enableCollection(cor);
            }
            if (iextr != null) {
                iextr.preload(t);
                Exceptions.printStackTrace(iextr);
            }
        } catch (InternalExceptionWrapper iex) {
        } catch (ClassNotPreparedExceptionWrapper cnpex) {
            Exceptions.printStackTrace(cnpex);
        } catch (ObjectCollectedExceptionWrapper collex) {
        } catch (UnsupportedOperationExceptionWrapper uex) {
            LOG.log(Level.INFO, uex.getLocalizedMessage(), uex);
        } catch (VMDisconnectedExceptionWrapper vmd) {
        } finally {
            writeLock.unlock();
        }
        if (LOG.isLoggable(Level.FINE)) {
            try {
                LOG.fine("The JPDATruffleAccessor is there: "+
                            RemoteServices.getClass(t.getThreadReference().virtualMachine(),
                         BASIC_CLASS_NAME));
            } catch (Exception ex) {
                LOG.log(Level.FINE, "", ex);
            }
        }
    }
    
    ClassType getAccessorClass() {
        synchronized (accessorClassLock) {
            return accessorClass;
        }
    }
    
    JPDAClassType getAccessorJPDAClass() {
        synchronized (accessorClassLock) {
            return accessorJPDAClass;
        }
    }
    
    void destroy() {
        breakpointsHandler.destroy();
        if (accessorClass == null) {
            return ;
        }
        try {
            Field accessLoopRunning = ReferenceTypeWrapper.fieldByName(accessorClass, ACCESSOR_LOOP_RUNNING_FIELD);
            if (accessLoopRunning != null) {
                ClassTypeWrapper.setValue(accessorClass, accessLoopRunning,
                                          VirtualMachineWrapper.mirrorOf(accessorClass.virtualMachine(), false));
                RemoteServices.interruptServiceAccessThread(debugger);
            }
        } catch (VMDisconnectedExceptionWrapper vdex) {
            // Ignore
        } catch (Exception ex) {
            Exceptions.printStackTrace(ex);
        }
    }
    
    void breakpointAdded(JSLineBreakpoint jsLineBreakpoint) {
        breakpointsHandler.breakpointAdded(jsLineBreakpoint);
    }

    void breakpointRemoved(JSLineBreakpoint jsLineBreakpoint) {
        breakpointsHandler.breakpointRemoved(jsLineBreakpoint);
    }

    private final class OptionsChangeListener implements PropertyChangeListener {

        @Override
        public void propertyChange(PropertyChangeEvent evt) {
            if (accessorClass == null) {
                // No accessor
                return ;
            }
            if (TruffleOptions.PROPERTY_LANG_DEV_MODE.equals(evt.getPropertyName())) {
                JPDADebuggerImpl debuggerImpl = (JPDADebuggerImpl) debugger;
                debuggerImpl.getRequestProcessor().post(() -> {
                    VirtualMachine vm = debuggerImpl.getVirtualMachine();
                    if (vm == null) {
                        return ;
                    }
                    BooleanValue includeInternal = vm.mirrorOf(TruffleOptions.isLanguageDeveloperMode());
                    try {
                        Method debugManagerMethod = ClassTypeWrapper.concreteMethodByName(
                                accessorClass,
                                ACCESSOR_SET_INCLUDE_INTERNAL,
                                ACCESSOR_SET_INCLUDE_INTERNAL_SGN);
                        TruffleAccess.methodCallingAccess(debugger, new TruffleAccess.MethodCallsAccess() {
                            @Override
                            public void callMethods(JPDAThread thread) throws InvocationException {
                                ThreadReference tr = ((JPDAThreadImpl) thread).getThreadReference();
                                List<Value> dmArgs = Arrays.asList(includeInternal);
                                LOG.log(Level.FINE, "Setting includeInternal to {0}", includeInternal.value());
                                try {
                                    ClassTypeWrapper.invokeMethod(accessorClass, tr, debugManagerMethod, dmArgs, ObjectReference.INVOKE_SINGLE_THREADED);
                                } catch (Exception ex) {
                                    Exceptions.printStackTrace(ex);
                                }
                            }
                        });
                    } catch (ClassNotPreparedExceptionWrapper | InternalExceptionWrapper | VMDisconnectedExceptionWrapper ex) {
                        Exceptions.printStackTrace(ex);
                    }
                });
            }
        }
        
    }
}