package org.joda.time.format;

import java.io.IOException;
import java.io.Writer;
import java.util.Locale;
import org.joda.time.Chronology;
import org.joda.time.DateTime;
import org.joda.time.DateTimeField;
import org.joda.time.DateTimeUtils;
import org.joda.time.DateTimeZone;
import org.joda.time.LocalDate;
import org.joda.time.LocalDateTime;
import org.joda.time.LocalTime;
import org.joda.time.MutableDateTime;
import org.joda.time.ReadWritableInstant;
import org.joda.time.ReadableInstant;
import org.joda.time.ReadablePartial;

public class DateTimeFormatter
{
  private final DateTimePrinter a;
  private final DateTimeParser b;
  private final Locale c;
  private final boolean d;
  private final Chronology e;
  private final DateTimeZone f;
  private final Integer g;
  private final int h;
  
  public DateTimeFormatter(DateTimePrinter paramDateTimePrinter, DateTimeParser paramDateTimeParser)
  {
    this.a = paramDateTimePrinter;
    this.b = paramDateTimeParser;
    this.c = null;
    this.d = false;
    this.e = null;
    this.f = null;
    this.g = null;
    this.h = 2000;
  }
  
  private DateTimeFormatter(DateTimePrinter paramDateTimePrinter, DateTimeParser paramDateTimeParser, Locale paramLocale, boolean paramBoolean, Chronology paramChronology, DateTimeZone paramDateTimeZone, Integer paramInteger, int paramInt)
  {
    this.a = paramDateTimePrinter;
    this.b = paramDateTimeParser;
    this.c = paramLocale;
    this.d = paramBoolean;
    this.e = paramChronology;
    this.f = paramDateTimeZone;
    this.g = paramInteger;
    this.h = paramInt;
  }
  
  private Chronology a(Chronology paramChronology)
  {
    paramChronology = DateTimeUtils.getChronology(paramChronology);
    if (this.e != null) {
      paramChronology = this.e;
    }
    Chronology localChronology = paramChronology;
    if (this.f != null) {
      localChronology = paramChronology.withZone(this.f);
    }
    return localChronology;
  }
  
  private DateTimePrinter a()
  {
    DateTimePrinter localDateTimePrinter = this.a;
    if (localDateTimePrinter == null) {
      throw new UnsupportedOperationException("Printing not supported");
    }
    return localDateTimePrinter;
  }
  
  private void a(Writer paramWriter, long paramLong, Chronology paramChronology)
    throws IOException
  {
    DateTimePrinter localDateTimePrinter = a();
    Chronology localChronology = a(paramChronology);
    DateTimeZone localDateTimeZone = localChronology.getZone();
    int j = localDateTimeZone.getOffset(paramLong);
    long l2 = j + paramLong;
    long l1 = l2;
    int i = j;
    paramChronology = localDateTimeZone;
    if ((paramLong ^ l2) < 0L)
    {
      l1 = l2;
      i = j;
      paramChronology = localDateTimeZone;
      if ((j ^ paramLong) >= 0L)
      {
        paramChronology = DateTimeZone.UTC;
        i = 0;
        l1 = paramLong;
      }
    }
    localDateTimePrinter.printTo(paramWriter, l1, localChronology.withUTC(), i, paramChronology, this.c);
  }
  
  private void a(StringBuffer paramStringBuffer, long paramLong, Chronology paramChronology)
  {
    DateTimePrinter localDateTimePrinter = a();
    Chronology localChronology = a(paramChronology);
    DateTimeZone localDateTimeZone = localChronology.getZone();
    int j = localDateTimeZone.getOffset(paramLong);
    long l2 = j + paramLong;
    long l1 = l2;
    int i = j;
    paramChronology = localDateTimeZone;
    if ((paramLong ^ l2) < 0L)
    {
      l1 = l2;
      i = j;
      paramChronology = localDateTimeZone;
      if ((j ^ paramLong) >= 0L)
      {
        paramChronology = DateTimeZone.UTC;
        i = 0;
        l1 = paramLong;
      }
    }
    localDateTimePrinter.printTo(paramStringBuffer, l1, localChronology.withUTC(), i, paramChronology, this.c);
  }
  
  private DateTimeParser b()
  {
    DateTimeParser localDateTimeParser = this.b;
    if (localDateTimeParser == null) {
      throw new UnsupportedOperationException("Parsing not supported");
    }
    return localDateTimeParser;
  }
  
  @Deprecated
  public Chronology getChronolgy()
  {
    return this.e;
  }
  
  public Chronology getChronology()
  {
    return this.e;
  }
  
  public int getDefaultYear()
  {
    return this.h;
  }
  
  public Locale getLocale()
  {
    return this.c;
  }
  
  public DateTimeParser getParser()
  {
    return this.b;
  }
  
  public Integer getPivotYear()
  {
    return this.g;
  }
  
  public DateTimePrinter getPrinter()
  {
    return this.a;
  }
  
  public DateTimeZone getZone()
  {
    return this.f;
  }
  
  public boolean isOffsetParsed()
  {
    return this.d;
  }
  
  public boolean isParser()
  {
    return this.b != null;
  }
  
  public boolean isPrinter()
  {
    return this.a != null;
  }
  
  public DateTime parseDateTime(String paramString)
  {
    DateTimeParser localDateTimeParser = b();
    Object localObject = a(null);
    DateTimeParserBucket localDateTimeParserBucket = new DateTimeParserBucket(0L, (Chronology)localObject, this.c, this.g, this.h);
    int j = localDateTimeParser.parseInto(localDateTimeParserBucket, paramString, 0);
    int i;
    if (j >= 0)
    {
      i = j;
      if (j >= paramString.length())
      {
        long l = localDateTimeParserBucket.computeMillis(true, paramString);
        if ((this.d) && (localDateTimeParserBucket.getOffsetInteger() != null)) {
          paramString = ((Chronology)localObject).withZone(DateTimeZone.forOffsetMillis(localDateTimeParserBucket.getOffsetInteger().intValue()));
        }
        for (;;)
        {
          localObject = new DateTime(l, paramString);
          paramString = (String)localObject;
          if (this.f != null) {
            paramString = ((DateTime)localObject).withZone(this.f);
          }
          return paramString;
          paramString = (String)localObject;
          if (localDateTimeParserBucket.getZone() != null) {
            paramString = ((Chronology)localObject).withZone(localDateTimeParserBucket.getZone());
          }
        }
      }
    }
    else
    {
      i = j ^ 0xFFFFFFFF;
    }
    throw new IllegalArgumentException(FormatUtils.b(paramString, i));
  }
  
  public int parseInto(ReadWritableInstant paramReadWritableInstant, String paramString, int paramInt)
  {
    DateTimeParser localDateTimeParser = b();
    if (paramReadWritableInstant == null) {
      throw new IllegalArgumentException("Instant must not be null");
    }
    long l = paramReadWritableInstant.getMillis();
    Chronology localChronology = paramReadWritableInstant.getChronology();
    l += localChronology.getZone().getOffset(l);
    localChronology = a(localChronology);
    DateTimeParserBucket localDateTimeParserBucket = new DateTimeParserBucket(l, localChronology, this.c, this.g, localChronology.year().get(l));
    paramInt = localDateTimeParser.parseInto(localDateTimeParserBucket, paramString, paramInt);
    paramReadWritableInstant.setMillis(localDateTimeParserBucket.computeMillis(false, paramString));
    if ((this.d) && (localDateTimeParserBucket.getOffsetInteger() != null)) {
      paramString = localChronology.withZone(DateTimeZone.forOffsetMillis(localDateTimeParserBucket.getOffsetInteger().intValue()));
    }
    for (;;)
    {
      paramReadWritableInstant.setChronology(paramString);
      if (this.f != null) {
        paramReadWritableInstant.setZone(this.f);
      }
      return paramInt;
      paramString = localChronology;
      if (localDateTimeParserBucket.getZone() != null) {
        paramString = localChronology.withZone(localDateTimeParserBucket.getZone());
      }
    }
  }
  
  public LocalDate parseLocalDate(String paramString)
  {
    return parseLocalDateTime(paramString).toLocalDate();
  }
  
  public LocalDateTime parseLocalDateTime(String paramString)
  {
    DateTimeParser localDateTimeParser = b();
    Chronology localChronology = a(null).withUTC();
    DateTimeParserBucket localDateTimeParserBucket = new DateTimeParserBucket(0L, localChronology, this.c, this.g, this.h);
    int j = localDateTimeParser.parseInto(localDateTimeParserBucket, paramString, 0);
    int i;
    if (j >= 0)
    {
      i = j;
      if (j >= paramString.length())
      {
        long l = localDateTimeParserBucket.computeMillis(true, paramString);
        if (localDateTimeParserBucket.getOffsetInteger() != null) {
          paramString = localChronology.withZone(DateTimeZone.forOffsetMillis(localDateTimeParserBucket.getOffsetInteger().intValue()));
        }
        for (;;)
        {
          return new LocalDateTime(l, paramString);
          paramString = localChronology;
          if (localDateTimeParserBucket.getZone() != null) {
            paramString = localChronology.withZone(localDateTimeParserBucket.getZone());
          }
        }
      }
    }
    else
    {
      i = j ^ 0xFFFFFFFF;
    }
    throw new IllegalArgumentException(FormatUtils.b(paramString, i));
  }
  
  public LocalTime parseLocalTime(String paramString)
  {
    return parseLocalDateTime(paramString).toLocalTime();
  }
  
  public long parseMillis(String paramString)
  {
    DateTimeParser localDateTimeParser = b();
    DateTimeParserBucket localDateTimeParserBucket = new DateTimeParserBucket(0L, a(this.e), this.c, this.g, this.h);
    int j = localDateTimeParser.parseInto(localDateTimeParserBucket, paramString, 0);
    int i;
    if (j >= 0)
    {
      i = j;
      if (j >= paramString.length()) {
        return localDateTimeParserBucket.computeMillis(true, paramString);
      }
    }
    else
    {
      i = j ^ 0xFFFFFFFF;
    }
    throw new IllegalArgumentException(FormatUtils.b(paramString, i));
  }
  
  public MutableDateTime parseMutableDateTime(String paramString)
  {
    DateTimeParser localDateTimeParser = b();
    Chronology localChronology = a(null);
    DateTimeParserBucket localDateTimeParserBucket = new DateTimeParserBucket(0L, localChronology, this.c, this.g, this.h);
    int j = localDateTimeParser.parseInto(localDateTimeParserBucket, paramString, 0);
    int i;
    if (j >= 0)
    {
      i = j;
      if (j >= paramString.length())
      {
        long l = localDateTimeParserBucket.computeMillis(true, paramString);
        if ((this.d) && (localDateTimeParserBucket.getOffsetInteger() != null)) {
          paramString = localChronology.withZone(DateTimeZone.forOffsetMillis(localDateTimeParserBucket.getOffsetInteger().intValue()));
        }
        for (;;)
        {
          paramString = new MutableDateTime(l, paramString);
          if (this.f != null) {
            paramString.setZone(this.f);
          }
          return paramString;
          paramString = localChronology;
          if (localDateTimeParserBucket.getZone() != null) {
            paramString = localChronology.withZone(localDateTimeParserBucket.getZone());
          }
        }
      }
    }
    else
    {
      i = j ^ 0xFFFFFFFF;
    }
    throw new IllegalArgumentException(FormatUtils.b(paramString, i));
  }
  
  public String print(long paramLong)
  {
    StringBuffer localStringBuffer = new StringBuffer(a().estimatePrintedLength());
    printTo(localStringBuffer, paramLong);
    return localStringBuffer.toString();
  }
  
  public String print(ReadableInstant paramReadableInstant)
  {
    StringBuffer localStringBuffer = new StringBuffer(a().estimatePrintedLength());
    printTo(localStringBuffer, paramReadableInstant);
    return localStringBuffer.toString();
  }
  
  public String print(ReadablePartial paramReadablePartial)
  {
    StringBuffer localStringBuffer = new StringBuffer(a().estimatePrintedLength());
    printTo(localStringBuffer, paramReadablePartial);
    return localStringBuffer.toString();
  }
  
  public void printTo(Writer paramWriter, long paramLong)
    throws IOException
  {
    a(paramWriter, paramLong, null);
  }
  
  public void printTo(Writer paramWriter, ReadableInstant paramReadableInstant)
    throws IOException
  {
    a(paramWriter, DateTimeUtils.getInstantMillis(paramReadableInstant), DateTimeUtils.getInstantChronology(paramReadableInstant));
  }
  
  public void printTo(Writer paramWriter, ReadablePartial paramReadablePartial)
    throws IOException
  {
    DateTimePrinter localDateTimePrinter = a();
    if (paramReadablePartial == null) {
      throw new IllegalArgumentException("The partial must not be null");
    }
    localDateTimePrinter.printTo(paramWriter, paramReadablePartial, this.c);
  }
  
  public void printTo(Appendable paramAppendable, long paramLong)
    throws IOException
  {
    paramAppendable.append(print(paramLong));
  }
  
  public void printTo(Appendable paramAppendable, ReadableInstant paramReadableInstant)
    throws IOException
  {
    paramAppendable.append(print(paramReadableInstant));
  }
  
  public void printTo(Appendable paramAppendable, ReadablePartial paramReadablePartial)
    throws IOException
  {
    paramAppendable.append(print(paramReadablePartial));
  }
  
  public void printTo(StringBuffer paramStringBuffer, long paramLong)
  {
    a(paramStringBuffer, paramLong, null);
  }
  
  public void printTo(StringBuffer paramStringBuffer, ReadableInstant paramReadableInstant)
  {
    a(paramStringBuffer, DateTimeUtils.getInstantMillis(paramReadableInstant), DateTimeUtils.getInstantChronology(paramReadableInstant));
  }
  
  public void printTo(StringBuffer paramStringBuffer, ReadablePartial paramReadablePartial)
  {
    DateTimePrinter localDateTimePrinter = a();
    if (paramReadablePartial == null) {
      throw new IllegalArgumentException("The partial must not be null");
    }
    localDateTimePrinter.printTo(paramStringBuffer, paramReadablePartial, this.c);
  }
  
  public DateTimeFormatter withChronology(Chronology paramChronology)
  {
    if (this.e == paramChronology) {
      return this;
    }
    return new DateTimeFormatter(this.a, this.b, this.c, this.d, paramChronology, this.f, this.g, this.h);
  }
  
  public DateTimeFormatter withDefaultYear(int paramInt)
  {
    return new DateTimeFormatter(this.a, this.b, this.c, this.d, this.e, this.f, this.g, paramInt);
  }
  
  public DateTimeFormatter withLocale(Locale paramLocale)
  {
    if ((paramLocale == getLocale()) || ((paramLocale != null) && (paramLocale.equals(getLocale())))) {
      return this;
    }
    return new DateTimeFormatter(this.a, this.b, paramLocale, this.d, this.e, this.f, this.g, this.h);
  }
  
  public DateTimeFormatter withOffsetParsed()
  {
    if (this.d == true) {
      return this;
    }
    return new DateTimeFormatter(this.a, this.b, this.c, true, this.e, null, this.g, this.h);
  }
  
  public DateTimeFormatter withPivotYear(int paramInt)
  {
    return withPivotYear(Integer.valueOf(paramInt));
  }
  
  public DateTimeFormatter withPivotYear(Integer paramInteger)
  {
    if ((this.g == paramInteger) || ((this.g != null) && (this.g.equals(paramInteger)))) {
      return this;
    }
    return new DateTimeFormatter(this.a, this.b, this.c, this.d, this.e, this.f, paramInteger, this.h);
  }
  
  public DateTimeFormatter withZone(DateTimeZone paramDateTimeZone)
  {
    if (this.f == paramDateTimeZone) {
      return this;
    }
    return new DateTimeFormatter(this.a, this.b, this.c, false, this.e, paramDateTimeZone, this.g, this.h);
  }
  
  public DateTimeFormatter withZoneUTC()
  {
    return withZone(DateTimeZone.UTC);
  }
}


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