package com.google.common.reflect;

import com.google.common.annotations.Beta;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.CharMatcher;
import com.google.common.base.Preconditions;
import com.google.common.base.Predicate;
import com.google.common.base.Splitter;
import com.google.common.collect.FluentIterable;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.ImmutableSet.Builder;
import com.google.common.collect.ImmutableSortedSet.Builder;
import com.google.common.collect.Maps;
import com.google.common.collect.Ordering;
import com.google.common.collect.Sets;
import java.io.File;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.jar.Attributes;
import java.util.jar.Attributes.Name;
import java.util.jar.Manifest;
import java.util.logging.Logger;
import javax.annotation.Nullable;

@Beta
public final class ClassPath
{
  private static final Logger a = Logger.getLogger(ClassPath.class.getName());
  private static final Predicate<ClassInfo> b = new Predicate() {};
  private static final Splitter c = Splitter.on(" ").omitEmptyStrings();
  private final ImmutableSet<ResourceInfo> d;
  
  private ClassPath(ImmutableSet<ResourceInfo> paramImmutableSet)
  {
    this.d = paramImmutableSet;
  }
  
  @VisibleForTesting
  private static ImmutableMap<URI, ClassLoader> a(ClassLoader paramClassLoader)
  {
    LinkedHashMap localLinkedHashMap = Maps.newLinkedHashMap();
    Object localObject = paramClassLoader.getParent();
    if (localObject != null) {
      localLinkedHashMap.putAll(a((ClassLoader)localObject));
    }
    if ((paramClassLoader instanceof URLClassLoader))
    {
      localObject = ((URLClassLoader)paramClassLoader).getURLs();
      int j = localObject.length;
      int i = 0;
      while (i < j)
      {
        URI localURI = localObject[i];
        try
        {
          localURI = localURI.toURI();
          if (!localLinkedHashMap.containsKey(localURI)) {
            localLinkedHashMap.put(localURI, paramClassLoader);
          }
          i += 1;
        }
        catch (URISyntaxException paramClassLoader)
        {
          throw new IllegalArgumentException(paramClassLoader);
        }
      }
    }
    return ImmutableMap.copyOf(localLinkedHashMap);
  }
  
  @VisibleForTesting
  static String a(String paramString)
  {
    return paramString.substring(0, paramString.length() - 6).replace('/', '.');
  }
  
  public static ClassPath from(ClassLoader paramClassLoader)
    throws IOException
  {
    a locala = new a();
    paramClassLoader = a(paramClassLoader).entrySet().iterator();
    while (paramClassLoader.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)paramClassLoader.next();
      locala.a((URI)localEntry.getKey(), (ClassLoader)localEntry.getValue());
    }
    return new ClassPath(locala.a.build());
  }
  
  public final ImmutableSet<ClassInfo> getAllClasses()
  {
    return FluentIterable.from(this.d).filter(ClassInfo.class).toSet();
  }
  
  public final ImmutableSet<ResourceInfo> getResources()
  {
    return this.d;
  }
  
  public final ImmutableSet<ClassInfo> getTopLevelClasses()
  {
    return FluentIterable.from(this.d).filter(ClassInfo.class).filter(b).toSet();
  }
  
  public final ImmutableSet<ClassInfo> getTopLevelClasses(String paramString)
  {
    Preconditions.checkNotNull(paramString);
    ImmutableSet.Builder localBuilder = ImmutableSet.builder();
    Iterator localIterator = getTopLevelClasses().iterator();
    while (localIterator.hasNext())
    {
      ClassInfo localClassInfo = (ClassInfo)localIterator.next();
      if (localClassInfo.getPackageName().equals(paramString)) {
        localBuilder.add(localClassInfo);
      }
    }
    return localBuilder.build();
  }
  
  public final ImmutableSet<ClassInfo> getTopLevelClassesRecursive(String paramString)
  {
    Preconditions.checkNotNull(paramString);
    paramString = String.valueOf(String.valueOf(paramString));
    paramString = paramString.length() + 1 + paramString + ".";
    ImmutableSet.Builder localBuilder = ImmutableSet.builder();
    Iterator localIterator = getTopLevelClasses().iterator();
    while (localIterator.hasNext())
    {
      ClassInfo localClassInfo = (ClassInfo)localIterator.next();
      if (localClassInfo.getName().startsWith(paramString)) {
        localBuilder.add(localClassInfo);
      }
    }
    return localBuilder.build();
  }
  
  @Beta
  public static final class ClassInfo
    extends ClassPath.ResourceInfo
  {
    private final String b;
    
    ClassInfo(String paramString, ClassLoader paramClassLoader)
    {
      super(paramClassLoader);
      this.b = ClassPath.a(paramString);
    }
    
    public final String getName()
    {
      return this.b;
    }
    
    public final String getPackageName()
    {
      return Reflection.getPackageName(this.b);
    }
    
    public final String getSimpleName()
    {
      int i = this.b.lastIndexOf('$');
      if (i != -1)
      {
        str = this.b.substring(i + 1);
        return CharMatcher.DIGIT.trimLeadingFrom(str);
      }
      String str = getPackageName();
      if (str.isEmpty()) {
        return this.b;
      }
      return this.b.substring(str.length() + 1);
    }
    
    public final Class<?> load()
    {
      try
      {
        Class localClass = this.a.loadClass(this.b);
        return localClass;
      }
      catch (ClassNotFoundException localClassNotFoundException)
      {
        throw new IllegalStateException(localClassNotFoundException);
      }
    }
    
    public final String toString()
    {
      return this.b;
    }
  }
  
  @Beta
  public static class ResourceInfo
  {
    final ClassLoader a;
    private final String b;
    
    ResourceInfo(String paramString, ClassLoader paramClassLoader)
    {
      this.b = ((String)Preconditions.checkNotNull(paramString));
      this.a = ((ClassLoader)Preconditions.checkNotNull(paramClassLoader));
    }
    
    static ResourceInfo a(String paramString, ClassLoader paramClassLoader)
    {
      if (paramString.endsWith(".class")) {
        return new ClassPath.ClassInfo(paramString, paramClassLoader);
      }
      return new ResourceInfo(paramString, paramClassLoader);
    }
    
    public boolean equals(Object paramObject)
    {
      boolean bool2 = false;
      boolean bool1 = bool2;
      if ((paramObject instanceof ResourceInfo))
      {
        paramObject = (ResourceInfo)paramObject;
        bool1 = bool2;
        if (this.b.equals(((ResourceInfo)paramObject).b))
        {
          bool1 = bool2;
          if (this.a == ((ResourceInfo)paramObject).a) {
            bool1 = true;
          }
        }
      }
      return bool1;
    }
    
    public final String getResourceName()
    {
      return this.b;
    }
    
    public int hashCode()
    {
      return this.b.hashCode();
    }
    
    public String toString()
    {
      return this.b;
    }
    
    public final URL url()
    {
      return (URL)Preconditions.checkNotNull(this.a.getResource(this.b), "Failed to load resource: %s", new Object[] { this.b });
    }
  }
  
  @VisibleForTesting
  static final class a
  {
    final ImmutableSortedSet.Builder<ClassPath.ResourceInfo> a = new ImmutableSortedSet.Builder(Ordering.usingToString());
    private final Set<URI> b = Sets.newHashSet();
    
    @VisibleForTesting
    private static ImmutableSet<URI> a(File paramFile, @Nullable Manifest paramManifest)
    {
      if (paramManifest == null) {
        return ImmutableSet.of();
      }
      ImmutableSet.Builder localBuilder = ImmutableSet.builder();
      paramManifest = paramManifest.getMainAttributes().getValue(Attributes.Name.CLASS_PATH.toString());
      if (paramManifest != null)
      {
        Iterator localIterator = ClassPath.b().split(paramManifest).iterator();
        Logger localLogger;
        for (;;)
        {
          if (!localIterator.hasNext()) {
            break label170;
          }
          String str = (String)localIterator.next();
          try
          {
            paramManifest = new URI(str);
            boolean bool = paramManifest.isAbsolute();
            if (bool) {}
            for (;;)
            {
              localBuilder.add(paramManifest);
              break;
              paramManifest = new File(paramFile.getParentFile(), str.replace('/', File.separatorChar)).toURI();
            }
            paramManifest = "Invalid Class-Path entry: ".concat(paramManifest);
          }
          catch (URISyntaxException paramManifest)
          {
            localLogger = ClassPath.a();
            paramManifest = String.valueOf(str);
            if (paramManifest.length() == 0) {}
          }
        }
        for (;;)
        {
          localLogger.warning(paramManifest);
          break;
          paramManifest = new String("Invalid Class-Path entry: ");
        }
      }
      label170:
      return localBuilder.build();
    }
    
    /* Error */
    private void a(File paramFile, ClassLoader paramClassLoader)
      throws IOException
    {
      // Byte code:
      //   0: new 171	java/util/jar/JarFile
      //   3: dup
      //   4: aload_1
      //   5: invokespecial 174	java/util/jar/JarFile:<init>	(Ljava/io/File;)V
      //   8: astore_3
      //   9: aload_1
      //   10: aload_3
      //   11: invokevirtual 178	java/util/jar/JarFile:getManifest	()Ljava/util/jar/Manifest;
      //   14: invokestatic 180	com/google/common/reflect/ClassPath$a:a	(Ljava/io/File;Ljava/util/jar/Manifest;)Lcom/google/common/collect/ImmutableSet;
      //   17: invokevirtual 181	com/google/common/collect/ImmutableSet:iterator	()Ljava/util/Iterator;
      //   20: astore_1
      //   21: aload_1
      //   22: invokeinterface 96 1 0
      //   27: ifeq +27 -> 54
      //   30: aload_0
      //   31: aload_1
      //   32: invokeinterface 100 1 0
      //   37: checkcast 104	java/net/URI
      //   40: aload_2
      //   41: invokevirtual 184	com/google/common/reflect/ClassPath$a:a	(Ljava/net/URI;Ljava/lang/ClassLoader;)V
      //   44: goto -23 -> 21
      //   47: astore_1
      //   48: aload_3
      //   49: invokevirtual 187	java/util/jar/JarFile:close	()V
      //   52: aload_1
      //   53: athrow
      //   54: aload_3
      //   55: invokevirtual 191	java/util/jar/JarFile:entries	()Ljava/util/Enumeration;
      //   58: astore_1
      //   59: aload_1
      //   60: invokeinterface 196 1 0
      //   65: ifeq +55 -> 120
      //   68: aload_1
      //   69: invokeinterface 199 1 0
      //   74: checkcast 201	java/util/jar/JarEntry
      //   77: astore 4
      //   79: aload 4
      //   81: invokevirtual 204	java/util/jar/JarEntry:isDirectory	()Z
      //   84: ifne -25 -> 59
      //   87: aload 4
      //   89: invokevirtual 207	java/util/jar/JarEntry:getName	()Ljava/lang/String;
      //   92: ldc -47
      //   94: invokevirtual 213	java/lang/String:equals	(Ljava/lang/Object;)Z
      //   97: ifne -38 -> 59
      //   100: aload_0
      //   101: getfield 30	com/google/common/reflect/ClassPath$a:a	Lcom/google/common/collect/ImmutableSortedSet$Builder;
      //   104: aload 4
      //   106: invokevirtual 207	java/util/jar/JarEntry:getName	()Ljava/lang/String;
      //   109: aload_2
      //   110: invokestatic 218	com/google/common/reflect/ClassPath$ResourceInfo:a	(Ljava/lang/String;Ljava/lang/ClassLoader;)Lcom/google/common/reflect/ClassPath$ResourceInfo;
      //   113: invokevirtual 221	com/google/common/collect/ImmutableSortedSet$Builder:add	(Ljava/lang/Object;)Lcom/google/common/collect/ImmutableSortedSet$Builder;
      //   116: pop
      //   117: goto -58 -> 59
      //   120: aload_3
      //   121: invokevirtual 187	java/util/jar/JarFile:close	()V
      //   124: return
      //   125: astore_1
      //   126: return
      //   127: astore_2
      //   128: goto -76 -> 52
      //   131: astore_1
      //   132: return
      // Local variable table:
      //   start	length	slot	name	signature
      //   0	133	0	this	a
      //   0	133	1	paramFile	File
      //   0	133	2	paramClassLoader	ClassLoader
      //   8	113	3	localJarFile	java.util.jar.JarFile
      //   77	28	4	localJarEntry	java.util.jar.JarEntry
      // Exception table:
      //   from	to	target	type
      //   9	21	47	finally
      //   21	44	47	finally
      //   54	59	47	finally
      //   59	117	47	finally
      //   120	124	125	java/io/IOException
      //   48	52	127	java/io/IOException
      //   0	9	131	java/io/IOException
    }
    
    private void a(File paramFile, ClassLoader paramClassLoader, String paramString, ImmutableSet<File> paramImmutableSet)
      throws IOException
    {
      Object localObject = paramFile.getCanonicalFile();
      if (paramImmutableSet.contains(localObject)) {
        return;
      }
      File[] arrayOfFile = paramFile.listFiles();
      if (arrayOfFile == null)
      {
        paramClassLoader = ClassPath.a();
        paramFile = String.valueOf(String.valueOf(paramFile));
        paramClassLoader.warning(paramFile.length() + 22 + "Cannot read directory " + paramFile);
        return;
      }
      paramImmutableSet = ImmutableSet.builder().addAll(paramImmutableSet).add(localObject).build();
      int j = arrayOfFile.length;
      int i = 0;
      label97:
      if (i < j)
      {
        paramFile = arrayOfFile[i];
        localObject = paramFile.getName();
        if (!paramFile.isDirectory()) {
          break label197;
        }
        String str = String.valueOf(String.valueOf(paramString));
        localObject = String.valueOf(String.valueOf(localObject));
        a(paramFile, paramClassLoader, str.length() + 1 + ((String)localObject).length() + str + (String)localObject + "/", paramImmutableSet);
      }
      label197:
      label259:
      for (;;)
      {
        i += 1;
        break label97;
        break;
        paramFile = String.valueOf(paramString);
        localObject = String.valueOf(localObject);
        if (((String)localObject).length() != 0) {}
        for (paramFile = paramFile.concat((String)localObject);; paramFile = new String(paramFile))
        {
          if (paramFile.equals("META-INF/MANIFEST.MF")) {
            break label259;
          }
          this.a.add(ClassPath.ResourceInfo.a(paramFile, paramClassLoader));
          break;
        }
      }
    }
    
    final void a(URI paramURI, ClassLoader paramClassLoader)
      throws IOException
    {
      if ((paramURI.getScheme().equals("file")) && (this.b.add(paramURI)))
      {
        paramURI = new File(paramURI);
        if (paramURI.exists())
        {
          if (!paramURI.isDirectory()) {
            break label62;
          }
          a(paramURI, paramClassLoader, "", ImmutableSet.of());
        }
      }
      return;
      label62:
      a(paramURI, paramClassLoader);
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/com/google/common/reflect/ClassPath.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */