/*
    * Copyright 2010-2013 the original author or authors.
    *
    * Licensed 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.callbackparams.internal.template;
  
  import java.lang.reflect.InvocationHandler;
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.lang.reflect.Proxy;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.IdentityHashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.ListIterator;
  import java.util.Map;
  import org.callbackparams.ext.CallbackControlPanel;
  import org.callbackparams.combine.reflect.Combined;
  
  /**
   * @author Henrik Kaipe
   */
  public class TestrunCallbacks {
  
      private static final List/*CallbackRef*/ callbackMethodParams =
              new ArrayList();
      private static final Map/*Field,CallbackRef*/ callbackInjectionFields =
              new IdentityHashMap();
      private static final Map/*Method,Object[]*/ valuesCache =
              new IdentityHashMap();
  
      /**
       * This piece of information has been saved for exceptional circumstances
       * when the test-classes has been rebyted/reloaded once more by the
       * wrapped runner from third-party.
       */
      private static final List/*Method*/ callbackMethods = new ArrayList();
      private static Collection/*Combined*/ currentCombinedRecord;
  
      /**
       * To have the class-loader as a final field makes debugging easier.
       */
  //    private final ClassLoader cl = getClass().getClassLoader();
  
      boolean currentlyWrappedWithinAdaptiveRules = false;
  
      private Collection/*Combined*/ refBackupOfCurrentCombinedRecord;
      private CallbackRecord callbackRecord;
      protected Object[] callbackMethodArguments;
  
      public static int addMethodParams(Method m) {
          callbackMethods.add(m);
          int startIndex = callbackMethodParams.size();
          for (int i = 0, size = m.getParameterTypes().length ; i < size ; ++i) {
              callbackMethodParams.add(CallbackRef.newInstance(m, i));
          }
          return startIndex;
      }
  
      public static void addFieldToInject(Field f) {
          try {
              f.setAccessible(true);
          } catch (SecurityException ignore) {
              /* We will try to access the field anyway ... */
          }
          callbackInjectionFields.put(f, CallbackRef.newInstance(f));
      }
  
      public static void setCallbackRecord(Collection testRunCombinedRecord) {
          currentCombinedRecord = testRunCombinedRecord;
      }
  
      public static Iterator iterateFields() {
          return callbackInjectionFields.keySet().iterator();
      }
  
      public static Iterator iterateMethods() {
          return callbackMethods.iterator();
      }
  
      public static Collection getCurrentCallbackRecord() {
          return currentCombinedRecord;
      }
  
     private void parseCurrentCombinedRecord() {
         this.refBackupOfCurrentCombinedRecord = currentCombinedRecord;
         List callbacks = new ArrayList(currentCombinedRecord.size());
         for (Iterator i = currentCombinedRecord.iterator(); i.hasNext();) {
             final Combined combined = Combined
                     .resurrectFromOtherClassLoader(i.next());
             Object callback = combined.retrieve(this, valuesCache);
             if (null != callback) {
                 callbacks.add(callback);
             }
         }
         this.callbackRecord = new CallbackRecord(callbacks);
     }
 
     private CallbackRecord getCallbackRecord() {
         if (this.refBackupOfCurrentCombinedRecord != currentCombinedRecord) {
             parseCurrentCombinedRecord();
         }
         return this.callbackRecord;
     }
 
     private void setupCallbackMethodArguments() {
         callbackMethodArguments = callbackMethodParams.toArray(
                 new Object[callbackMethodParams.size()]);
 
         ListIterator li = Arrays.asList(callbackMethodArguments).listIterator();
         while (li.hasNext()) {
             final CallbackRef methodParam = (CallbackRef) li.next();
             li.set(createCallbackProxy(methodParam));
         }
     }
 
     private void injectCallbackFields() {
         for (Iterator i = callbackInjectionFields.entrySet().iterator()
                 ; i.hasNext() ;) {
             Map.Entry/*Field,CallbackRef*/ fieldEntr = (Map.Entry) i.next();
             Field f = (Field) fieldEntr.getKey();
             if (f.getDeclaringClass().isInstance(this)) {
                 try {
                     f.set(this, createCallbackProxy(
                             (CallbackRef) fieldEntr.getValue()));
                 } catch (Exception ex) {
                     throw new Error("Callback injection failed for the field "
                             + f.getName() + ": " + ex.getClass().getName()
                             + " - " + ex.getMessage(), ex);
                 }
             }
         }
     }
 
     private Object createCallbackProxy(final CallbackRef ref) {
         final Class paramClass = ref.getParamClass();
         final Class[] interfaces = new Class[] {paramClass};
 
         if (CallbackControlPanel.class == paramClass
                 || org.callbackparams.CallbackControlPanel.class == paramClass) {
             return Proxy.newProxyInstance(
                     getClass().getClassLoader(), interfaces,
                     new InvocationHandler() {
                 public Object invoke(Object proxy, Method method, Object[] args)
                 throws Throwable {
                     try {
                         return method.invoke(
                                 getCallbackRecord().getCallbackControlPanel(),
                                 args);
                     } catch (InvocationTargetException x) {
                         throw x.getTargetException();
                     }
                 }
             });
             
 
         } else {
             return Proxy.newProxyInstance(
                     paramClass.getClassLoader(), interfaces,
                     new InvocationHandler() {
                 CallbackRecord record;
                 InvocationHandler wrappedInvokeHandler;
                 public Object invoke(Object proxy, Method method, Object[] args)
                 throws Throwable {
                     if (getCallbackRecord() != record) {
                         record = getCallbackRecord();
                         wrappedInvokeHandler = record.newCallbackInvoker(ref);
                     }
                     return wrappedInvokeHandler.invoke(proxy, method, args);
                 }
             });
         }
     }
 
     private void init() throws Exception {
         if (null == currentCombinedRecord) {
             ThirdPartyReloadingWorkaround.getInstance()
                     .resurrectSetup(getClass());
         }
 
         parseCurrentCombinedRecord();
         setupCallbackMethodArguments();
         injectCallbackFields();
     }
 
     public TestrunCallbacks() throws Exception {
         init();
     }
 }