/*
 * Copyright (c) 2004, 2007, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

package sun.jvm.hotspot.utilities.soql;

import java.util.*;
import javax.script.ScriptException;
import sun.jvm.hotspot.debugger.*;
import sun.jvm.hotspot.memory.*;
import sun.jvm.hotspot.oops.*;
import sun.jvm.hotspot.runtime.*;
import sun.jvm.hotspot.utilities.*;
import java.lang.reflect.Method;

public class JSJavaHeap extends DefaultScriptObject {
    private static final int FIELD_CAPACITY = 0;
    private static final int FIELD_USED = 1;
    private static final int FIELD_FOR_EACH_OBJECT = 2;
    private static final int FIELD_FOR_EACH_CLASS = 3;

    private static final int FIELD_UNDEFINED = -1;

    public JSJavaHeap(JSJavaFactory fac) {
        this.factory = fac;
    }

    public Object get(String name) {
        int fieldID = getFieldID(name);
        switch (fieldID) {
        case FIELD_CAPACITY:
            return new Long(getCapacity());
        case FIELD_USED:
            return new Long(getUsed());
        case FIELD_FOR_EACH_OBJECT:
            return new MethodCallable(this, forEachObjectMethod);
        case FIELD_FOR_EACH_CLASS:
            return new MethodCallable(this, forEachClassMethod);
        case FIELD_UNDEFINED:
        default:
            return super.get(name);
        }
    }

    public Object[] getIds() {
        Object[] superIds = super.getIds();
        Object[] tmp = fields.keySet().toArray();
        Object[] res = new Object[superIds.length + tmp.length];
        System.arraycopy(tmp, 0, res, 0, tmp.length);
        System.arraycopy(superIds, 0, res, tmp.length, superIds.length);
        return res;
    }

    public boolean has(String name) {
        if (getFieldID(name) != FIELD_UNDEFINED) {
            return true;
        } else {
            return super.has(name);
        }
    }

    public void put(String name, Object value) {
        if (getFieldID(name) == FIELD_UNDEFINED) {
            super.put(name, value);
        }
    }

    public void forEachObject(Object[] args) {
        boolean subtypes = true;
        Klass kls = null;
        Callable func = null;
        switch (args.length) {
        case 3: {
            Object b = args[2];
            if (b != null && b instanceof Boolean) {
                subtypes = ((Boolean)b).booleanValue();
            }
        }
        case 2: {
            Object k = args[1];
            if (k == null) return;
            if (k instanceof JSJavaKlass) {
                kls = ((JSJavaKlass)k).getKlass();
            } else if (k instanceof String) {
                kls = SystemDictionaryHelper.findInstanceKlass((String)k);
                if (kls == null) return;
            }
        }
        case 1: {
            Object f = args[0];
            if (f != null && f instanceof Callable) {
                func = (Callable) f;
            } else {
                // unknown target - just return
                return ;
            }
        }
        break;

        default:
            return;
        }

        final Callable finalFunc = func;
      HeapVisitor visitor = new DefaultHeapVisitor() {
                public boolean doObj(Oop oop) {
                    JSJavaObject jo = factory.newJSJavaObject(oop);
                    if (jo != null) {
                  try {
                    finalFunc.call(new Object[] { jo });
                  } catch (ScriptException exp) {
                    throw new RuntimeException(exp);
                  }
                    }
                return false;
                }
            };
        ObjectHeap heap = VM.getVM().getObjectHeap();
        if (kls == null) {
            kls = SystemDictionaryHelper.findInstanceKlass("java.lang.Object");
        }
        heap.iterateObjectsOfKlass(visitor, kls, subtypes);
    }

    public void forEachClass(Object[] args) {
        boolean withLoader = false;
        Callable func = null;
        switch (args.length) {
        case 2: {
            Object b = args[1];
            if (b instanceof Boolean) {
                withLoader = ((Boolean)b).booleanValue();
            }
        }
        case 1: {
            Object f = args[0];
            if (f instanceof Callable) {
                func = (Callable) f;
            } else {
                return;
            }
        }
        break;
        default:
            return;
        }

      final Callable finalFunc = func;
        SystemDictionary sysDict = VM.getVM().getSystemDictionary();
        if (withLoader) {
            sysDict.classesDo(new SystemDictionary.ClassAndLoaderVisitor() {
                    public void visit(Klass kls, Oop loader) {
                        JSJavaKlass  jk = factory.newJSJavaKlass(kls);
                        if (jk == null) {
                            return;
                        }
                        JSJavaObject k = jk.getJSJavaClass();
                        JSJavaObject l = factory.newJSJavaObject(loader);
                        if (k != null) {
                         if (k != null) {
                       try {
                               finalFunc.call(new Object[] { k, l });
                       } catch (ScriptException exp) {
                         throw new RuntimeException(exp);
                       }
                           }
                        }
                    }
                });

        } else {
            sysDict.classesDo(new SystemDictionary.ClassVisitor() {
                    public void visit(Klass kls) {
                        JSJavaKlass jk = factory.newJSJavaKlass(kls);
                        if (jk == null) {
                            return;
                        }
                        JSJavaClass k = jk.getJSJavaClass();
                        if (k != null) {
                            if (k != null) {
                        try {
                                  finalFunc.call(new Object[] { k });
                        } catch (ScriptException exp) {
                          throw new RuntimeException(exp);
                        }
                            }
                        }
                    }
                });
        }
    }

    public String toString() {
        StringBuffer buf = new StringBuffer();
        buf.append("Java Heap (capacity=");
        buf.append(getCapacity());
        buf.append(", used=");
        buf.append(getUsed());
        buf.append(")");
        return buf.toString();
    }

    //-- Internals only below this point
    private static Map fields = new HashMap();
    private static void addField(String name, int fieldId) {
        fields.put(name, new Integer(fieldId));
    }

    private static int getFieldID(String name) {
        Integer res = (Integer) fields.get(name);
        return (res != null)? res.intValue() : FIELD_UNDEFINED;
    }

    static {
        addField("capacity", FIELD_CAPACITY);
        addField("used", FIELD_USED);
        addField("forEachObject", FIELD_FOR_EACH_OBJECT);
        addField("forEachClass", FIELD_FOR_EACH_CLASS);
      try {
          Class myClass = JSJavaHeap.class;
          forEachObjectMethod = myClass.getMethod("forEachObject",
                                new Class[] { Object[].class });
          forEachClassMethod = myClass.getMethod("forEachClass",
                                new Class[] {Object[].class });
      } catch (RuntimeException re) {
          throw re;
      } catch (Exception exp) {
          throw new RuntimeException(exp);
      }
    }

    private long getCapacity() {
        return VM.getVM().getUniverse().heap().capacity();
    }

    private long getUsed() {
        return VM.getVM().getUniverse().heap().used();
    }

    private final JSJavaFactory factory;
    private static Method forEachObjectMethod;
    private static Method forEachClassMethod;
}