/**

  * Back 2 Browser Bytecode Translator

  * Copyright (C) 2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

  *

  * This program is free software: you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation, version 2 of the License.

  *

  * This program 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 for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program. Look for COPYING file in the top folder.

  * If not, see http://opensource.org/licenses/GPL-2.0.

  */

 package org.apidesign.bck2brwsr.emul.reflect;

 import java.lang.reflect.Array;

 import java.lang.reflect.Constructor;

 import java.lang.reflect.Method;

 import java.util.Enumeration;

 import org.apidesign.bck2brwsr.core.Exported;

 import org.apidesign.bck2brwsr.core.JavaScriptBody;

 /** Utilities to work on methods.

  *

  * @author Jaroslav Tulach <jtulach@netbeans.org>

  */

 public abstract class MethodImpl {

     public static MethodImpl INSTANCE;

     static {

         try {

             Class.forName(Method.class.getName());

         } catch (ClassNotFoundException ex) {

             throw new IllegalStateException(ex);

         }

     }

     protected abstract Method create(Class<?> declaringClass, String name, Object data, String sig);

     protected abstract Constructor create(Class<?> declaringClass, Object data, String sig);

     //

     // bck2brwsr implementation

     //

     @JavaScriptBody(args = {"clazz", "prefix", "cnstr"},

         body = ""

         + "var c = clazz.cnstr;\n"

         + "if (!cnstr) c = c.prototype;\n"

         + "var arr = new Array();\n"

         + "function check(m, verify) {\n"

         + "  if (m.indexOf(prefix) === 0) {\n"

         + "     if (!c[m].cls) return;\n"

         + "     if (verify) {\n"

         + "       for (var i = 0; i < arr.length; i += 3) {\n"

         + "         if (arr[i] === m) return;\n"

         + "       }\n"

         + "     }\n"

         + "     arr.push(m);\n"

         + "     arr.push(c[m]);\n"

         + "     arr.push(c[m].cls.$class);\n"

         + "  }\n"

         + "}\n"

         + "for (m in c) {\n"

         + "  check(m)\n"

         + "}\n"

         + "check('wait__V', true);\n"

         + "check('wait__VJ', true);\n"

         + "check('wait__VJI', true);\n"

         + "check('equals__ZLjava_lang_Object_2', true);\n"

         + "check('toString__Ljava_lang_String_2', true);\n"

         + "check('hashCode__I', true);\n"

         + "check('getClass__Ljava_lang_Class_2', true);\n"

         + "check('notify__V', true);\n"

         + "check('notifyAll__V', true);\n"

         + "return arr;\n")

     private static native Object[] findMethodData(

         Class<?> clazz, String prefix, boolean cnstr);

     public static Constructor findConstructor(

         Class<?> clazz, Class<?>... parameterTypes) {

         Object[] data = findMethodData(clazz, "cons__", true);

         BIG: for (int i = 0; i < data.length; i += 3) {

             String sig = ((String) data[i]).substring(6);

             Class<?> cls = (Class<?>) data[i + 2];

             Constructor tmp = INSTANCE.create(cls, data[i + 1], sig);

             Class<?>[] tmpParms = tmp.getParameterTypes();

             if (parameterTypes.length != tmpParms.length) {

                 continue;

             }

             for (int j = 0; j < tmpParms.length; j++) {

                 if (!parameterTypes[j].equals(tmpParms[j])) {

                     continue BIG;

                 }

             }

             return tmp;

         }

         return null;

     }

     public static Constructor[] findConstructors(Class<?> clazz, int mask) {

         Object[] namesAndData = findMethodData(clazz, "", true);

         int cnt = 0;

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

             String sig = (String) namesAndData[i];

             Object data = namesAndData[i + 1];

             if (!sig.startsWith("cons__")) {

                 continue;

             }

             sig = sig.substring(6);

             Class<?> cls = (Class<?>) namesAndData[i + 2];

             final Constructor m = INSTANCE.create(cls, data, sig);

             if ((m.getModifiers() & mask) == 0) {

                 continue;

             }

             namesAndData[cnt++] = m;

         }

         Constructor[] arr = new Constructor[cnt];

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

             arr[i] = (Constructor) namesAndData[i];

         }

         return arr;

     }

     public static Method findMethod(

         Class<?> clazz, String name, Class<?>... parameterTypes) {

         Object[] data = findMethodData(clazz, name + "__", false);

         BIG: for (int i = 0; i < data.length; i += 3) {

             String sig = ((String) data[i]).substring(name.length() + 2);

             Class<?> cls = (Class<?>) data[i + 2];

             Method tmp = INSTANCE.create(cls, name, data[i + 1], sig);

             Class<?>[] tmpParms = tmp.getParameterTypes();

             if (parameterTypes.length != tmpParms.length) {

                 continue;

             }

             for (int j = 0; j < tmpParms.length; j++) {

                 if (!parameterTypes[j].equals(tmpParms[j])) {

                     continue BIG;

                 }

             }

             return tmp;

         }

         return null;

     }

     public static Method[] findMethods(Class<?> clazz, int mask) {

         Object[] namesAndData = findMethodData(clazz, "", false);

         int cnt = 0;

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

             String sig = (String) namesAndData[i];

             Object data = namesAndData[i + 1];

             int middle = sig.indexOf("__");

             if (middle == -1) {

                 continue;

             }

             if (sig.startsWith("$") && sig.endsWith("$")) {

                 // produced by Closure compiler in debug mode

                 // needs to be ignored

                 continue;

             }

             String name = sig.substring(0, middle);

             sig = sig.substring(middle + 2);

             Class<?> cls = (Class<?>) namesAndData[i + 2];

             final Method m = INSTANCE.create(cls, name, data, sig);

             if ((m.getModifiers() & mask) == 0) {

                 continue;

             }

             namesAndData[cnt++] = m;

         }

         Method[] arr = new Method[cnt];

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

             arr[i] = (Method) namesAndData[i];

         }

         return arr;

     }

     @Exported static String toSignature(Method m) {

         StringBuilder sb = new StringBuilder();

         sb.append(m.getName()).append("__");

         appendType(sb, m.getReturnType());

         Class<?>[] arr = m.getParameterTypes();

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

             appendType(sb, arr[i]);

         }

         return sb.toString();

     }

     private static void appendType(StringBuilder sb, Class<?> type) {

         if (type == Integer.TYPE) {

             sb.append('I');

             return;

         }

         if (type == Long.TYPE) {

             sb.append('J');

             return;

         }

         if (type == Double.TYPE) {

             sb.append('D');

             return;

         }

         if (type == Float.TYPE) {

             sb.append('F');

             return;

         }

         if (type == Byte.TYPE) {

             sb.append('B');

             return;

         }

         if (type == Boolean.TYPE) {

             sb.append('Z');

             return;

         }

         if (type == Short.TYPE) {

             sb.append('S');

             return;

         }

         if (type == Void.TYPE) {

             sb.append('V');

             return;

         }

         if (type == Character.TYPE) {

             sb.append('C');

             return;

         }

         if (type.isArray()) {

             sb.append("_3");

             appendType(sb, type.getComponentType());

             return;

         }

         sb.append('L').append(type.getName().replace('.', '_'));

         sb.append("_2");

     }

     public static int signatureElements(String sig) {

         Enumeration<Class> en = signatureParser(sig);

         int cnt = 0;

         while (en.hasMoreElements()) {

             en.nextElement();

             cnt++;

         }

         return cnt;

     }

     public static Enumeration<Class> signatureParser(final String sig) {

         class E implements Enumeration<Class> {

             int pos;

             int len;

             E() {

                 len = sig.length();

                 while (sig.charAt(len - 1) == '$') {

                     len--;

                 }

             }

             public boolean hasMoreElements() {

                 return pos < len;

             }

             public Class nextElement() {

                 switch (sig.charAt(pos++)) {

                     case 'I':

                         return Integer.TYPE;

                     case 'J':

                         return Long.TYPE;

                     case 'D':

                         return Double.TYPE;

                     case 'F':

                         return Float.TYPE;

                     case 'B':

                         return Byte.TYPE;

                     case 'Z':

                         return Boolean.TYPE;

                     case 'S':

                         return Short.TYPE;

                     case 'V':

                         return Void.TYPE;

                     case 'C':

                         return Character.TYPE;

                     case 'L':

                         try {

                             int up = sig.indexOf("_2", pos);

                             String type = sig.substring(pos, up);

                             pos = up + 2;

                             return Class.forName(type.replace('_', '.'));

                         } catch (ClassNotFoundException ex) {

                             throw new IllegalStateException(ex);

                         }

                     case '_': {

                         char nch = sig.charAt(pos++);

                         assert nch == '3' : "Can't find '3' at " + sig.substring(pos - 1);

                         final Class compType = nextElement();

                         return Array.newInstance(compType, 0).getClass();

                     }

                 }

                 throw new UnsupportedOperationException(sig + " at " + pos);

             }

         }

         return new E();

     }

 }