/*
 * Created on Oct 24, 2010
 */

package engine.rts;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.NoSuchElementException;

import craterstudio.data.tuples.Pair;

public class Binding
{
   class Callback
   {
      final Object target;
      final Method method;

      public Callback(Object target, Method method)
      {
         this.target = target;
         this.method = method;
      }

      public void call()
      {
         try
         {
            this.method.invoke(this.target, new Object[] { Binding.this.source });
         }
         catch (Exception exc)
         {
            throw new RuntimeException(exc);
         }
      }
   }

   final Object                              source;
   private final Map<String, List<Callback>> eventToCallbacks;

   public Binding(Object source)
   {
      this.source = source;
      this.eventToCallbacks = new HashMap<String, List<Callback>>();
   }

   public void listen(String event, Object target)
   {
      String methodName = fromEventToMethodname(event);
      Method method = findMethod(target, methodName);

      List<Callback> callbacks = this.eventToCallbacks.get(event);
      if (callbacks == null)
         this.eventToCallbacks.put(event, callbacks = new ArrayList<Callback>());
      callbacks.add(new Callback(target, method));
   }

   public void fire(String event)
   {
      List<Callback> callbacks = this.eventToCallbacks.get(event);
      if (callbacks != null)
         for (Callback callback : callbacks)
            callback.call();
   }

   // utility methods

   private static Method findMethod(Object target, String event)
   {
      Pair<String, Class< ? >> key = new Pair<String, Class< ? >>(event, target.getClass());
      Method found = method_cache.get(key);
      if (found != null)
         return found;

      found = findMethodImpl(target, fromEventToMethodname(event));
      method_cache.put(key, found);
      return found;
   }

   private static String fromEventToMethodname(String event)
   {
      return "on" + event.substring(0, 1).toUpperCase() + event.substring(1);
   }

   private static Method findMethodImpl(Object target, String methodName)
   {
      for (Method method : target.getClass().getMethods())
         if (method.getName().equals(methodName))
            return method;
      throw new NoSuchElementException(methodName);
   }

   private static Map<Pair<String, Class< ? >>, Method> method_cache = new HashMap<Pair<String, Class< ? >>, Method>();
}