package org.joda.time;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.lang.ref.Reference;
import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TimeZone;
import org.joda.convert.FromString;
import org.joda.convert.ToString;
import org.joda.time.chrono.BaseChronology;
import org.joda.time.format.DateTimeFormatter;
import org.joda.time.format.DateTimeFormatterBuilder;
import org.joda.time.format.FormatUtils;
import org.joda.time.tz.DefaultNameProvider;
import org.joda.time.tz.FixedDateTimeZone;
import org.joda.time.tz.NameProvider;
import org.joda.time.tz.Provider;
import org.joda.time.tz.UTCProvider;
import org.joda.time.tz.ZoneInfoProvider;

public abstract class DateTimeZone
  implements Serializable
{
  public static final DateTimeZone UTC = new FixedDateTimeZone("UTC", "UTC", 0, 0);
  private static Provider a;
  private static NameProvider b;
  private static Set<String> c;
  private static volatile DateTimeZone d;
  private static DateTimeFormatter e;
  private static Map<String, SoftReference<DateTimeZone>> f;
  private static Map<String, String> g;
  private static final long serialVersionUID = 5546345482340108586L;
  private final String h;
  
  static
  {
    a(null);
    a(null);
  }
  
  protected DateTimeZone(String paramString)
  {
    if (paramString == null) {
      throw new IllegalArgumentException("Id must not be null");
    }
    this.h = paramString;
  }
  
  private static String a(int paramInt)
  {
    StringBuffer localStringBuffer = new StringBuffer();
    if (paramInt >= 0) {
      localStringBuffer.append('+');
    }
    for (;;)
    {
      i = paramInt / 3600000;
      FormatUtils.appendPaddedInteger(localStringBuffer, i, 2);
      paramInt -= i * 3600000;
      i = paramInt / 60000;
      localStringBuffer.append(':');
      FormatUtils.appendPaddedInteger(localStringBuffer, i, 2);
      paramInt -= i * 60000;
      if (paramInt != 0) {
        break;
      }
      return localStringBuffer.toString();
      localStringBuffer.append('-');
      paramInt = -paramInt;
    }
    int i = paramInt / 1000;
    localStringBuffer.append(':');
    FormatUtils.appendPaddedInteger(localStringBuffer, i, 2);
    paramInt -= i * 1000;
    if (paramInt == 0) {
      return localStringBuffer.toString();
    }
    localStringBuffer.append('.');
    FormatUtils.appendPaddedInteger(localStringBuffer, paramInt, 3);
    return localStringBuffer.toString();
  }
  
  private static String a(String paramString)
  {
    try
    {
      Map localMap = g;
      Object localObject = localMap;
      if (localMap == null)
      {
        localObject = new HashMap();
        ((Map)localObject).put("GMT", "UTC");
        ((Map)localObject).put("WET", "WET");
        ((Map)localObject).put("CET", "CET");
        ((Map)localObject).put("MET", "CET");
        ((Map)localObject).put("ECT", "CET");
        ((Map)localObject).put("EET", "EET");
        ((Map)localObject).put("MIT", "Pacific/Apia");
        ((Map)localObject).put("HST", "Pacific/Honolulu");
        ((Map)localObject).put("AST", "America/Anchorage");
        ((Map)localObject).put("PST", "America/Los_Angeles");
        ((Map)localObject).put("MST", "America/Denver");
        ((Map)localObject).put("PNT", "America/Phoenix");
        ((Map)localObject).put("CST", "America/Chicago");
        ((Map)localObject).put("EST", "America/New_York");
        ((Map)localObject).put("IET", "America/Indiana/Indianapolis");
        ((Map)localObject).put("PRT", "America/Puerto_Rico");
        ((Map)localObject).put("CNT", "America/St_Johns");
        ((Map)localObject).put("AGT", "America/Argentina/Buenos_Aires");
        ((Map)localObject).put("BET", "America/Sao_Paulo");
        ((Map)localObject).put("ART", "Africa/Cairo");
        ((Map)localObject).put("CAT", "Africa/Harare");
        ((Map)localObject).put("EAT", "Africa/Addis_Ababa");
        ((Map)localObject).put("NET", "Asia/Yerevan");
        ((Map)localObject).put("PLT", "Asia/Karachi");
        ((Map)localObject).put("IST", "Asia/Kolkata");
        ((Map)localObject).put("BST", "Asia/Dhaka");
        ((Map)localObject).put("VST", "Asia/Ho_Chi_Minh");
        ((Map)localObject).put("CTT", "Asia/Shanghai");
        ((Map)localObject).put("JST", "Asia/Tokyo");
        ((Map)localObject).put("ACT", "Australia/Darwin");
        ((Map)localObject).put("AET", "Australia/Sydney");
        ((Map)localObject).put("SST", "Pacific/Guadalcanal");
        ((Map)localObject).put("NST", "Pacific/Auckland");
        g = (Map)localObject;
      }
      paramString = (String)((Map)localObject).get(paramString);
      return paramString;
    }
    finally {}
  }
  
  private static DateTimeZone a(String paramString, int paramInt)
  {
    if (paramInt == 0) {}
    for (;;)
    {
      try
      {
        localObject = UTC;
        return (DateTimeZone)localObject;
      }
      finally {}
      if (f == null) {
        f = new HashMap();
      }
      Object localObject = (Reference)f.get(paramString);
      if (localObject != null)
      {
        DateTimeZone localDateTimeZone = (DateTimeZone)((Reference)localObject).get();
        localObject = localDateTimeZone;
        if (localDateTimeZone != null) {}
      }
      else
      {
        localObject = new FixedDateTimeZone(paramString, null, paramInt, paramInt);
        f.put(paramString, new SoftReference(localObject));
      }
    }
  }
  
  private static Provider a()
  {
    localObject4 = null;
    for (;;)
    {
      try
      {
        localObject5 = System.getProperty("org.joda.time.DateTimeZone.Provider");
        localObject1 = localObject4;
        if (localObject5 == null) {}
      }
      catch (SecurityException localSecurityException)
      {
        Object localObject5;
        Object localObject1;
        Object localObject2;
        Object localObject3 = localObject4;
        continue;
        continue;
      }
      try
      {
        localObject1 = (Provider)Class.forName((String)localObject5).newInstance();
        if (localObject1 != null) {}
      }
      catch (Exception localException1)
      {
        try
        {
          localObject4 = new ZoneInfoProvider("org/joda/time/tz/data");
          localObject1 = localObject4;
          localObject4 = localObject1;
          if (localObject1 == null) {
            localObject4 = new UTCProvider();
          }
          return (Provider)localObject4;
        }
        catch (Exception localException2)
        {
          localObject5 = Thread.currentThread();
          ((Thread)localObject5).getThreadGroup().uncaughtException((Thread)localObject5, localException2);
        }
        localException1 = localException1;
        localObject5 = Thread.currentThread();
        ((Thread)localObject5).getThreadGroup().uncaughtException((Thread)localObject5, localException1);
        localObject2 = localObject4;
      }
    }
  }
  
  private static void a(NameProvider paramNameProvider)
  {
    NameProvider localNameProvider = paramNameProvider;
    if (paramNameProvider == null) {
      localNameProvider = b();
    }
    b = localNameProvider;
  }
  
  private static void a(Provider paramProvider)
  {
    Provider localProvider = paramProvider;
    if (paramProvider == null) {
      localProvider = a();
    }
    paramProvider = localProvider.getAvailableIDs();
    if ((paramProvider == null) || (paramProvider.size() == 0)) {
      throw new IllegalArgumentException("The provider doesn't have any available ids");
    }
    if (!paramProvider.contains("UTC")) {
      throw new IllegalArgumentException("The provider doesn't support UTC");
    }
    if (!UTC.equals(localProvider.getZone("UTC"))) {
      throw new IllegalArgumentException("Invalid UTC zone provided");
    }
    a = localProvider;
    c = paramProvider;
  }
  
  private static int b(String paramString)
  {
    BaseChronology local1 = new BaseChronology()
    {
      public final DateTimeZone getZone()
      {
        return null;
      }
      
      public final String toString()
      {
        return getClass().getName();
      }
      
      public final Chronology withUTC()
      {
        return this;
      }
      
      public final Chronology withZone(DateTimeZone paramAnonymousDateTimeZone)
      {
        return this;
      }
    };
    return -(int)c().withChronology(local1).parseMillis(paramString);
  }
  
  private static NameProvider b()
  {
    for (;;)
    {
      try
      {
        localObject1 = System.getProperty("org.joda.time.DateTimeZone.NameProvider");
        if (localObject1 == null) {
          continue;
        }
      }
      catch (SecurityException localSecurityException)
      {
        Object localObject1;
        Object localObject4;
        Object localObject2;
        Object localObject3 = null;
        continue;
      }
      try
      {
        localObject1 = (NameProvider)Class.forName((String)localObject1).newInstance();
        localObject4 = localObject1;
        if (localObject1 == null) {
          localObject4 = new DefaultNameProvider();
        }
        return (NameProvider)localObject4;
      }
      catch (Exception localException)
      {
        localObject4 = Thread.currentThread();
        ((Thread)localObject4).getThreadGroup().uncaughtException((Thread)localObject4, localException);
      }
      localObject2 = null;
    }
  }
  
  private static DateTimeFormatter c()
  {
    try
    {
      if (e == null) {
        e = new DateTimeFormatterBuilder().appendTimeZoneOffset(null, true, 2, 4).toFormatter();
      }
      DateTimeFormatter localDateTimeFormatter = e;
      return localDateTimeFormatter;
    }
    finally {}
  }
  
  @FromString
  public static DateTimeZone forID(String paramString)
  {
    Object localObject;
    if (paramString == null) {
      localObject = getDefault();
    }
    DateTimeZone localDateTimeZone;
    do
    {
      return (DateTimeZone)localObject;
      if (paramString.equals("UTC")) {
        return UTC;
      }
      localDateTimeZone = a.getZone(paramString);
      localObject = localDateTimeZone;
    } while (localDateTimeZone != null);
    if ((paramString.startsWith("+")) || (paramString.startsWith("-")))
    {
      int i = b(paramString);
      if (i == 0L) {
        return UTC;
      }
      return a(a(i), i);
    }
    throw new IllegalArgumentException("The datetime zone id '" + paramString + "' is not recognised");
  }
  
  public static DateTimeZone forOffsetHours(int paramInt)
    throws IllegalArgumentException
  {
    return forOffsetHoursMinutes(paramInt, 0);
  }
  
  /* Error */
  public static DateTimeZone forOffsetHoursMinutes(int paramInt1, int paramInt2)
    throws IllegalArgumentException
  {
    // Byte code:
    //   0: iload_0
    //   1: ifne +11 -> 12
    //   4: iload_1
    //   5: ifne +7 -> 12
    //   8: getstatic 44	org/joda/time/DateTimeZone:UTC	Lorg/joda/time/DateTimeZone;
    //   11: areturn
    //   12: iload_1
    //   13: iflt +9 -> 22
    //   16: iload_1
    //   17: bipush 59
    //   19: if_icmple +28 -> 47
    //   22: new 56	java/lang/IllegalArgumentException
    //   25: dup
    //   26: new 375	java/lang/StringBuilder
    //   29: dup
    //   30: ldc_w 396
    //   33: invokespecial 378	java/lang/StringBuilder:<init>	(Ljava/lang/String;)V
    //   36: iload_1
    //   37: invokevirtual 399	java/lang/StringBuilder:append	(I)Ljava/lang/StringBuilder;
    //   40: invokevirtual 384	java/lang/StringBuilder:toString	()Ljava/lang/String;
    //   43: invokespecial 60	java/lang/IllegalArgumentException:<init>	(Ljava/lang/String;)V
    //   46: athrow
    //   47: iload_0
    //   48: bipush 60
    //   50: invokestatic 405	org/joda/time/field/FieldUtils:safeMultiply	(II)I
    //   53: istore_0
    //   54: iload_0
    //   55: ifge +22 -> 77
    //   58: iload_0
    //   59: iload_1
    //   60: ineg
    //   61: invokestatic 408	org/joda/time/field/FieldUtils:safeAdd	(II)I
    //   64: istore_0
    //   65: iload_0
    //   66: ldc 78
    //   68: invokestatic 405	org/joda/time/field/FieldUtils:safeMultiply	(II)I
    //   71: istore_0
    //   72: iload_0
    //   73: invokestatic 411	org/joda/time/DateTimeZone:forOffsetMillis	(I)Lorg/joda/time/DateTimeZone;
    //   76: areturn
    //   77: iload_0
    //   78: iload_1
    //   79: invokestatic 408	org/joda/time/field/FieldUtils:safeAdd	(II)I
    //   82: istore_0
    //   83: goto -18 -> 65
    //   86: astore_2
    //   87: new 56	java/lang/IllegalArgumentException
    //   90: dup
    //   91: ldc_w 413
    //   94: invokespecial 60	java/lang/IllegalArgumentException:<init>	(Ljava/lang/String;)V
    //   97: athrow
    // Local variable table:
    //   start	length	slot	name	signature
    //   0	98	0	paramInt1	int
    //   0	98	1	paramInt2	int
    //   86	1	2	localArithmeticException	ArithmeticException
    // Exception table:
    //   from	to	target	type
    //   47	54	86	java/lang/ArithmeticException
    //   58	65	86	java/lang/ArithmeticException
    //   65	72	86	java/lang/ArithmeticException
    //   77	83	86	java/lang/ArithmeticException
  }
  
  public static DateTimeZone forOffsetMillis(int paramInt)
  {
    return a(a(paramInt), paramInt);
  }
  
  public static DateTimeZone forTimeZone(TimeZone paramTimeZone)
  {
    Object localObject2;
    if (paramTimeZone == null) {
      localObject2 = getDefault();
    }
    String str1;
    String str2;
    Object localObject1;
    do
    {
      return (DateTimeZone)localObject2;
      str1 = paramTimeZone.getID();
      if (str1.equals("UTC")) {
        return UTC;
      }
      localObject2 = null;
      str2 = a(str1);
      if (str2 != null) {
        localObject2 = a.getZone(str2);
      }
      localObject1 = localObject2;
      if (localObject2 == null) {
        localObject1 = a.getZone(str1);
      }
      localObject2 = localObject1;
    } while (localObject1 != null);
    if (str2 == null)
    {
      paramTimeZone = paramTimeZone.getID();
      if ((paramTimeZone.startsWith("GMT+")) || (paramTimeZone.startsWith("GMT-")))
      {
        int i = b(paramTimeZone.substring(3));
        if (i == 0L) {
          return UTC;
        }
        return a(a(i), i);
      }
    }
    throw new IllegalArgumentException("The datetime zone id '" + str1 + "' is not recognised");
  }
  
  public static Set<String> getAvailableIDs()
  {
    return c;
  }
  
  public static DateTimeZone getDefault()
  {
    Object localObject1 = d;
    if (localObject1 == null)
    {
      for (;;)
      {
        Object localObject4;
        DateTimeZone localDateTimeZone;
        String str;
        try
        {
          localObject4 = d;
          localObject1 = localObject4;
          if (localObject4 == null)
          {
            localDateTimeZone = null;
            localObject4 = null;
            localObject1 = localDateTimeZone;
          }
        }
        finally {}
        try
        {
          str = System.getProperty("user.timezone");
          localObject1 = localObject4;
          if (str != null)
          {
            localObject1 = localDateTimeZone;
            localDateTimeZone = forID(str);
            localObject1 = localDateTimeZone;
          }
        }
        catch (IllegalArgumentException localIllegalArgumentException)
        {
          localObject5 = localObject2;
        }
        catch (RuntimeException localRuntimeException)
        {
          Object localObject5;
          localObject3 = localObject5;
        }
      }
      localObject4 = localObject1;
      if (localObject1 == null) {
        localObject4 = forTimeZone(TimeZone.getDefault());
      }
      localObject1 = localObject4;
      if (localObject4 == null) {
        localObject1 = UTC;
      }
      d = (DateTimeZone)localObject1;
      return (DateTimeZone)localObject1;
    }
    Object localObject3;
    return (DateTimeZone)localObject3;
  }
  
  public static NameProvider getNameProvider()
  {
    return b;
  }
  
  public static Provider getProvider()
  {
    return a;
  }
  
  public static void setDefault(DateTimeZone paramDateTimeZone)
    throws SecurityException
  {
    SecurityManager localSecurityManager = System.getSecurityManager();
    if (localSecurityManager != null) {
      localSecurityManager.checkPermission(new JodaTimePermission("DateTimeZone.setDefault"));
    }
    if (paramDateTimeZone == null) {
      throw new IllegalArgumentException("The datetime zone must not be null");
    }
    try
    {
      d = paramDateTimeZone;
      return;
    }
    finally {}
  }
  
  public static void setNameProvider(NameProvider paramNameProvider)
    throws SecurityException
  {
    SecurityManager localSecurityManager = System.getSecurityManager();
    if (localSecurityManager != null) {
      localSecurityManager.checkPermission(new JodaTimePermission("DateTimeZone.setNameProvider"));
    }
    a(paramNameProvider);
  }
  
  public static void setProvider(Provider paramProvider)
    throws SecurityException
  {
    SecurityManager localSecurityManager = System.getSecurityManager();
    if (localSecurityManager != null) {
      localSecurityManager.checkPermission(new JodaTimePermission("DateTimeZone.setProvider"));
    }
    a(paramProvider);
  }
  
  public long adjustOffset(long paramLong, boolean paramBoolean)
  {
    long l1 = paramLong - 10800000L;
    long l2 = getOffset(l1);
    long l3 = getOffset(10800000L + paramLong);
    if (l2 <= l3) {}
    do
    {
      do
      {
        do
        {
          return paramLong;
          l2 -= l3;
          l1 = nextTransition(l1);
          l3 = l1 - l2;
        } while ((paramLong < l3) || (paramLong >= l1 + l2));
        if (paramLong - l3 < l2) {
          break;
        }
      } while (paramBoolean);
      return paramLong - l2;
    } while (!paramBoolean);
    return paramLong + l2;
  }
  
  public long convertLocalToUTC(long paramLong, boolean paramBoolean)
  {
    long l2 = Long.MAX_VALUE;
    int i = getOffset(paramLong);
    int j = getOffset(paramLong - i);
    long l3;
    long l1;
    if ((i != j) && ((paramBoolean) || (i < 0)))
    {
      l3 = nextTransition(paramLong - i);
      l1 = l3;
      if (l3 == paramLong - i) {
        l1 = Long.MAX_VALUE;
      }
      l3 = nextTransition(paramLong - j);
      if (l3 != paramLong - j) {
        break label164;
      }
    }
    for (;;)
    {
      if (l1 != l2) {
        if (paramBoolean) {
          throw new IllegalInstantException(paramLong, getID());
        }
      }
      for (;;)
      {
        l1 = paramLong - i;
        if (((paramLong ^ l1) < 0L) && ((i ^ paramLong) < 0L)) {
          throw new ArithmeticException("Subtracting time zone offset caused overflow");
        }
        return l1;
        i = j;
      }
      label164:
      l2 = l3;
    }
  }
  
  public long convertLocalToUTC(long paramLong1, boolean paramBoolean, long paramLong2)
  {
    int i = getOffset(paramLong2);
    paramLong2 = paramLong1 - i;
    if (getOffset(paramLong2) == i) {
      return paramLong2;
    }
    return convertLocalToUTC(paramLong1, paramBoolean);
  }
  
  public long convertUTCToLocal(long paramLong)
  {
    int i = getOffset(paramLong);
    long l = i + paramLong;
    if (((paramLong ^ l) < 0L) && ((i ^ paramLong) >= 0L)) {
      throw new ArithmeticException("Adding time zone offset caused overflow");
    }
    return l;
  }
  
  public abstract boolean equals(Object paramObject);
  
  @ToString
  public final String getID()
  {
    return this.h;
  }
  
  public long getMillisKeepLocal(DateTimeZone paramDateTimeZone, long paramLong)
  {
    if (paramDateTimeZone == null) {
      paramDateTimeZone = getDefault();
    }
    for (;;)
    {
      if (paramDateTimeZone == this) {
        return paramLong;
      }
      return paramDateTimeZone.convertLocalToUTC(convertUTCToLocal(paramLong), false, paramLong);
    }
  }
  
  public final String getName(long paramLong)
  {
    return getName(paramLong, null);
  }
  
  public String getName(long paramLong, Locale paramLocale)
  {
    Object localObject = paramLocale;
    if (paramLocale == null) {
      localObject = Locale.getDefault();
    }
    paramLocale = getNameKey(paramLong);
    if (paramLocale == null) {
      paramLocale = this.h;
    }
    do
    {
      return paramLocale;
      localObject = b.getName((Locale)localObject, this.h, paramLocale);
      paramLocale = (Locale)localObject;
    } while (localObject != null);
    return a(getOffset(paramLong));
  }
  
  public abstract String getNameKey(long paramLong);
  
  public abstract int getOffset(long paramLong);
  
  public final int getOffset(ReadableInstant paramReadableInstant)
  {
    if (paramReadableInstant == null) {
      return getOffset(DateTimeUtils.currentTimeMillis());
    }
    return getOffset(paramReadableInstant.getMillis());
  }
  
  public int getOffsetFromLocal(long paramLong)
  {
    int i = getOffset(paramLong);
    long l = paramLong - i;
    int j = getOffset(l);
    if (i != j)
    {
      if ((i - j < 0) && (nextTransition(l) != nextTransition(paramLong - j))) {
        return i;
      }
    }
    else if (i >= 0)
    {
      paramLong = previousTransition(l);
      if (paramLong < l)
      {
        int k = getOffset(paramLong);
        if (l - paramLong <= k - i) {
          return k;
        }
      }
    }
    return j;
  }
  
  public final String getShortName(long paramLong)
  {
    return getShortName(paramLong, null);
  }
  
  public String getShortName(long paramLong, Locale paramLocale)
  {
    Object localObject = paramLocale;
    if (paramLocale == null) {
      localObject = Locale.getDefault();
    }
    paramLocale = getNameKey(paramLong);
    if (paramLocale == null) {
      paramLocale = this.h;
    }
    do
    {
      return paramLocale;
      localObject = b.getShortName((Locale)localObject, this.h, paramLocale);
      paramLocale = (Locale)localObject;
    } while (localObject != null);
    return a(getOffset(paramLong));
  }
  
  public abstract int getStandardOffset(long paramLong);
  
  public int hashCode()
  {
    return getID().hashCode() + 57;
  }
  
  public abstract boolean isFixed();
  
  public boolean isLocalDateTimeGap(LocalDateTime paramLocalDateTime)
  {
    if (isFixed()) {
      return false;
    }
    try
    {
      paramLocalDateTime.toDateTime(this);
      return false;
    }
    catch (IllegalInstantException paramLocalDateTime) {}
    return true;
  }
  
  public boolean isStandardOffset(long paramLong)
  {
    return getOffset(paramLong) == getStandardOffset(paramLong);
  }
  
  public abstract long nextTransition(long paramLong);
  
  public abstract long previousTransition(long paramLong);
  
  public String toString()
  {
    return getID();
  }
  
  public TimeZone toTimeZone()
  {
    return TimeZone.getTimeZone(this.h);
  }
  
  protected Object writeReplace()
    throws ObjectStreamException
  {
    return new a(this.h);
  }
  
  static final class a
    implements Serializable
  {
    private static final long serialVersionUID = -6471952376487863581L;
    private transient String a;
    
    a(String paramString)
    {
      this.a = paramString;
    }
    
    private void readObject(ObjectInputStream paramObjectInputStream)
      throws IOException
    {
      this.a = paramObjectInputStream.readUTF();
    }
    
    private Object readResolve()
      throws ObjectStreamException
    {
      return DateTimeZone.forID(this.a);
    }
    
    private void writeObject(ObjectOutputStream paramObjectOutputStream)
      throws IOException
    {
      paramObjectOutputStream.writeUTF(this.a);
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/org/joda/time/DateTimeZone.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */