/*
 * 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.javascript.v8debug.sources;

import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Phaser;
import java.util.concurrent.Semaphore;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.netbeans.api.debugger.ActionsManager;
import org.netbeans.api.debugger.LazyActionsManagerListener;
import org.netbeans.lib.v8debug.PropertyBoolean;
import org.netbeans.lib.v8debug.V8Arguments;
import org.netbeans.lib.v8debug.V8Command;
import org.netbeans.lib.v8debug.V8Request;
import org.netbeans.lib.v8debug.V8Response;
import org.netbeans.lib.v8debug.V8Script;
import org.netbeans.lib.v8debug.V8StepAction;
import org.netbeans.lib.v8debug.commands.ChangeLive;
import org.netbeans.lib.v8debug.commands.ChangeLive.ChangeLog.BreakpointUpdate;
import org.netbeans.lib.v8debug.commands.ChangeLive.ChangeLog.BreakpointUpdate.Position;
import org.netbeans.lib.v8debug.commands.Continue;
import org.netbeans.lib.v8debug.commands.Source;
import org.netbeans.modules.javascript.v8debug.ScriptsHandler;
import org.netbeans.modules.javascript.v8debug.V8Debugger;
import org.netbeans.modules.javascript.v8debug.V8DebuggerEngineProvider;
import org.netbeans.modules.javascript.v8debug.api.DebuggerOptions;
import org.netbeans.modules.javascript.v8debug.frames.CallFrame;
import org.netbeans.spi.debugger.ActionsProvider;
import org.netbeans.spi.debugger.ContextProvider;
import org.openide.filesystems.FileAttributeEvent;
import org.openide.filesystems.FileChangeListener;
import org.openide.filesystems.FileEvent;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileRenameEvent;
import org.openide.filesystems.FileUtil;
import org.openide.util.Exceptions;
import org.openide.util.RequestProcessor;

/**
 * Support for live application of saved files to the V8.
 * 
 * @author Martin Entlicher
 */
public final class ChangeLiveSupport {
    
    private static final Logger LOG = Logger.getLogger(ChangeLiveSupport.class.getName());
    
    private static final String PREP_REGEX = "^(\\(function.*\\(.*\\).*\\{ ).*";
    private static final Pattern PREP_PATTERN = Pattern.compile(PREP_REGEX, Pattern.MULTILINE | Pattern.DOTALL);
    
    //private static final String PREP_TEXT = "(function (exports, require, module, __filename, __dirname) { ";
    private static final String APP_TEXT = "})();";
    
    public static final String PROP_CHANGES = "changes";
    
    private final V8Debugger dbg;
    private final FileChangeListener sourceChangeListener;
    private FileChangeDelivery fileChangeDelivery = new FileChangeDelivery();
    private final File[] sourceChangeRoots;
    private final RequestProcessor rp = new RequestProcessor(ChangeLiveSupport.class);
    private final PropertyChangeSupport pcl = new PropertyChangeSupport(this);
    private volatile boolean haveChanges = false;
    
    public ChangeLiveSupport(V8Debugger dbg) {
        this.dbg = dbg;
        this.sourceChangeListener = new SourceChangeListener();
        this.sourceChangeRoots = dbg.getScriptsHandler().getLocalRoots();
        if (LOG.isLoggable(Level.FINE)) {
            LOG.fine("new ChangeLiveSupport(), sourceChangeRoots = "+Arrays.toString(sourceChangeRoots));
        }
        if (sourceChangeRoots.length == 0) {
            FileUtil.addFileChangeListener(sourceChangeListener);
        } else {
            for (File root : sourceChangeRoots) {
                FileUtil.addRecursiveListener(sourceChangeListener, root);
            }
        }
        dbg.addListener(new V8Debugger.Listener() {
            @Override public void notifySuspended(boolean suspended) {}

            @Override public void notifyCurrentFrame(CallFrame cf) {}

            @Override public void notifyFinished() {
                destroy();
            }
        });
    }
    
    public boolean hasChanges() {
        return haveChanges;
    }
    
    private void setHasChanges(boolean haveChanges) {
        if (haveChanges == this.haveChanges) {
            return ;
        }
        this.haveChanges = haveChanges;
        pcl.firePropertyChange(PROP_CHANGES, !haveChanges, haveChanges);
    }
    
    public void applyChanges() {
        fileChangeDelivery.applyChanges();
    }
    
    public void addPropertyChangeListener(PropertyChangeListener l) {
        pcl.addPropertyChangeListener(l);
    }
    
    public void removePropertyChangeListener(PropertyChangeListener l) {
        pcl.removePropertyChangeListener(l);
    }
    
    private void applyModifiedFiles(List<FileObject> modifiedFiles) {
        ScriptsHandler sh = dbg.getScriptsHandler();
        Collection<V8Script> scripts = sh.getScripts();
        final AtomicBoolean doStepInto = new AtomicBoolean(false);
        final Phaser phaser = new Phaser(1);
        LOG.log(Level.FINE, "applyModifiedFiles({0})", modifiedFiles);
        for (FileObject fo : modifiedFiles) {
            if (!sh.containsLocalFile(fo)) {
                continue;
            }
            String path = fo.getPath();
            String serverPath;
            try {
                serverPath = sh.getServerPath(path);
            } catch (ScriptsHandler.OutOfScope ex) {
                continue;
            }
            V8Script script = null;
            for (V8Script s : scripts) {
                if (serverPath.equals(s.getName())) {
                    script = s;
                    break;
                }
            }
            if (script == null) {
                // Not a loaded script
                continue;
            }
            String origScriptSource = script.getSource();
            if (origScriptSource == null) {
                origScriptSource = script.getSourceStart();
            }
            String prependedText = null;
            Matcher matcher = PREP_PATTERN.matcher(origScriptSource);
            if (matcher.matches()) {
                int gc = matcher.groupCount();
                if (gc > 0) {
                    prependedText = matcher.group(1);
                }
            }
            String fileSource;
            try {
                fileSource = fo.asText();
            } catch (IOException ioex) {
                // Can not update scripts that can not be read.
                continue;
            }
            LOG.fine("Identified changed script "+script.getName());
            if (prependedText != null) {
                if (!fileSource.startsWith(prependedText)) {
                    // It's not there already
                    fileSource = prependedText + fileSource + APP_TEXT;
                    LOG.log(Level.FINE,"Header text added: ''{0}"+"'', appended: ''"+APP_TEXT+"''", prependedText);
                }
            }
            V8Arguments changeLiveArgs = new ChangeLive.Arguments(
                    script.getId(),
                    fileSource,
                    Boolean.FALSE
                    );
            phaser.register();
            LOG.log(Level.FINE, "Running ChangeLive command for script {0}", script.getName());
            V8Request sendCLRequest = dbg.sendCommandRequest(V8Command.Changelive, changeLiveArgs, new V8Debugger.CommandResponseCallback() {
                @Override
                public void notifyResponse(V8Request request, V8Response response) {
                    try {
                        if (response != null) {
                            ChangeLive.ResponseBody clrb = (ChangeLive.ResponseBody) response.getBody();
                            if (clrb != null) {
                                ChangeLive.ChangeLog changeLog = clrb.getChangeLog();
                                if (changeLog != null) {
                                    updateBreakpoints(changeLog.getBreakpointsUpdate());
                                }
                                PropertyBoolean doStepIn = clrb.getStepInRecommended();
                                ChangeLive.Result result = clrb.getResult();
                                if (result != null) {
                                    if (!doStepIn.hasValue()) {
                                        doStepIn = result.getStackUpdateNeedsStepIn();
                                    }
                                }
                                if (doStepIn.getValue()) {
                                    doStepInto.set(true);
                                }
                            }
                        }
                    } finally {
                        LOG.fine("A ChangeLive command finished.");
                        phaser.arriveAndDeregister();
                    }
                }
            });
            if (sendCLRequest == null) {
                phaser.arriveAndDeregister();
            }
        }
        phaser.arriveAndAwaitAdvance();
        boolean doStepIn = doStepInto.get();
        doStepIn = doStepIn && dbg.isSuspended();
        LOG.log(Level.FINE, "ALl ChangeLive commands processed. Will step into = {0}", doStepIn);
        if (doStepIn) {
            final CountDownLatch cdl = new CountDownLatch(1);
            Continue.Arguments ca = new Continue.Arguments(V8StepAction.in);
            V8Request stepInRequest = dbg.sendCommandRequest(V8Command.Continue, ca, new V8Debugger.CommandResponseCallback() {
                @Override public void notifyResponse(V8Request request, V8Response response) {
                    if (response != null) {
                        dbg.addListener(new V8Debugger.Listener() {

                            @Override public void notifySuspended(boolean suspended) {
                                if (suspended) {
                                    cdl.countDown();
                                    dbg.removeListener(this);
                                }
                            }

                            @Override public void notifyCurrentFrame(CallFrame cf) {}

                            @Override public void notifyFinished() {
                                cdl.countDown();
                                dbg.removeListener(this);
                            }
                        });
                    } else {
                        cdl.countDown();
                    }
                }
            });
            if (stepInRequest != null) {
                try {
                    cdl.await();
                } catch (InterruptedException ex) {}
            }
        }
    }

    private void updateBreakpoints(BreakpointUpdate[] breakpointsUpdate) {
        for (BreakpointUpdate bu : breakpointsUpdate) {
            long bpId = bu.getId();
            BreakpointUpdate.Type type = bu.getType();
            LOG.fine("updateBreakpoint id = "+bpId+", type = "+type);
            switch (type) {
                case CopiedToOld:
                    
                    break;
                case PositionChanged:
                    Position oldPos = bu.getOldPositions();
                    Position newPos = bu.getNewPositions();
                    dbg.getBreakpointsHandler().positionChanged(bpId,
                            newPos.getLine(), newPos.getColumn());
                    break;
            }
        }
    }
    
    private void destroy() {
        if (sourceChangeRoots.length == 0) {
            FileUtil.removeFileChangeListener(sourceChangeListener);
        } else {
            for (File root : sourceChangeRoots) {
                FileUtil.removeRecursiveListener(sourceChangeListener, root);
            }
        }
    }

    private final class SourceChangeListener implements FileChangeListener {
        
        @Override
        public void fileFolderCreated(FileEvent fe) {
        }

        @Override
        public void fileDataCreated(FileEvent fe) {
        }

        @Override
        public void fileChanged(FileEvent fe) {
            fileChangeDelivery.add(fe.getFile());
            fe.runWhenDeliveryOver(fileChangeDelivery);
        }

        @Override
        public void fileDeleted(FileEvent fe) {
        }

        @Override
        public void fileRenamed(FileRenameEvent fe) {
        }

        @Override
        public void fileAttributeChanged(FileAttributeEvent fe) {
        }
        
    }
    
    private final class FileChangeDelivery implements Runnable {
        
        private final List<FileObject> changedFiles = new LinkedList<>();

        private void add(FileObject file) {
            synchronized (changedFiles) {
                changedFiles.add(file);
            }
            setHasChanges(true);
        }
        
        @Override
        public void run() {
            if (DebuggerOptions.getInstance().isLiveEdit()) {
                applyChanges();
            }
        }
        
        void applyChanges() {
            final List<FileObject> modifiedFiles;
            synchronized (changedFiles) {
                modifiedFiles = new ArrayList<>(changedFiles);
                changedFiles.clear();
            }
            setHasChanges(false);
            rp.post(new Runnable() {
                @Override
                public void run() {
                    applyModifiedFiles(modifiedFiles);
                }
            });
        }

    }
}