/*

    **** 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) 2001 Chad Fowler <chadfowler@chadfowler.com>

   * Copyright (C) 2001 Alan Moore <alan_moore@gmx.net>

   * Copyright (C) 2001-2002 Benoit Cerrina <b.cerrina@wanadoo.fr>

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

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

   * 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-2007 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;

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

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

  import static org.jruby.anno.FrameField.VISIBILITY;

  import static org.jruby.runtime.Visibility.*;

  import static org.jruby.CompatVersion.*;

  import java.lang.reflect.Field;

  import java.lang.reflect.Method;

  import java.lang.reflect.Modifier;

  import java.security.AccessControlException;

  import java.util.ArrayList;

  import java.util.Arrays;

  import java.util.Collection;

  import java.util.Collections;

  import java.util.HashMap;

  import java.util.HashSet;

  import java.util.List;

  import java.util.Map;

  import java.util.Set;

  import java.util.concurrent.ConcurrentHashMap;

  import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

  import org.jruby.anno.AnnotationBinder;

  import org.jruby.anno.JRubyClass;

  import org.jruby.anno.JRubyConstant;

  import org.jruby.anno.JRubyMethod;

  import org.jruby.anno.JavaMethodDescriptor;

  import org.jruby.anno.TypePopulator;

  import org.jruby.common.IRubyWarnings.ID;

  import org.jruby.compiler.ASTInspector;

  import org.jruby.exceptions.RaiseException;

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

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

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

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

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

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

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

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

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

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

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

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

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

  import org.jruby.javasupport.util.RuntimeHelpers;

  import org.jruby.parser.StaticScope;

  import org.jruby.runtime.Arity;

  import org.jruby.runtime.Block;

  import org.jruby.runtime.CallSite;

  import org.jruby.runtime.CallType;

  import org.jruby.runtime.ClassIndex;

  import org.jruby.runtime.MethodFactory;

  import org.jruby.runtime.ObjectAllocator;

  import org.jruby.runtime.ThreadContext;

  import org.jruby.runtime.Visibility;

  import org.jruby.runtime.builtin.IRubyObject;

  import org.jruby.runtime.builtin.Variable;

  import org.jruby.runtime.callback.Callback;

  import org.jruby.runtime.callsite.CacheEntry;

 import org.jruby.runtime.callsite.FunctionalCachingCallSite;

 import org.jruby.runtime.load.IAutoloadMethod;

 import org.jruby.runtime.marshal.MarshalStream;

 import org.jruby.runtime.marshal.UnmarshalStream;

 import org.jruby.runtime.opto.Invalidator;

 import org.jruby.runtime.opto.OptoFactory;

 import org.jruby.util.ClassProvider;

 import org.jruby.util.IdUtil;

 import org.jruby.util.collections.WeakHashSet;

 import org.jruby.util.log.Logger;

 import org.jruby.util.log.LoggerFactory;

 @JRubyClass(name="Module")

 public class RubyModule extends RubyObject {

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

     private static final boolean DEBUG = false;

     protected static final String ERR_INSECURE_SET_CONSTANT  = "Insecure: can't modify constant";

     protected static final String ERR_FROZEN_CONST_TYPE = "class/module ";

     public static final Set<String> SCOPE_CAPTURING_METHODS = new HashSet<String>(Arrays.asList(

             "eval",

             "module_eval",

             "class_eval",

             "instance_eval",

             "module_exec",

             "class_exec",

             "instance_exec",

             "binding",

             "local_variables"

             ));

     public static final ObjectAllocator MODULE_ALLOCATOR = new ObjectAllocator() {

         public IRubyObject allocate(Ruby runtime, RubyClass klass) {

             return new RubyModule(runtime, klass);

         }

     };

     public static RubyClass createModuleClass(Ruby runtime, RubyClass moduleClass) {

         moduleClass.index = ClassIndex.MODULE;

         moduleClass.setReifiedClass(RubyModule.class);

         moduleClass.kindOf = new RubyModule.KindOf() {

             @Override

             public boolean isKindOf(IRubyObject obj, RubyModule type) {

                 return obj instanceof RubyModule;

             }

         };

         moduleClass.defineAnnotatedMethods(RubyModule.class);

         moduleClass.defineAnnotatedMethods(ModuleKernelMethods.class);

         return moduleClass;

     }

     public static class ModuleKernelMethods {

         @JRubyMethod

         public static IRubyObject autoload(IRubyObject recv, IRubyObject arg0, IRubyObject arg1) {

             return RubyKernel.autoload(recv, arg0, arg1);

         }

         @JRubyMethod(name = "autoload?")

         public static IRubyObject autoload_p(ThreadContext context, IRubyObject recv, IRubyObject arg0) {

             return RubyKernel.autoload_p(context, recv, arg0);

         }

     }

     @Override

     public int getNativeTypeIndex() {

         return ClassIndex.MODULE;

     }

     @Override

     public boolean isModule() {

         return true;

     }

     @Override

     public boolean isClass() {

         return false;

     }

     public boolean isSingleton() {

         return false;

     }

     public static class KindOf {

         public static final KindOf DEFAULT_KIND_OF = new KindOf();

         public boolean isKindOf(IRubyObject obj, RubyModule type) {

             return obj.getMetaClass().hasModuleInHierarchy(type);

         }

     }

     public boolean isInstance(IRubyObject object) {

         return kindOf.isKindOf(object, this);

     }

     public Map<String, ConstantEntry> getConstantMap() {

         return constants;

     }

     public synchronized Map<String, ConstantEntry> getConstantMapForWrite() {

         return constants == Collections.EMPTY_MAP ? constants = new ConcurrentHashMap<String, ConstantEntry>(4, 0.9f, 1) : constants;

     }
    
    

     private Map<String, Autoload> getAutoloadMap() {

         return autoloads;

     }

     private synchronized Map<String, Autoload> getAutoloadMapForWrite() {

         return autoloads == Collections.EMPTY_MAP ? autoloads = new ConcurrentHashMap<String, Autoload>(4, 0.9f, 1) : autoloads;

     }

     public void addIncludingHierarchy(IncludedModuleWrapper hierarchy) {

         synchronized (getRuntime().getHierarchyLock()) {

             Set<RubyClass> oldIncludingHierarchies = includingHierarchies;

             if (oldIncludingHierarchies == Collections.EMPTY_SET) includingHierarchies = oldIncludingHierarchies = new WeakHashSet(4);

             oldIncludingHierarchies.add(hierarchy);

         }

     }

    

     protected RubyModule(Ruby runtime, RubyClass metaClass, boolean objectSpace) {

         super(runtime, metaClass, objectSpace);

         id = runtime.allocModuleId();

         runtime.addModule(this);

         // if (parent == null) parent = runtime.getObject();

         setFlag(USER7_F, !isClass());

         generationObject = generation = runtime.getNextModuleGeneration();

         if (runtime.getInstanceConfig().isProfiling()) {

             cacheEntryFactory = new ProfilingCacheEntryFactory(NormalCacheEntryFactory);

         } else {

             cacheEntryFactory = NormalCacheEntryFactory;

         }

         // set up an invalidator for use in new optimization strategies

         methodInvalidator = OptoFactory.newMethodInvalidator(this);

     }
    
    

     protected RubyModule(Ruby runtime, RubyClass metaClass) {

         this(runtime, metaClass, runtime.isObjectSpaceEnabled());

     }
    
    

     protected RubyModule(Ruby runtime) {

         this(runtime, runtime.getModule());

     }

     public boolean needsImplementer() {

         return getFlag(USER7_F);

     }
    
    

     public static RubyModule newModule(Ruby runtime) {

         return new RubyModule(runtime);

     }
    
    

     public static RubyModule newModule(Ruby runtime, String name, RubyModule parent, boolean setParent) {

         RubyModule module = newModule(runtime);

         module.setBaseName(name);

         if (setParent) module.setParent(parent);

         parent.setConstant(name, module);

         return module;

     }

     // synchronized method per JRUBY-1173 (unsafe Double-Checked Locking)

     // FIXME: synchronization is still wrong in CP code

     public synchronized void addClassProvider(ClassProvider provider) {

         if (!classProviders.contains(provider)) {

             Set<ClassProvider> cp = new HashSet<ClassProvider>(classProviders);

             cp.add(provider);

             classProviders = cp;

         }

     }

     public synchronized void removeClassProvider(ClassProvider provider) {

         Set<ClassProvider> cp = new HashSet<ClassProvider>(classProviders);

         cp.remove(provider);

         classProviders = cp;

     }

     private void checkForCyclicInclude(RubyModule m) throws RaiseException {

         if (getNonIncludedClass() == m.getNonIncludedClass()) {

             throw getRuntime().newArgumentError("cyclic include detected");

         }

     }

     private RubyClass searchProvidersForClass(String name, RubyClass superClazz) {

         RubyClass clazz;

         for (ClassProvider classProvider: classProviders) {

             if ((clazz = classProvider.defineClassUnder(this, name, superClazz)) != null) {

                 return clazz;

             }

         }

         return null;

     }

     private RubyModule searchProvidersForModule(String name) {

         RubyModule module;

         for (ClassProvider classProvider: classProviders) {

             if ((module = classProvider.defineModuleUnder(this, name)) != null) {

                 return module;

             }

         }

         return null;

     }

    

     public RubyClass getSuperClass() {

         return superClass;

     }

     public void setSuperClass(RubyClass superClass) {

         // update superclass reference

         this.superClass = superClass;

         if (superClass != null && superClass.isSynchronized()) becomeSynchronized();

     }

     public RubyModule getParent() {

         return parent;

     }

     public void setParent(RubyModule parent) {

         this.parent = parent;

     }

     public Map<String, DynamicMethod> getMethods() {

         return this.methods;

     }

     public synchronized Map<String, DynamicMethod> getMethodsForWrite() {

         Map<String, DynamicMethod> myMethods = this.methods;

         return myMethods == Collections.EMPTY_MAP ?

             this.methods = new ConcurrentHashMap<String, DynamicMethod>(0, 0.9f, 1) :

             myMethods;

     }

     // note that addMethod now does its own put, so any change made to

     // functionality here should be made there as well 

     private void putMethod(String name, DynamicMethod method) {

         getMethodsForWrite().put(name, method);

         getRuntime().addProfiledMethod(name, method);

     }

    

     public boolean isIncluded() {

         return false;

     }

     public RubyModule getNonIncludedClass() {

         return this;

     }

    

     public String getBaseName() {

         return baseName;

     }

    

     public void setBaseName(String name) {

         baseName = name;

     }

    

     public String getName() {

         if (cachedName != null) return cachedName;

         return calculateName();

     }
    
    

     public String getSimpleName() {

         if (baseName != null) return baseName;

         return calculateAnonymousName();

     }

    

     private String calculateName() {

         boolean cache = true;

         if (getBaseName() == null) {

             // we are anonymous, use anonymous name

             return calculateAnonymousName();

         }

         Ruby runtime = getRuntime();

         String name = getBaseName();

         RubyClass objectClass = runtime.getObject();

         // First, we count the parents

         int parentCount = 0;

         for (RubyModule p = getParent() ; p != null && p != objectClass ; p = p.getParent()) {

             parentCount++;

         }

         // Allocate a String array for all of their names and populate it

         String[] parentNames = new String[parentCount];

         int i = parentCount - 1;

         int totalLength = name.length() + parentCount * 2; // name length + enough :: for all parents

         for (RubyModule p = getParent() ; p != null && p != objectClass ; p = p.getParent(), i--) {

             String pName = p.getBaseName();

             // This is needed when the enclosing class or module is a singleton.

             // In that case, we generated a name such as null::Foo, which broke 

             // Marshalling, among others. The correct thing to do in this situation 

             // is to insert the generate the name of form #<Class:01xasdfasd> if 

             // it's a singleton module/class, which this code accomplishes.

             if(pName == null) {

                 cache = false;

                 pName = p.getName();

              }

             parentNames[i] = pName;

             totalLength += pName.length();

         }

         // Then build from the front using a StringBuilder

         StringBuilder builder = new StringBuilder(totalLength);

         for (String parentName : parentNames) {

             builder.append(parentName).append("::");

         }

         builder.append(name);

         String fullName = builder.toString();

         if (cache) cachedName = fullName;

         return fullName;

     }

     private String calculateAnonymousName() {

         if (anonymousName == null) {

             // anonymous classes get the #<Class:0xdeadbeef> format

             StringBuilder anonBase = new StringBuilder(isClass() ? "#<Class:0x" : "#<Module:0x");

             anonBase.append(Integer.toHexString(System.identityHashCode(this))).append('>');

             anonymousName = anonBase.toString();

         }

         return anonymousName;

     }

    

     @Deprecated

     public IncludedModuleWrapper newIncludeClass(RubyClass superClazz) {

         IncludedModuleWrapper includedModule = new IncludedModuleWrapper(getRuntime(), superClazz, this);

         // include its parent (and in turn that module's parents)

         if (getSuperClass() != null) {

             includedModule.includeModule(getSuperClass());

         }

         return includedModule;

     }
    

     public RubyClass getClass(String name) {

         IRubyObject module;

         if ((module = getConstantAt(name)) instanceof RubyClass) {

             return (RubyClass)module;

         }

         return null;

     }

     @Deprecated

     public RubyClass fastGetClass(String internedName) {

         return getClass(internedName);

     }

    

     public synchronized void includeModule(IRubyObject arg) {

         assert arg != null;

         testFrozen("module");

         if (!(arg instanceof RubyModule)) {

             throw getRuntime().newTypeError("Wrong argument type " + arg.getMetaClass().getName() +

                     " (expected Module).");

         }

         RubyModule module = (RubyModule) arg;

         // Make sure the module we include does not already exist

         checkForCyclicInclude(module);

         infectBy(module);

         doIncludeModule(module);

         invalidateCoreClasses();

         invalidateCacheDescendants();

     }

     public void defineMethod(String name, Callback method) {

         Visibility visibility = name.equals("initialize") ?

                 PRIVATE : PUBLIC;

         addMethod(name, new FullFunctionCallbackMethod(this, method, visibility));

     }

     public void defineAnnotatedMethod(Class clazz, String name) {

         // FIXME: This is probably not very efficient, since it loads all methods for each call

         boolean foundMethod = false;

         for (Method method : clazz.getDeclaredMethods()) {

             if (method.getName().equals(name) && defineAnnotatedMethod(method, MethodFactory.createFactory(getRuntime().getJRubyClassLoader()))) {

                 foundMethod = true;

             }

         }

         if (!foundMethod) {

             throw new RuntimeException("No JRubyMethod present for method " + name + "on class " + clazz.getName());

         }

     }

     public void defineAnnotatedConstants(Class clazz) {

         Field[] declaredFields = clazz.getDeclaredFields();

         for (Field field : declaredFields) {

             if (Modifier.isStatic(field.getModifiers())) {

                 defineAnnotatedConstant(field);

             }

         }

     }

     public boolean defineAnnotatedConstant(Field field) {

         JRubyConstant jrubyConstant = field.getAnnotation(JRubyConstant.class);

         if (jrubyConstant == null) return false;

         String[] names = jrubyConstant.value();

         if(names.length == 0) {

             names = new String[]{field.getName()};

         }

         Class tp = field.getType();

         IRubyObject realVal;

         try {

             if(tp == Integer.class || tp == Integer.TYPE || tp == Short.class || tp == Short.TYPE || tp == Byte.class || tp == Byte.TYPE) {

                 realVal = RubyNumeric.int2fix(getRuntime(), field.getInt(null));

             } else if(tp == Boolean.class || tp == Boolean.TYPE) {

                 realVal = field.getBoolean(null) ? getRuntime().getTrue() : getRuntime().getFalse();

             } else {

                 realVal = getRuntime().getNil();

             }

         } catch(Exception e) {

             realVal = getRuntime().getNil();

         }

         for(String name : names) {

             this.setConstant(name, realVal);

         }

         return true;

     }

     public void defineAnnotatedMethods(Class clazz) {

         defineAnnotatedMethodsIndividually(clazz);

     }

     public static class MethodClumper {

         Map<String, List<JavaMethodDescriptor>> annotatedMethods = new HashMap<String, List<JavaMethodDescriptor>>();

         Map<String, List<JavaMethodDescriptor>> staticAnnotatedMethods = new HashMap<String, List<JavaMethodDescriptor>>();

         Map<String, List<JavaMethodDescriptor>> annotatedMethods1_8 = new HashMap<String, List<JavaMethodDescriptor>>();

         Map<String, List<JavaMethodDescriptor>> staticAnnotatedMethods1_8 = new HashMap<String, List<JavaMethodDescriptor>>();

         Map<String, List<JavaMethodDescriptor>> annotatedMethods1_9 = new HashMap<String, List<JavaMethodDescriptor>>();

         Map<String, List<JavaMethodDescriptor>> staticAnnotatedMethods1_9 = new HashMap<String, List<JavaMethodDescriptor>>();

         Map<String, List<JavaMethodDescriptor>> annotatedMethods2_0 = new HashMap<String, List<JavaMethodDescriptor>>();

         Map<String, List<JavaMethodDescriptor>> staticAnnotatedMethods2_0 = new HashMap<String, List<JavaMethodDescriptor>>();

         Map<String, List<JavaMethodDescriptor>> allAnnotatedMethods = new HashMap<String, List<JavaMethodDescriptor>>();

         public void clump(Class cls) {

             Method[] declaredMethods = cls.getDeclaredMethods();

             for (Method method: declaredMethods) {

                 JRubyMethod anno = method.getAnnotation(JRubyMethod.class);

                 if (anno == null) continue;

                 JavaMethodDescriptor desc = new JavaMethodDescriptor(method);

                 String name = anno.name().length == 0 ? method.getName() : anno.name()[0];

                 List<JavaMethodDescriptor> methodDescs;

                 Map<String, List<JavaMethodDescriptor>> methodsHash = null;

                 if (desc.isStatic) {

                     if (anno.compat() == RUBY1_8) {

                         methodsHash = staticAnnotatedMethods1_8;

                     } else if (anno.compat() == RUBY1_9) {

                         methodsHash = staticAnnotatedMethods1_9;

                     } else if (anno.compat() == RUBY2_0) {

                         methodsHash = staticAnnotatedMethods2_0;

                     } else {

                         methodsHash = staticAnnotatedMethods;

                     }

                 } else {

                     if (anno.compat() == RUBY1_8) {

                         methodsHash = annotatedMethods1_8;

                     } else if (anno.compat() == RUBY1_9) {

                         methodsHash = annotatedMethods1_9;

                     } else if (anno.compat() == RUBY2_0) {

                         methodsHash = annotatedMethods2_0;

                     } else {

                         methodsHash = annotatedMethods;

                     }

                 }

                 // add to specific

                 methodDescs = methodsHash.get(name);

                 if (methodDescs == null) {

                     methodDescs = new ArrayList<JavaMethodDescriptor>();

                     methodsHash.put(name, methodDescs);

                 }

                 methodDescs.add(desc);

                 // add to general