/*

    ***** BEGIN LICENSE BLOCK *****

    * Version: CPL 1.0/GPL 2.0/LGPL 2.1

    *

    * The contents of this file are subject to the Common Public

    * License Version 1.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.eclipse.org/legal/cpl-v10.html

    *

   * Software distributed under the License is distributed on an "AS

   * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or

   * implied. See the License for the specific language governing

   * rights and limitations under the License.

   *

   * Copyright (C) 2002-2004 Anders Bengtsson <ndrsbngtssn@yahoo.se>

   * Copyright (C) 2002-2004 Jan Arne Petersen <jpetersen@uni-bonn.de>

   * Copyright (C) 2004 Thomas E Enebo <enebo@acm.org>

   * Copyright (C) 2004-2005 Charles O Nutter <headius@headius.com>

   * Copyright (C) 2004 Stefan Matthias Aust <sma@3plus4.de>

   * Copyright (C) 2006 Michael Studman <codehaus@michaelstudman.com>

   * Copyright (C) 2006 Miguel Covarrubias <mlcovarrubias@gmail.com>

   * Copyright (C) 2007 William N Dortch <bill.dortch@gmail.com>

   *

   * Alternatively, the contents of this file may be used under the terms of

   * either of the GNU General Public License Version 2 or later (the "GPL"),

   * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

   * in which case the provisions of the GPL or the LGPL are applicable instead

   * of those above. If you wish to allow use of your version of this file only

   * under the terms of either the GPL or the LGPL, and not to allow others to

   * use your version of this file under the terms of the CPL, indicate your

   * decision by deleting the provisions above and replace them with the notice

   * and other provisions required by the GPL or the LGPL. If you do not delete

   * the provisions above, a recipient may use your version of this file under

   * the terms of any one of the CPL, the GPL or the LGPL.

   ***** END LICENSE BLOCK *****/

  package org.jruby.runtime;

  import java.util.ArrayList;

  import java.util.List;

  import java.util.Locale;

  import java.util.Set;

  import org.jruby.Ruby;

  import org.jruby.RubyArray;

  import org.jruby.RubyClass;

  import org.jruby.RubyContinuation.Continuation;

  import org.jruby.RubyInstanceConfig;

  import org.jruby.RubyModule;

  import org.jruby.RubyString;

  import org.jruby.RubyThread;

  import org.jruby.ast.executable.RuntimeCache;

  import org.jruby.exceptions.JumpException.ReturnJump;

  import org.jruby.internal.runtime.methods.DynamicMethod;

  import org.jruby.lexer.yacc.ISourcePosition;

  import org.jruby.ext.fiber.Fiber;

  import org.jruby.parser.StaticScope;

  import org.jruby.runtime.backtrace.BacktraceElement;

  import org.jruby.runtime.backtrace.RubyStackTraceElement;

  import org.jruby.runtime.backtrace.TraceType;

  import org.jruby.runtime.backtrace.TraceType.Gather;

  import org.jruby.runtime.backtrace.BacktraceElement;

  import org.jruby.runtime.backtrace.RubyStackTraceElement;

  import org.jruby.runtime.builtin.IRubyObject;

  import org.jruby.runtime.profile.ProfileData;

  import org.jruby.runtime.scope.ManyVarsDynamicScope;

  import org.jruby.util.RecursiveComparator;

  import org.jruby.util.RubyDateFormat;

  import org.jruby.util.log.Logger;

  import org.jruby.util.log.LoggerFactory;

  public final class ThreadContext {

      private static final Logger LOG = LoggerFactory.getLogger("ThreadContext");

      public static ThreadContext newContext(Ruby runtime) {

          ThreadContext context = new ThreadContext(runtime);

          return context;

      }

      private final static int INITIAL_SIZE = 10;

      private final static int INITIAL_FRAMES_SIZE = 10;
    
    

      private final static int CALL_POLL_COUNT = 0xFFF;

      // runtime, nil, and runtimeCache cached here for speed of access from any thread

      public final Ruby runtime;

      public final IRubyObject nil;

      public final RuntimeCache runtimeCache;

      public final boolean is19;

      // Is this thread currently with in a function trace?

      private boolean isWithinTrace;

      private RubyThread thread;

      private Fiber fiber;

      // Cache format string because it is expensive to create on demand

      private RubyDateFormat dateFormat;

     private RubyModule[] parentStack = new RubyModule[INITIAL_SIZE];

     private int parentIndex = -1;

     private Frame[] frameStack = new Frame[INITIAL_FRAMES_SIZE];

     private int frameIndex = -1;

     private BacktraceElement[] backtrace = new BacktraceElement[INITIAL_FRAMES_SIZE];

     private int backtraceIndex = -1;

     // List of active dynamic scopes.  Each of these may have captured other dynamic scopes

     // to implement closures.

     private DynamicScope[] scopeStack = new DynamicScope[INITIAL_SIZE];

     private int scopeIndex = -1;

     private static final Continuation[] EMPTY_CATCHTARGET_STACK = new Continuation[0];

     private Continuation[] catchStack = EMPTY_CATCHTARGET_STACK;

     private int catchIndex = -1;

     private boolean isProfiling = false;

     // The flat profile data for this thread

 	private ProfileData profileData;

     // In certain places, like grep, we don't use real frames for the

     // call blocks. This has the effect of not setting the backref in

     // the correct frame - this delta is activated to the place where

     // the grep is running in so that the backref will be set in an

     // appropriate place.

     private int rubyFrameDelta = 0;

     private boolean eventHooksEnabled = true;

     CallType lastCallType;

     Visibility lastVisibility;

     IRubyObject lastExitStatus;
    
    

     private ThreadContext(Ruby runtime) {

         this.runtime = runtime;

         this.nil = runtime.getNil();

         this.is19 = runtime.is1_9();

         if (runtime.getInstanceConfig().isProfilingEntireRun())

             startProfiling();

         this.runtimeCache = runtime.getRuntimeCache();

         // TOPLEVEL self and a few others want a top-level scope.  We create this one right

         // away and then pass it into top-level parse so it ends up being the top level.

         StaticScope topStaticScope = runtime.getStaticScopeFactory().newLocalScope(null);

         pushScope(new ManyVarsDynamicScope(topStaticScope, null));

         Frame[] stack = frameStack;

         int length = stack.length;

         for (int i = 0; i < length; i++) {

             stack[i] = new Frame();

         }

         BacktraceElement[] stack2 = backtrace;

         int length2 = stack2.length;

         for (int i = 0; i < length2; i++) {

             stack2[i] = new BacktraceElement();

         }

         ThreadContext.pushBacktrace(this, "", "", 0);

         ThreadContext.pushBacktrace(this, "", "", 0);

         fiber = (Fiber) runtime.getRootFiber();

     }

     @Override

     protected void finalize() throws Throwable {

         if (thread != null) {

             thread.dispose();

         }

     }

    

     public final Ruby getRuntime() {

         return runtime;

     }

     public IRubyObject getErrorInfo() {

         return thread.getErrorInfo();

     }

     public IRubyObject setErrorInfo(IRubyObject errorInfo) {

         thread.setErrorInfo(errorInfo);

         return errorInfo;

     }

     public ReturnJump returnJump(IRubyObject value) {

         return new ReturnJump(getFrameJumpTarget(), value);

     }
    
    

     public void setLastCallStatus(CallType callType) {

         lastCallType = callType;

     }

     public CallType getLastCallType() {

         return lastCallType;

     }

     public void setLastVisibility(Visibility visibility) {

         lastVisibility = visibility;

     }

     public Visibility getLastVisibility() {

         return lastVisibility;

     }

     public void setLastCallStatusAndVisibility(CallType callType, Visibility visibility) {

         lastCallType = callType;

         lastVisibility = visibility;

     }

     public IRubyObject getLastExitStatus() {

         return lastExitStatus;

     }

     public void setLastExitStatus(IRubyObject lastExitStatus) {

         this.lastExitStatus = lastExitStatus;

     }

     public void printScope() {

         LOG.debug("SCOPE STACK:");

         for (int i = 0; i <= scopeIndex; i++) {

             LOG.debug("{}", scopeStack[i]);

         }

     }

     public DynamicScope getCurrentScope() {

         return scopeStack[scopeIndex];

     }

     public DynamicScope getPreviousScope() {

         return scopeStack[scopeIndex - 1];

     }

     private void expandFramesIfNecessary() {

         int newSize = frameStack.length * 2;

         frameStack = fillNewFrameStack(new Frame[newSize], newSize);

     }

     private Frame[] fillNewFrameStack(Frame[] newFrameStack, int newSize) {

         System.arraycopy(frameStack, 0, newFrameStack, 0, frameStack.length);

         for (int i = frameStack.length; i < newSize; i++) {

             newFrameStack[i] = new Frame();

         }

         return newFrameStack;

     }

     private void expandParentsIfNecessary() {

         int newSize = parentStack.length * 2;

         RubyModule[] newParentStack = new RubyModule[newSize];

         System.arraycopy(parentStack, 0, newParentStack, 0, parentStack.length);

         parentStack = newParentStack;

     }

     public void pushScope(DynamicScope scope) {

         int index = ++scopeIndex;

         DynamicScope[] stack = scopeStack;

         stack[index] = scope;

         if (index + 1 == stack.length) {

             expandScopesIfNecessary();

         }

     }

     public void popScope() {

         scopeStack[scopeIndex--] = null;

     }

     private void expandScopesIfNecessary() {

         int newSize = scopeStack.length * 2;

         DynamicScope[] newScopeStack = new DynamicScope[newSize];

         System.arraycopy(scopeStack, 0, newScopeStack, 0, scopeStack.length);

         scopeStack = newScopeStack;

     }

     public RubyThread getThread() {

         return thread;

     }

     public RubyDateFormat getRubyDateFormat() {

         if (dateFormat == null) dateFormat = new RubyDateFormat("-", Locale.US, runtime.is1_9());

         return dateFormat;

     }

     public void setThread(RubyThread thread) {

         this.thread = thread;

         // associate the thread with this context, unless we're clearing the reference

         if (thread != null) {

             thread.setContext(this);

         }

     }

     public Fiber getFiber() {

         return fiber;

     }

     public void setFiber(Fiber fiber) {

         this.fiber = fiber;

     }

     //////////////////// CATCH MANAGEMENT ////////////////////////

     private void expandCatchIfNecessary() {

         int newSize = catchStack.length * 2;

         if (newSize == 0) newSize = 1;

         Continuation[] newCatchStack = new Continuation[newSize];

         System.arraycopy(catchStack, 0, newCatchStack, 0, catchStack.length);

         catchStack = newCatchStack;

     }

     public void pushCatch(Continuation catchTarget) {

         int index = ++catchIndex;

         if (index == catchStack.length) {

             expandCatchIfNecessary();

         }

         catchStack[index] = catchTarget;

     }

     public void popCatch() {

         catchIndex--;

     }

    

     public Continuation getActiveCatch(Object tag) {

         for (int i = catchIndex; i >= 0; i--) {

             Continuation c = catchStack[i];

             if (runtime.is1_9()) {

                 if (c.tag == tag) return c;

             } else {

                 if (c.tag.equals(tag)) return c;

             }

         }

         return null;

     }

     //////////////////// FRAME MANAGEMENT ////////////////////////

     private void pushFrameCopy() {

         int index = ++this.frameIndex;

         Frame[] stack = frameStack;

         Frame currentFrame = stack[index - 1];

         stack[index].updateFrame(currentFrame);

         if (index + 1 == stack.length) {

             expandFramesIfNecessary();

         }

     }

     private Frame pushFrame(Frame frame) {

         int index = ++this.frameIndex;

         Frame[] stack = frameStack;

         stack[index] = frame;

         if (index + 1 == stack.length) {

             expandFramesIfNecessary();

         }

         return frame;

     }

     private void pushCallFrame(RubyModule clazz, String name, 

                                IRubyObject self, Block block) {

         int index = ++this.frameIndex;

         Frame[] stack = frameStack;

         stack[index].updateFrame(clazz, self, name, block, callNumber);

         if (index + 1 == stack.length) {

             expandFramesIfNecessary();

         }

     }

     private void pushEvalFrame(IRubyObject self) {

         int index = ++this.frameIndex;

         Frame[] stack = frameStack;

         stack[index].updateFrameForEval(self, callNumber);

         if (index + 1 == stack.length) {

             expandFramesIfNecessary();

         }

     }

     private void pushFrame(String name) {

         int index = ++this.frameIndex;

         Frame[] stack = frameStack;

         stack[index].updateFrame(name);

         if (index + 1 == stack.length) {

             expandFramesIfNecessary();

         }

     }

     public void pushFrame() {

         int index = ++this.frameIndex;

         Frame[] stack = frameStack;

         if (index + 1 == stack.length) {

             expandFramesIfNecessary();

         }

     }

     public void popFrame() {

         Frame frame = frameStack[frameIndex--];

         frame.clear();

     }

     private void popFrameReal(Frame oldFrame) {

         frameStack[frameIndex--] = oldFrame;

     }

     public Frame getCurrentFrame() {

         return frameStack[frameIndex];

     }

     public int getRubyFrameDelta() {

         return this.rubyFrameDelta;

     }

     public void setRubyFrameDelta(int newDelta) {

         this.rubyFrameDelta = newDelta;

     }

     public Frame getCurrentRubyFrame() {

         return frameStack[frameIndex-rubyFrameDelta];

     }

     public Frame getNextFrame() {

         int index = frameIndex;

         Frame[] stack = frameStack;

         if (index + 1 == stack.length) {

             expandFramesIfNecessary();

         }

         return stack[index + 1];

     }

     public Frame getPreviousFrame() {

         int index = frameIndex;

         return index < 1 ? null : frameStack[index - 1];

     }

     public int getFrameCount() {

         return frameIndex + 1;

     }

     public Frame[] getFrames(int delta) {

         int top = frameIndex + delta;

         Frame[] frames = new Frame[top + 1];

         for (int i = 0; i <= top; i++) {

             frames[i] = frameStack[i].duplicateForBacktrace();

         }

         return frames;

     }

     /////////////////// BACKTRACE ////////////////////

     private static void expandBacktraceIfNecessary(ThreadContext context) {

         int newSize = context.backtrace.length * 2;

         context.backtrace = fillNewBacktrace(context, new BacktraceElement[newSize], newSize);

     }

     private static BacktraceElement[] fillNewBacktrace(ThreadContext context, BacktraceElement[] newBacktrace, int newSize) {

         System.arraycopy(context.backtrace, 0, newBacktrace, 0, context.backtrace.length);

         for (int i = context.backtrace.length; i < newSize; i++) {

             newBacktrace[i] = new BacktraceElement();

         }

         return newBacktrace;

     }

     public static void pushBacktrace(ThreadContext context, String method, ISourcePosition position) {

         int index = ++context.backtraceIndex;

         BacktraceElement[] stack = context.backtrace;

         BacktraceElement.update(stack[index], method, position);

         if (index + 1 == stack.length) {

             ThreadContext.expandBacktraceIfNecessary(context);

         }

     }

     public static void pushBacktrace(ThreadContext context, String method, String file, int line) {

         int index = ++context.backtraceIndex;

         BacktraceElement[] stack = context.backtrace;

         BacktraceElement.update(stack[index], method, file, line);

         if (index + 1 == stack.length) {

             ThreadContext.expandBacktraceIfNecessary(context);

         }

     }

     public static void popBacktrace(ThreadContext context) {

         context.backtraceIndex--;

     }

    

     public boolean isJumpTargetAlive(int target, int skipFrames) {

         for (int i = frameIndex - skipFrames; i >= 0; i--) {

             if (frameStack[i].getJumpTarget() == target) return true;

         }

         return false;

     }

    

     public boolean scopeExistsOnCallStack(StaticScope s) {

         DynamicScope[] stack = scopeStack;

         for (int i = scopeIndex; i >= 0; i--) {

            if (stack[i].getStaticScope() == s) return true;

         }

         return false;

     }

     public String getFrameName() {

         return getCurrentFrame().getName();

     }

     public IRubyObject getFrameSelf() {

         return getCurrentFrame().getSelf();

     }

     public int getFrameJumpTarget() {

         return getCurrentFrame().getJumpTarget();

     }

     public RubyModule getFrameKlazz() {

         return getCurrentFrame().getKlazz();

     }

     public Block getFrameBlock() {

         return getCurrentFrame().getBlock();

     }

     public String getFile() {

         return backtrace[backtraceIndex].filename;

     }

     public int getLine() {

         return backtrace[backtraceIndex].line;

     }

     public void setLine(int line) {

         backtrace[backtraceIndex].line = line;

     }

     public void setFileAndLine(String file, int line) {

         BacktraceElement b = backtrace[backtraceIndex];

         b.filename = file;

         b.line = line;

     }

     public void setFileAndLine(ISourcePosition position) {

         BacktraceElement b = backtrace[backtraceIndex];

         b.filename = position.getFile();

         b.line = position.getStartLine();

     }

     public Visibility getCurrentVisibility() {

         return getCurrentFrame().getVisibility();

     }

     public Visibility getPreviousVisibility() {

         return getPreviousFrame().getVisibility();

     }

     public void setCurrentVisibility(Visibility visibility) {

         getCurrentFrame().setVisibility(visibility);

     }

     public void pollThreadEvents() {

         thread.pollThreadEvents(this);

     }

     public int callNumber = 0;

     public int getCurrentTarget() {

         return callNumber;

     }

     public void callThreadPoll() {

         if ((callNumber++ & CALL_POLL_COUNT) == 0) pollThreadEvents();

     }

     public static void callThreadPoll(ThreadContext context) {

         if ((context.callNumber++ & CALL_POLL_COUNT) == 0) context.pollThreadEvents();

     }

     public void trace(RubyEvent event, String name, RubyModule implClass) {

         trace(event, name, implClass, backtrace[backtraceIndex].filename, backtrace[backtraceIndex].line);

     }

     public void trace(RubyEvent event, String name, RubyModule implClass, String file, int line) {

         runtime.callEventHooks(this, event, file, line, name, implClass);

     }

     public void pushRubyClass(RubyModule currentModule) {

         // FIXME: this seems like a good assertion, but it breaks compiled code and the code seems

         // to run without it...

         //assert currentModule != null : "Can't push null RubyClass";

         int index = ++parentIndex;

         RubyModule[] stack = parentStack;

         stack[index] = currentModule;

         if (index + 1 == stack.length) {

             expandParentsIfNecessary();

         }

     }

     public RubyModule popRubyClass() {

         int index = parentIndex;

         RubyModule[] stack = parentStack;

         RubyModule ret = stack[index];

         stack[index] = null;

         parentIndex = index - 1;

         return ret;

     }