package com.google.common.io;

import com.google.common.annotations.Beta;
import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.base.Ascii;
import com.google.common.base.CharMatcher;
import com.google.common.base.Preconditions;
import com.google.common.math.IntMath;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.math.RoundingMode;
import java.util.Arrays;
import javax.annotation.CheckReturnValue;
import javax.annotation.Nullable;
import rc.1;
import rc.2;
import rc.3;
import rc.4;
import rc.5;
import rc.6;
import rc.a;
import rc.b;
import rc.c;
import rc.d;

@Beta
@GwtCompatible(emulated=true)
public abstract class BaseEncoding
{
  private static final BaseEncoding a = new c("base64()", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", Character.valueOf('='));
  private static final BaseEncoding b = new c("base64Url()", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_", Character.valueOf('='));
  private static final BaseEncoding c = new c("base32()", "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567", Character.valueOf('='));
  private static final BaseEncoding d = new c("base32Hex()", "0123456789ABCDEFGHIJKLMNOPQRSTUV", Character.valueOf('='));
  private static final BaseEncoding e = new c("base16()", "0123456789ABCDEF", null);
  
  private byte[] a(CharSequence paramCharSequence)
    throws BaseEncoding.DecodingException
  {
    Object localObject = a().trimTrailingFrom(paramCharSequence);
    Preconditions.checkNotNull(localObject);
    paramCharSequence = a(new rc.2((CharSequence)localObject));
    localObject = new byte[b(((CharSequence)localObject).length())];
    int i;
    try
    {
      int j = paramCharSequence.a();
      i = 0;
      while (j != -1)
      {
        localObject[i] = ((byte)j);
        j = paramCharSequence.a();
        i += 1;
      }
      if (i != localObject.length) {
        break label102;
      }
    }
    catch (DecodingException paramCharSequence)
    {
      throw paramCharSequence;
    }
    catch (IOException paramCharSequence)
    {
      throw new AssertionError(paramCharSequence);
    }
    return (byte[])localObject;
    label102:
    paramCharSequence = new byte[i];
    System.arraycopy(localObject, 0, paramCharSequence, 0, i);
    return paramCharSequence;
  }
  
  public static BaseEncoding base16()
  {
    return e;
  }
  
  public static BaseEncoding base32()
  {
    return c;
  }
  
  public static BaseEncoding base32Hex()
  {
    return d;
  }
  
  public static BaseEncoding base64()
  {
    return a;
  }
  
  public static BaseEncoding base64Url()
  {
    return b;
  }
  
  abstract int a(int paramInt);
  
  abstract CharMatcher a();
  
  abstract rc.a a(rc.c paramc);
  
  abstract rc.b a(rc.d paramd);
  
  abstract int b(int paramInt);
  
  public final byte[] decode(CharSequence paramCharSequence)
  {
    try
    {
      paramCharSequence = a(paramCharSequence);
      return paramCharSequence;
    }
    catch (DecodingException paramCharSequence)
    {
      throw new IllegalArgumentException(paramCharSequence);
    }
  }
  
  @GwtIncompatible("ByteSource,CharSource")
  public final ByteSource decodingSource(final CharSource paramCharSource)
  {
    Preconditions.checkNotNull(paramCharSource);
    new ByteSource()
    {
      public final InputStream openStream()
        throws IOException
      {
        return BaseEncoding.this.decodingStream(paramCharSource.openStream());
      }
    };
  }
  
  @GwtIncompatible("Reader,InputStream")
  public final InputStream decodingStream(Reader paramReader)
  {
    Preconditions.checkNotNull(paramReader);
    paramReader = a(new rc.1(paramReader));
    Preconditions.checkNotNull(paramReader);
    return new rc.3(paramReader);
  }
  
  public String encode(byte[] paramArrayOfByte)
  {
    return encode((byte[])Preconditions.checkNotNull(paramArrayOfByte), 0, paramArrayOfByte.length);
  }
  
  public final String encode(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
  {
    Preconditions.checkNotNull(paramArrayOfByte);
    Preconditions.checkPositionIndexes(paramInt1, paramInt1 + paramInt2, paramArrayOfByte.length);
    rc.6 local6 = new rc.6(new StringBuilder(a(paramInt2)));
    rc.b localb = a(local6);
    int i = 0;
    for (;;)
    {
      if (i < paramInt2) {}
      try
      {
        localb.a(paramArrayOfByte[(paramInt1 + i)]);
        i += 1;
      }
      catch (IOException paramArrayOfByte)
      {
        throw new AssertionError("impossible");
      }
    }
    localb.b();
    return local6.toString();
  }
  
  @GwtIncompatible("ByteSink,CharSink")
  public final ByteSink encodingSink(final CharSink paramCharSink)
  {
    Preconditions.checkNotNull(paramCharSink);
    new ByteSink()
    {
      public final OutputStream openStream()
        throws IOException
      {
        return BaseEncoding.this.encodingStream(paramCharSink.openStream());
      }
    };
  }
  
  @GwtIncompatible("Writer,OutputStream")
  public final OutputStream encodingStream(Writer paramWriter)
  {
    Preconditions.checkNotNull(paramWriter);
    paramWriter = a(new rc.5(paramWriter));
    Preconditions.checkNotNull(paramWriter);
    return new rc.4(paramWriter);
  }
  
  @CheckReturnValue
  public abstract BaseEncoding lowerCase();
  
  @CheckReturnValue
  public abstract BaseEncoding omitPadding();
  
  @CheckReturnValue
  public abstract BaseEncoding upperCase();
  
  @CheckReturnValue
  public abstract BaseEncoding withPadChar(char paramChar);
  
  @CheckReturnValue
  public abstract BaseEncoding withSeparator(String paramString, int paramInt);
  
  public static final class DecodingException
    extends IOException
  {
    DecodingException(String paramString)
    {
      super();
    }
  }
  
  static final class a
    extends CharMatcher
  {
    final String c;
    final char[] d;
    final int e;
    final int f;
    final int g;
    final int h;
    final byte[] i;
    private final boolean[] j;
    
    a(String paramString, char[] paramArrayOfChar)
    {
      this.c = ((String)Preconditions.checkNotNull(paramString));
      this.d = ((char[])Preconditions.checkNotNull(paramArrayOfChar));
      for (;;)
      {
        try
        {
          this.f = IntMath.log2(paramArrayOfChar.length, RoundingMode.UNNECESSARY);
          k = Math.min(8, Integer.lowestOneBit(this.f));
          this.g = (8 / k);
          this.h = (this.f / k);
          this.e = (paramArrayOfChar.length - 1);
          paramString = new byte['€'];
          Arrays.fill(paramString, (byte)-1);
          k = 0;
          if (k >= paramArrayOfChar.length) {
            break;
          }
          char c1 = paramArrayOfChar[k];
          Preconditions.checkArgument(CharMatcher.ASCII.matches(c1), "Non-ASCII character: %s", new Object[] { Character.valueOf(c1) });
          boolean bool;
          if (paramString[c1] == -1)
          {
            bool = true;
            Preconditions.checkArgument(bool, "Duplicate character: %s", new Object[] { Character.valueOf(c1) });
            paramString[c1] = ((byte)k);
            k += 1;
          }
          else
          {
            bool = false;
          }
        }
        catch (ArithmeticException paramString)
        {
          k = paramArrayOfChar.length;
          throw new IllegalArgumentException(35 + "Illegal alphabet length " + k, paramString);
        }
      }
      this.i = paramString;
      paramString = new boolean[this.g];
      int k = m;
      while (k < this.h)
      {
        paramString[IntMath.divide(k * 8, this.f, RoundingMode.CEILING)] = 1;
        k += 1;
      }
      this.j = paramString;
    }
    
    final boolean a()
    {
      boolean bool2 = false;
      char[] arrayOfChar = this.d;
      int m = arrayOfChar.length;
      int k = 0;
      for (;;)
      {
        boolean bool1 = bool2;
        if (k < m)
        {
          if (Ascii.isLowerCase(arrayOfChar[k])) {
            bool1 = true;
          }
        }
        else {
          return bool1;
        }
        k += 1;
      }
    }
    
    final boolean a(int paramInt)
    {
      return this.j[(paramInt % this.g)];
    }
    
    final boolean b()
    {
      boolean bool2 = false;
      char[] arrayOfChar = this.d;
      int m = arrayOfChar.length;
      int k = 0;
      for (;;)
      {
        boolean bool1 = bool2;
        if (k < m)
        {
          if (Ascii.isUpperCase(arrayOfChar[k])) {
            bool1 = true;
          }
        }
        else {
          return bool1;
        }
        k += 1;
      }
    }
    
    public final boolean matches(char paramChar)
    {
      return (CharMatcher.ASCII.matches(paramChar)) && (this.i[paramChar] != -1);
    }
    
    public final String toString()
    {
      return this.c;
    }
  }
  
  static final class b
    extends BaseEncoding
  {
    private final BaseEncoding a;
    private final String b;
    private final int c;
    private final CharMatcher d;
    
    b(BaseEncoding paramBaseEncoding, String paramString, int paramInt)
    {
      this.a = ((BaseEncoding)Preconditions.checkNotNull(paramBaseEncoding));
      this.b = ((String)Preconditions.checkNotNull(paramString));
      this.c = paramInt;
      if (paramInt > 0) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "Cannot add a separator after every %s chars", new Object[] { Integer.valueOf(paramInt) });
        this.d = CharMatcher.anyOf(paramString).precomputed();
        return;
      }
    }
    
    final int a(int paramInt)
    {
      paramInt = this.a.a(paramInt);
      return paramInt + this.b.length() * IntMath.divide(Math.max(0, paramInt - 1), this.c, RoundingMode.FLOOR);
    }
    
    final CharMatcher a()
    {
      return this.a.a();
    }
    
    final rc.a a(rc.c paramc)
    {
      BaseEncoding localBaseEncoding = this.a;
      CharMatcher localCharMatcher = this.d;
      Preconditions.checkNotNull(paramc);
      Preconditions.checkNotNull(localCharMatcher);
      return localBaseEncoding.a(new BaseEncoding.3(paramc, localCharMatcher));
    }
    
    final rc.b a(rc.d paramd)
    {
      BaseEncoding localBaseEncoding = this.a;
      String str = this.b;
      int i = this.c;
      Preconditions.checkNotNull(paramd);
      Preconditions.checkNotNull(str);
      if (i > 0) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool);
        return localBaseEncoding.a(new BaseEncoding.4(i, str, paramd));
      }
    }
    
    final int b(int paramInt)
    {
      return this.a.b(paramInt);
    }
    
    public final BaseEncoding lowerCase()
    {
      return this.a.lowerCase().withSeparator(this.b, this.c);
    }
    
    public final BaseEncoding omitPadding()
    {
      return this.a.omitPadding().withSeparator(this.b, this.c);
    }
    
    public final String toString()
    {
      String str1 = String.valueOf(String.valueOf(this.a.toString()));
      String str2 = String.valueOf(String.valueOf(this.b));
      int i = this.c;
      return str1.length() + 31 + str2.length() + str1 + ".withSeparator(\"" + str2 + "\", " + i + ")";
    }
    
    public final BaseEncoding upperCase()
    {
      return this.a.upperCase().withSeparator(this.b, this.c);
    }
    
    public final BaseEncoding withPadChar(char paramChar)
    {
      return this.a.withPadChar(paramChar).withSeparator(this.b, this.c);
    }
    
    public final BaseEncoding withSeparator(String paramString, int paramInt)
    {
      throw new UnsupportedOperationException("Already have a separator");
    }
  }
  
  static final class c
    extends BaseEncoding
  {
    private final BaseEncoding.a a;
    @Nullable
    private final Character b;
    private transient BaseEncoding c;
    private transient BaseEncoding d;
    
    private c(BaseEncoding.a parama, @Nullable Character paramCharacter)
    {
      this.a = ((BaseEncoding.a)Preconditions.checkNotNull(parama));
      if ((paramCharacter == null) || (!parama.matches(paramCharacter.charValue()))) {}
      for (boolean bool = true;; bool = false)
      {
        Preconditions.checkArgument(bool, "Padding character %s was already in alphabet", new Object[] { paramCharacter });
        this.b = paramCharacter;
        return;
      }
    }
    
    c(String paramString1, String paramString2, @Nullable Character paramCharacter)
    {
      this(new BaseEncoding.a(paramString1, paramString2.toCharArray()), paramCharacter);
    }
    
    final int a(int paramInt)
    {
      return this.a.g * IntMath.divide(paramInt, this.a.h, RoundingMode.CEILING);
    }
    
    final CharMatcher a()
    {
      if (this.b == null) {
        return CharMatcher.NONE;
      }
      return CharMatcher.is(this.b.charValue());
    }
    
    final rc.a a(final rc.c paramc)
    {
      Preconditions.checkNotNull(paramc);
      new rc.a()
      {
        int a = 0;
        int b = 0;
        int c = 0;
        boolean d = false;
        final CharMatcher e = BaseEncoding.c.this.a();
        
        public final int a()
          throws IOException
        {
          int j = -1;
          do
          {
            char c1;
            for (;;)
            {
              i = paramc.a();
              if (i == -1)
              {
                i = j;
                if (this.d) {
                  return i;
                }
                i = j;
                if (BaseEncoding.c.a(BaseEncoding.c.this).a(this.c)) {
                  return i;
                }
                i = this.c;
                throw new BaseEncoding.DecodingException(32 + "Invalid input length " + i);
              }
              this.c += 1;
              c1 = (char)i;
              if (!this.e.matches(c1)) {
                break;
              }
              if ((!this.d) && ((this.c == 1) || (!BaseEncoding.c.a(BaseEncoding.c.this).a(this.c - 1))))
              {
                i = this.c;
                throw new BaseEncoding.DecodingException(41 + "Padding cannot start at index " + i);
              }
              this.d = true;
            }
            if (this.d)
            {
              i = this.c;
              throw new BaseEncoding.DecodingException(61 + "Expected padding character but found '" + c1 + "' at index " + i);
            }
            this.a <<= BaseEncoding.c.a(BaseEncoding.c.this).f;
            i = this.a;
            BaseEncoding.a locala = BaseEncoding.c.a(BaseEncoding.c.this);
            if ((c1 > '') || (locala.i[c1] == -1)) {
              throw new BaseEncoding.DecodingException(25 + "Unrecognized character: " + c1);
            }
            this.a = (locala.i[c1] | i);
            this.b += BaseEncoding.c.a(BaseEncoding.c.this).f;
          } while (this.b < 8);
          this.b -= 8;
          int i = this.a >> this.b & 0xFF;
          return i;
        }
        
        public final void b()
          throws IOException
        {
          paramc.b();
        }
      };
    }
    
    final rc.b a(final rc.d paramd)
    {
      Preconditions.checkNotNull(paramd);
      new rc.b()
      {
        int a = 0;
        int b = 0;
        int c = 0;
        
        public final void a()
          throws IOException
        {
          paramd.a();
        }
        
        public final void a(byte paramAnonymousByte)
          throws IOException
        {
          this.a <<= 8;
          this.a |= paramAnonymousByte & 0xFF;
          for (this.b += 8; this.b >= BaseEncoding.c.a(BaseEncoding.c.this).f; this.b -= BaseEncoding.c.a(BaseEncoding.c.this).f)
          {
            paramAnonymousByte = this.a;
            int i = this.b;
            int j = BaseEncoding.c.a(BaseEncoding.c.this).f;
            int k = BaseEncoding.c.a(BaseEncoding.c.this).e;
            paramd.a(BaseEncoding.c.a(BaseEncoding.c.this).d[(paramAnonymousByte >> i - j & k)]);
            this.c += 1;
          }
        }
        
        public final void b()
          throws IOException
        {
          if (this.b > 0)
          {
            int i = this.a;
            int j = BaseEncoding.c.a(BaseEncoding.c.this).f;
            int k = this.b;
            int m = BaseEncoding.c.a(BaseEncoding.c.this).e;
            paramd.a(BaseEncoding.c.a(BaseEncoding.c.this).d[(i << j - k & m)]);
            this.c += 1;
            if (BaseEncoding.c.b(BaseEncoding.c.this) != null) {
              while (this.c % BaseEncoding.c.a(BaseEncoding.c.this).g != 0)
              {
                paramd.a(BaseEncoding.c.b(BaseEncoding.c.this).charValue());
                this.c += 1;
              }
            }
          }
          paramd.b();
        }
      };
    }
    
    final int b(int paramInt)
    {
      return (int)((this.a.f * paramInt + 7L) / 8L);
    }
    
    public final BaseEncoding lowerCase()
    {
      int i = 0;
      Object localObject2 = this.d;
      Object localObject1 = localObject2;
      if (localObject2 == null)
      {
        localObject1 = this.a;
        if (((BaseEncoding.a)localObject1).b()) {
          break label45;
        }
        if (localObject1 != this.a) {
          break label128;
        }
      }
      label45:
      label128:
      for (localObject1 = this;; localObject1 = new c((BaseEncoding.a)localObject1, this.b))
      {
        this.d = ((BaseEncoding)localObject1);
        return (BaseEncoding)localObject1;
        if (!((BaseEncoding.a)localObject1).a()) {}
        for (boolean bool = true;; bool = false)
        {
          Preconditions.checkState(bool, "Cannot call lowerCase() on a mixed-case alphabet");
          localObject2 = new char[((BaseEncoding.a)localObject1).d.length];
          while (i < ((BaseEncoding.a)localObject1).d.length)
          {
            localObject2[i] = Ascii.toLowerCase(localObject1.d[i]);
            i += 1;
          }
        }
        localObject1 = new BaseEncoding.a(String.valueOf(((BaseEncoding.a)localObject1).c).concat(".lowerCase()"), (char[])localObject2);
        break;
      }
    }
    
    public final BaseEncoding omitPadding()
    {
      if (this.b == null) {
        return this;
      }
      return new c(this.a, null);
    }
    
    public final String toString()
    {
      StringBuilder localStringBuilder = new StringBuilder("BaseEncoding.");
      localStringBuilder.append(this.a.toString());
      if (8 % this.a.f != 0)
      {
        if (this.b != null) {
          break label54;
        }
        localStringBuilder.append(".omitPadding()");
      }
      for (;;)
      {
        return localStringBuilder.toString();
        label54:
        localStringBuilder.append(".withPadChar(").append(this.b).append(')');
      }
    }
    
    public final BaseEncoding upperCase()
    {
      int i = 0;
      Object localObject2 = this.c;
      Object localObject1 = localObject2;
      if (localObject2 == null)
      {
        localObject1 = this.a;
        if (((BaseEncoding.a)localObject1).a()) {
          break label45;
        }
        if (localObject1 != this.a) {
          break label128;
        }
      }
      label45:
      label128:
      for (localObject1 = this;; localObject1 = new c((BaseEncoding.a)localObject1, this.b))
      {
        this.c = ((BaseEncoding)localObject1);
        return (BaseEncoding)localObject1;
        if (!((BaseEncoding.a)localObject1).b()) {}
        for (boolean bool = true;; bool = false)
        {
          Preconditions.checkState(bool, "Cannot call upperCase() on a mixed-case alphabet");
          localObject2 = new char[((BaseEncoding.a)localObject1).d.length];
          while (i < ((BaseEncoding.a)localObject1).d.length)
          {
            localObject2[i] = Ascii.toUpperCase(localObject1.d[i]);
            i += 1;
          }
        }
        localObject1 = new BaseEncoding.a(String.valueOf(((BaseEncoding.a)localObject1).c).concat(".upperCase()"), (char[])localObject2);
        break;
      }
    }
    
    public final BaseEncoding withPadChar(char paramChar)
    {
      if ((8 % this.a.f == 0) || ((this.b != null) && (this.b.charValue() == paramChar))) {
        return this;
      }
      return new c(this.a, Character.valueOf(paramChar));
    }
    
    public final BaseEncoding withSeparator(String paramString, int paramInt)
    {
      Preconditions.checkNotNull(paramString);
      Preconditions.checkArgument(a().or(this.a).matchesNoneOf(paramString), "Separator cannot contain alphabet or padding characters");
      return new BaseEncoding.b(this, paramString, paramInt);
    }
  }
}


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