package com.splunk.mint.network.util;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.Set;

public class Delegator
{
  private final Object delegate;
  private final Object source;
  private final Class superclass;

  public Delegator(Object paramObject1, Class paramClass, Object paramObject2)
  {
    this.source = paramObject1;
    this.superclass = paramClass;
    this.delegate = paramObject2;
  }

  public Delegator(Object paramObject, Class paramClass, String paramString)
  {
    try
    {
      this.source = paramObject;
      this.superclass = paramClass;
      Constructor localConstructor = Class.forName(paramString).getDeclaredConstructor(new Class[0]);
      localConstructor.setAccessible(true);
      this.delegate = localConstructor.newInstance(new Object[0]);
      return;
    }
    catch (RuntimeException localRuntimeException)
    {
      throw localRuntimeException;
    }
    catch (Exception localException)
    {
      throw new DelegationException("Could not make delegate object", localException);
    }
  }

  private Class<?> convertPrimitiveClass(Class<?> paramClass)
  {
    if (paramClass.isPrimitive())
    {
      if (paramClass != Integer.TYPE)
        break label19;
      paramClass = Integer.class;
    }
    label19: 
    do
    {
      return paramClass;
      if (paramClass == Boolean.TYPE)
        return Boolean.class;
      if (paramClass == Float.TYPE)
        return Float.class;
      if (paramClass == Long.TYPE)
        return Long.class;
      if (paramClass == Double.TYPE)
        return Double.class;
      if (paramClass == Short.TYPE)
        return Short.class;
      if (paramClass == Byte.TYPE)
        return Byte.class;
    }
    while (paramClass != Character.TYPE);
    return Character.class;
  }

  private String extractMethodName()
  {
    return new java.lang.Throwable().getStackTrace()[2].getMethodName();
  }

  private Method findMethod(String paramString, Object[] paramArrayOfObject)
    throws NoSuchMethodException
  {
    Class localClass = this.superclass;
    Object localObject;
    if (paramArrayOfObject.length == 0)
      localObject = localClass.getDeclaredMethod(paramString, new Class[0]);
    label123: 
    do
    {
      return localObject;
      localObject = null;
      Iterator localIterator = ReflectionUtil.getAllMethods(localClass).iterator();
      while (localIterator.hasNext())
      {
        Method localMethod = (Method)localIterator.next();
        if (localMethod.getName().equals(paramString))
        {
          Class[] arrayOfClass = localMethod.getParameterTypes();
          if (arrayOfClass.length == paramArrayOfObject.length)
          {
            for (int i = 0; ; i++)
            {
              if (i >= arrayOfClass.length)
                break label123;
              if (!convertPrimitiveClass(arrayOfClass[i]).isInstance(paramArrayOfObject[i]))
                break;
            }
            if (localObject == null)
              localObject = localMethod;
            else
              throw new DelegationException("Duplicate matches");
          }
        }
      }
    }
    while (localObject != null);
    throw new DelegationException("Could not find method: " + paramString);
  }

  private Object invoke0(Method paramMethod, Object[] paramArrayOfObject)
    throws Exception
  {
    try
    {
      writeFields(this.superclass, this.source, this.delegate);
      paramMethod.setAccessible(true);
      Object localObject = paramMethod.invoke(this.delegate, paramArrayOfObject);
      writeFields(this.superclass, this.delegate, this.source);
      return localObject;
    }
    catch (Exception localException)
    {
      throw localException;
    }
  }

  private void writeFields(Class paramClass, Object paramObject1, Object paramObject2)
    throws Exception
  {
    for (Field localField : paramClass.getDeclaredFields())
    {
      localField.setAccessible(true);
      localField.set(paramObject2, localField.get(paramObject1));
    }
  }

  public DelegatorMethodFinder delegateTo(String paramString, Class<?>[] paramArrayOfClass)
  {
    return new DelegatorMethodFinder(paramString, paramArrayOfClass);
  }

  public final <T> T invoke(Object[] paramArrayOfObject)
    throws Exception
  {
    return invoke0(findMethod(extractMethodName(), paramArrayOfObject), paramArrayOfObject);
  }

  public class DelegatorMethodFinder
  {
    private final Method method;

    public DelegatorMethodFinder(Class<?>[] arg2)
    {
      try
      {
        String str;
        Class[] arrayOfClass;
        this.method = Delegator.this.superclass.getDeclaredMethod(str, arrayOfClass);
        return;
      }
      catch (RuntimeException localRuntimeException)
      {
        throw localRuntimeException;
      }
      catch (Exception localException)
      {
        throw new DelegationException(localException);
      }
    }

    public <T> T invoke(Object[] paramArrayOfObject)
      throws Exception
    {
      return Delegator.this.invoke0(this.method, paramArrayOfObject);
    }
  }
}

/* Location:           C:\Documents and Settings\Cesar Cabello Cea\Mis documentos\Downloads\apk-downloader\com.ikea.kompis-6_dex2jar.jar
 * Qualified Name:     com.splunk.mint.network.util.Delegator
 * JD-Core Version:    0.6.2
 */