package org.joda.time;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import java.util.Locale;
import org.joda.time.base.AbstractPartial;
import org.joda.time.field.AbstractPartialFieldProperty;
import org.joda.time.field.FieldUtils;
import org.joda.time.format.DateTimeFormat;
import org.joda.time.format.DateTimeFormatter;
import org.joda.time.format.ISODateTimeFormat;

public final class Partial
  extends AbstractPartial
  implements Serializable, ReadablePartial
{
  private static final long serialVersionUID = 12324121189002L;
  private final Chronology a;
  private final DateTimeFieldType[] b;
  private final int[] c;
  private transient DateTimeFormatter[] d;
  
  public Partial()
  {
    this(null);
  }
  
  public Partial(Chronology paramChronology)
  {
    this.a = DateTimeUtils.getChronology(paramChronology).withUTC();
    this.b = new DateTimeFieldType[0];
    this.c = new int[0];
  }
  
  private Partial(Chronology paramChronology, DateTimeFieldType[] paramArrayOfDateTimeFieldType, int[] paramArrayOfInt)
  {
    this.a = paramChronology;
    this.b = paramArrayOfDateTimeFieldType;
    this.c = paramArrayOfInt;
  }
  
  public Partial(DateTimeFieldType paramDateTimeFieldType, int paramInt)
  {
    this(paramDateTimeFieldType, paramInt, null);
  }
  
  public Partial(DateTimeFieldType paramDateTimeFieldType, int paramInt, Chronology paramChronology)
  {
    paramChronology = DateTimeUtils.getChronology(paramChronology).withUTC();
    this.a = paramChronology;
    if (paramDateTimeFieldType == null) {
      throw new IllegalArgumentException("The field type must not be null");
    }
    this.b = new DateTimeFieldType[] { paramDateTimeFieldType };
    this.c = new int[] { paramInt };
    paramChronology.validate(this, this.c);
  }
  
  Partial(Partial paramPartial, int[] paramArrayOfInt)
  {
    this.a = paramPartial.a;
    this.b = paramPartial.b;
    this.c = paramArrayOfInt;
  }
  
  public Partial(ReadablePartial paramReadablePartial)
  {
    if (paramReadablePartial == null) {
      throw new IllegalArgumentException("The partial must not be null");
    }
    this.a = DateTimeUtils.getChronology(paramReadablePartial.getChronology()).withUTC();
    this.b = new DateTimeFieldType[paramReadablePartial.size()];
    this.c = new int[paramReadablePartial.size()];
    int i = 0;
    while (i < paramReadablePartial.size())
    {
      this.b[i] = paramReadablePartial.getFieldType(i);
      this.c[i] = paramReadablePartial.getValue(i);
      i += 1;
    }
  }
  
  public Partial(DateTimeFieldType[] paramArrayOfDateTimeFieldType, int[] paramArrayOfInt)
  {
    this(paramArrayOfDateTimeFieldType, paramArrayOfInt, null);
  }
  
  public Partial(DateTimeFieldType[] paramArrayOfDateTimeFieldType, int[] paramArrayOfInt, Chronology paramChronology)
  {
    Chronology localChronology = DateTimeUtils.getChronology(paramChronology).withUTC();
    this.a = localChronology;
    if (paramArrayOfDateTimeFieldType == null) {
      throw new IllegalArgumentException("Types array must not be null");
    }
    if (paramArrayOfInt == null) {
      throw new IllegalArgumentException("Values array must not be null");
    }
    if (paramArrayOfInt.length != paramArrayOfDateTimeFieldType.length) {
      throw new IllegalArgumentException("Values array must be the same length as the types array");
    }
    if (paramArrayOfDateTimeFieldType.length == 0)
    {
      this.b = paramArrayOfDateTimeFieldType;
      this.c = paramArrayOfInt;
      return;
    }
    int i = 0;
    while (i < paramArrayOfDateTimeFieldType.length)
    {
      if (paramArrayOfDateTimeFieldType[i] == null) {
        throw new IllegalArgumentException("Types array must not contain null: index " + i);
      }
      i += 1;
    }
    paramChronology = null;
    i = j;
    while (i < paramArrayOfDateTimeFieldType.length)
    {
      DateTimeFieldType localDateTimeFieldType = paramArrayOfDateTimeFieldType[i];
      DurationField localDurationField1 = localDateTimeFieldType.getDurationType().getField(this.a);
      if (i > 0)
      {
        j = paramChronology.compareTo(localDurationField1);
        if ((j < 0) || ((j != 0) && (!localDurationField1.isSupported()))) {
          throw new IllegalArgumentException("Types array must be in order largest-smallest: " + paramArrayOfDateTimeFieldType[(i - 1)].getName() + " < " + localDateTimeFieldType.getName());
        }
        if (j == 0) {
          if (paramArrayOfDateTimeFieldType[(i - 1)].getRangeDurationType() == null)
          {
            if (localDateTimeFieldType.getRangeDurationType() == null) {
              throw new IllegalArgumentException("Types array must not contain duplicate: " + localDateTimeFieldType.getName());
            }
          }
          else
          {
            if (localDateTimeFieldType.getRangeDurationType() == null) {
              throw new IllegalArgumentException("Types array must be in order largest-smallest: " + paramArrayOfDateTimeFieldType[(i - 1)].getName() + " < " + localDateTimeFieldType.getName());
            }
            paramChronology = paramArrayOfDateTimeFieldType[(i - 1)].getRangeDurationType().getField(this.a);
            DurationField localDurationField2 = localDateTimeFieldType.getRangeDurationType().getField(this.a);
            if (paramChronology.compareTo(localDurationField2) < 0) {
              throw new IllegalArgumentException("Types array must be in order largest-smallest: " + paramArrayOfDateTimeFieldType[(i - 1)].getName() + " < " + localDateTimeFieldType.getName());
            }
            if (paramChronology.compareTo(localDurationField2) == 0) {
              throw new IllegalArgumentException("Types array must not contain duplicate: " + localDateTimeFieldType.getName());
            }
          }
        }
      }
      i += 1;
      paramChronology = localDurationField1;
    }
    this.b = ((DateTimeFieldType[])paramArrayOfDateTimeFieldType.clone());
    localChronology.validate(this, paramArrayOfInt);
    this.c = ((int[])paramArrayOfInt.clone());
  }
  
  public final Chronology getChronology()
  {
    return this.a;
  }
  
  protected final DateTimeField getField(int paramInt, Chronology paramChronology)
  {
    return this.b[paramInt].getField(paramChronology);
  }
  
  public final DateTimeFieldType getFieldType(int paramInt)
  {
    return this.b[paramInt];
  }
  
  public final DateTimeFieldType[] getFieldTypes()
  {
    return (DateTimeFieldType[])this.b.clone();
  }
  
  public final DateTimeFormatter getFormatter()
  {
    Object localObject2 = this.d;
    Object localObject1 = localObject2;
    if (localObject2 == null)
    {
      if (size() == 0) {
        return null;
      }
      localObject1 = new DateTimeFormatter[2];
    }
    try
    {
      localObject2 = new ArrayList(Arrays.asList(this.b));
      localObject1[0] = ISODateTimeFormat.forFields((Collection)localObject2, true, false);
      if (((List)localObject2).size() == 0) {
        localObject1[1] = localObject1[0];
      }
    }
    catch (IllegalArgumentException localIllegalArgumentException)
    {
      for (;;) {}
    }
    this.d = ((DateTimeFormatter[])localObject1);
    return localObject1[0];
  }
  
  public final int getValue(int paramInt)
  {
    return this.c[paramInt];
  }
  
  public final int[] getValues()
  {
    return (int[])this.c.clone();
  }
  
  public final boolean isMatch(ReadableInstant paramReadableInstant)
  {
    long l = DateTimeUtils.getInstantMillis(paramReadableInstant);
    paramReadableInstant = DateTimeUtils.getInstantChronology(paramReadableInstant);
    int i = 0;
    while (i < this.b.length)
    {
      if (this.b[i].getField(paramReadableInstant).get(l) != this.c[i]) {
        return false;
      }
      i += 1;
    }
    return true;
  }
  
  public final boolean isMatch(ReadablePartial paramReadablePartial)
  {
    if (paramReadablePartial == null) {
      throw new IllegalArgumentException("The partial must not be null");
    }
    int i = 0;
    while (i < this.b.length)
    {
      if (paramReadablePartial.get(this.b[i]) != this.c[i]) {
        return false;
      }
      i += 1;
    }
    return true;
  }
  
  public final Partial minus(ReadablePeriod paramReadablePeriod)
  {
    return withPeriodAdded(paramReadablePeriod, -1);
  }
  
  public final Partial plus(ReadablePeriod paramReadablePeriod)
  {
    return withPeriodAdded(paramReadablePeriod, 1);
  }
  
  public final Property property(DateTimeFieldType paramDateTimeFieldType)
  {
    return new Property(this, indexOfSupported(paramDateTimeFieldType));
  }
  
  public final int size()
  {
    return this.b.length;
  }
  
  public final String toString()
  {
    DateTimeFormatter[] arrayOfDateTimeFormatter = this.d;
    Object localObject = arrayOfDateTimeFormatter;
    if (arrayOfDateTimeFormatter == null)
    {
      getFormatter();
      arrayOfDateTimeFormatter = this.d;
      localObject = arrayOfDateTimeFormatter;
      if (arrayOfDateTimeFormatter == null) {
        return toStringList();
      }
    }
    localObject = localObject[1];
    if (localObject == null) {
      return toStringList();
    }
    return ((DateTimeFormatter)localObject).print(this);
  }
  
  public final String toString(String paramString)
  {
    if (paramString == null) {
      return toString();
    }
    return DateTimeFormat.forPattern(paramString).print(this);
  }
  
  public final String toString(String paramString, Locale paramLocale)
  {
    if (paramString == null) {
      return toString();
    }
    return DateTimeFormat.forPattern(paramString).withLocale(paramLocale).print(this);
  }
  
  public final String toStringList()
  {
    int j = size();
    StringBuilder localStringBuilder = new StringBuilder(j * 20);
    localStringBuilder.append('[');
    int i = 0;
    while (i < j)
    {
      if (i > 0) {
        localStringBuilder.append(',').append(' ');
      }
      localStringBuilder.append(this.b[i].getName());
      localStringBuilder.append('=');
      localStringBuilder.append(this.c[i]);
      i += 1;
    }
    localStringBuilder.append(']');
    return localStringBuilder.toString();
  }
  
  public final Partial with(DateTimeFieldType paramDateTimeFieldType, int paramInt)
  {
    if (paramDateTimeFieldType == null) {
      throw new IllegalArgumentException("The field type must not be null");
    }
    int i = indexOf(paramDateTimeFieldType);
    if (i == -1)
    {
      DateTimeFieldType[] arrayOfDateTimeFieldType = new DateTimeFieldType[this.b.length + 1];
      int[] arrayOfInt = new int[arrayOfDateTimeFieldType.length];
      DurationField localDurationField1 = paramDateTimeFieldType.getDurationType().getField(this.a);
      if (localDurationField1.isSupported())
      {
        i = 0;
        for (;;)
        {
          j = i;
          if (i >= this.b.length) {
            break;
          }
          DateTimeFieldType localDateTimeFieldType = this.b[i];
          DurationField localDurationField2 = localDateTimeFieldType.getDurationType().getField(this.a);
          if (localDurationField2.isSupported())
          {
            int k = localDurationField1.compareTo(localDurationField2);
            j = i;
            if (k > 0) {
              break;
            }
            if (k == 0)
            {
              j = i;
              if (paramDateTimeFieldType.getRangeDurationType().getField(this.a).compareTo(localDateTimeFieldType.getRangeDurationType().getField(this.a)) > 0) {
                break;
              }
            }
          }
          i += 1;
        }
      }
      int j = 0;
      System.arraycopy(this.b, 0, arrayOfDateTimeFieldType, 0, j);
      System.arraycopy(this.c, 0, arrayOfInt, 0, j);
      arrayOfDateTimeFieldType[j] = paramDateTimeFieldType;
      arrayOfInt[j] = paramInt;
      System.arraycopy(this.b, j, arrayOfDateTimeFieldType, j + 1, arrayOfDateTimeFieldType.length - j - 1);
      System.arraycopy(this.c, j, arrayOfInt, j + 1, arrayOfInt.length - j - 1);
      paramDateTimeFieldType = new Partial(this.a, arrayOfDateTimeFieldType, arrayOfInt);
      this.a.validate(paramDateTimeFieldType, arrayOfInt);
    }
    do
    {
      return paramDateTimeFieldType;
      paramDateTimeFieldType = this;
    } while (paramInt == getValue(i));
    paramDateTimeFieldType = getValues();
    return new Partial(this, getField(i).set(this, i, paramDateTimeFieldType, paramInt));
  }
  
  public final Partial withChronologyRetainFields(Chronology paramChronology)
  {
    paramChronology = DateTimeUtils.getChronology(paramChronology).withUTC();
    if (paramChronology == getChronology()) {
      return this;
    }
    Partial localPartial = new Partial(paramChronology, this.b, this.c);
    paramChronology.validate(localPartial, this.c);
    return localPartial;
  }
  
  public final Partial withField(DateTimeFieldType paramDateTimeFieldType, int paramInt)
  {
    int i = indexOfSupported(paramDateTimeFieldType);
    if (paramInt == getValue(i)) {
      return this;
    }
    paramDateTimeFieldType = getValues();
    return new Partial(this, getField(i).set(this, i, paramDateTimeFieldType, paramInt));
  }
  
  public final Partial withFieldAddWrapped(DurationFieldType paramDurationFieldType, int paramInt)
  {
    int i = indexOfSupported(paramDurationFieldType);
    if (paramInt == 0) {
      return this;
    }
    paramDurationFieldType = getValues();
    return new Partial(this, getField(i).addWrapPartial(this, i, paramDurationFieldType, paramInt));
  }
  
  public final Partial withFieldAdded(DurationFieldType paramDurationFieldType, int paramInt)
  {
    int i = indexOfSupported(paramDurationFieldType);
    if (paramInt == 0) {
      return this;
    }
    paramDurationFieldType = getValues();
    return new Partial(this, getField(i).add(this, i, paramDurationFieldType, paramInt));
  }
  
  public final Partial withPeriodAdded(ReadablePeriod paramReadablePeriod, int paramInt)
  {
    if ((paramReadablePeriod == null) || (paramInt == 0)) {
      return this;
    }
    Object localObject1 = getValues();
    int i = 0;
    while (i < paramReadablePeriod.size())
    {
      int j = indexOf(paramReadablePeriod.getFieldType(i));
      Object localObject2 = localObject1;
      if (j >= 0) {
        localObject2 = getField(j).add(this, j, (int[])localObject1, FieldUtils.safeMultiply(paramReadablePeriod.getValue(i), paramInt));
      }
      i += 1;
      localObject1 = localObject2;
    }
    return new Partial(this, (int[])localObject1);
  }
  
  public final Partial without(DateTimeFieldType paramDateTimeFieldType)
  {
    int i = indexOf(paramDateTimeFieldType);
    paramDateTimeFieldType = this;
    if (i != -1)
    {
      paramDateTimeFieldType = new DateTimeFieldType[size() - 1];
      int[] arrayOfInt = new int[size() - 1];
      System.arraycopy(this.b, 0, paramDateTimeFieldType, 0, i);
      System.arraycopy(this.b, i + 1, paramDateTimeFieldType, i, paramDateTimeFieldType.length - i);
      System.arraycopy(this.c, 0, arrayOfInt, 0, i);
      System.arraycopy(this.c, i + 1, arrayOfInt, i, arrayOfInt.length - i);
      paramDateTimeFieldType = new Partial(this.a, paramDateTimeFieldType, arrayOfInt);
      this.a.validate(paramDateTimeFieldType, arrayOfInt);
    }
    return paramDateTimeFieldType;
  }
  
  public static class Property
    extends AbstractPartialFieldProperty
    implements Serializable
  {
    private static final long serialVersionUID = 53278362873888L;
    private final Partial a;
    private final int b;
    
    Property(Partial paramPartial, int paramInt)
    {
      this.a = paramPartial;
      this.b = paramInt;
    }
    
    public Partial addToCopy(int paramInt)
    {
      int[] arrayOfInt = this.a.getValues();
      arrayOfInt = getField().add(this.a, this.b, arrayOfInt, paramInt);
      return new Partial(this.a, arrayOfInt);
    }
    
    public Partial addWrapFieldToCopy(int paramInt)
    {
      int[] arrayOfInt = this.a.getValues();
      arrayOfInt = getField().addWrapField(this.a, this.b, arrayOfInt, paramInt);
      return new Partial(this.a, arrayOfInt);
    }
    
    public int get()
    {
      return this.a.getValue(this.b);
    }
    
    public DateTimeField getField()
    {
      return this.a.getField(this.b);
    }
    
    public Partial getPartial()
    {
      return this.a;
    }
    
    protected ReadablePartial getReadablePartial()
    {
      return this.a;
    }
    
    public Partial setCopy(int paramInt)
    {
      int[] arrayOfInt = this.a.getValues();
      arrayOfInt = getField().set(this.a, this.b, arrayOfInt, paramInt);
      return new Partial(this.a, arrayOfInt);
    }
    
    public Partial setCopy(String paramString)
    {
      return setCopy(paramString, null);
    }
    
    public Partial setCopy(String paramString, Locale paramLocale)
    {
      int[] arrayOfInt = this.a.getValues();
      paramString = getField().set(this.a, this.b, arrayOfInt, paramString, paramLocale);
      return new Partial(this.a, paramString);
    }
    
    public Partial withMaximumValue()
    {
      return setCopy(getMaximumValue());
    }
    
    public Partial withMinimumValue()
    {
      return setCopy(getMinimumValue());
    }
  }
}


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