package org.joda.time.base;

import java.io.Serializable;
import org.joda.time.Chronology;
import org.joda.time.DateTimeUtils;
import org.joda.time.Duration;
import org.joda.time.DurationFieldType;
import org.joda.time.MutablePeriod;
import org.joda.time.PeriodType;
import org.joda.time.ReadWritablePeriod;
import org.joda.time.ReadableDuration;
import org.joda.time.ReadableInstant;
import org.joda.time.ReadablePartial;
import org.joda.time.ReadablePeriod;
import org.joda.time.chrono.ISOChronology;
import org.joda.time.convert.ConverterManager;
import org.joda.time.convert.PeriodConverter;
import org.joda.time.field.FieldUtils;

public abstract class BasePeriod
  extends AbstractPeriod
  implements Serializable, ReadablePeriod
{
  private static final ReadablePeriod a = new AbstractPeriod()
  {
    public final PeriodType getPeriodType()
    {
      return PeriodType.time();
    }
    
    public final int getValue(int paramAnonymousInt)
    {
      return 0;
    }
  };
  private static final long serialVersionUID = -2110953284060001145L;
  private final PeriodType b;
  private final int[] c;
  
  protected BasePeriod(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, int paramInt6, int paramInt7, int paramInt8, PeriodType paramPeriodType)
  {
    this.b = checkPeriodType(paramPeriodType);
    this.c = a(paramInt1, paramInt2, paramInt3, paramInt4, paramInt5, paramInt6, paramInt7, paramInt8);
  }
  
  protected BasePeriod(long paramLong)
  {
    this.b = PeriodType.standard();
    int[] arrayOfInt = ISOChronology.getInstanceUTC().get(a, paramLong);
    this.c = new int[8];
    System.arraycopy(arrayOfInt, 0, this.c, 4, 4);
  }
  
  protected BasePeriod(long paramLong1, long paramLong2, PeriodType paramPeriodType, Chronology paramChronology)
  {
    paramPeriodType = checkPeriodType(paramPeriodType);
    paramChronology = DateTimeUtils.getChronology(paramChronology);
    this.b = paramPeriodType;
    this.c = paramChronology.get(this, paramLong1, paramLong2);
  }
  
  protected BasePeriod(long paramLong, PeriodType paramPeriodType, Chronology paramChronology)
  {
    paramPeriodType = checkPeriodType(paramPeriodType);
    paramChronology = DateTimeUtils.getChronology(paramChronology);
    this.b = paramPeriodType;
    this.c = paramChronology.get(this, paramLong);
  }
  
  protected BasePeriod(Object paramObject, PeriodType paramPeriodType, Chronology paramChronology)
  {
    PeriodConverter localPeriodConverter = ConverterManager.getInstance().getPeriodConverter(paramObject);
    PeriodType localPeriodType = paramPeriodType;
    if (paramPeriodType == null) {
      localPeriodType = localPeriodConverter.getPeriodType(paramObject);
    }
    paramPeriodType = checkPeriodType(localPeriodType);
    this.b = paramPeriodType;
    if ((this instanceof ReadWritablePeriod))
    {
      this.c = new int[size()];
      paramPeriodType = DateTimeUtils.getChronology(paramChronology);
      localPeriodConverter.setInto((ReadWritablePeriod)this, paramObject, paramPeriodType);
      return;
    }
    this.c = new MutablePeriod(paramObject, paramPeriodType, paramChronology).getValues();
  }
  
  protected BasePeriod(ReadableDuration paramReadableDuration, ReadableInstant paramReadableInstant, PeriodType paramPeriodType)
  {
    paramPeriodType = checkPeriodType(paramPeriodType);
    long l2 = DateTimeUtils.getDurationMillis(paramReadableDuration);
    long l1 = DateTimeUtils.getInstantMillis(paramReadableInstant);
    l2 = FieldUtils.safeSubtract(l1, l2);
    paramReadableDuration = DateTimeUtils.getInstantChronology(paramReadableInstant);
    this.b = paramPeriodType;
    this.c = paramReadableDuration.get(this, l2, l1);
  }
  
  protected BasePeriod(ReadableInstant paramReadableInstant, ReadableDuration paramReadableDuration, PeriodType paramPeriodType)
  {
    paramPeriodType = checkPeriodType(paramPeriodType);
    long l1 = DateTimeUtils.getInstantMillis(paramReadableInstant);
    long l2 = FieldUtils.safeAdd(l1, DateTimeUtils.getDurationMillis(paramReadableDuration));
    paramReadableInstant = DateTimeUtils.getInstantChronology(paramReadableInstant);
    this.b = paramPeriodType;
    this.c = paramReadableInstant.get(this, l1, l2);
  }
  
  protected BasePeriod(ReadableInstant paramReadableInstant1, ReadableInstant paramReadableInstant2, PeriodType paramPeriodType)
  {
    paramPeriodType = checkPeriodType(paramPeriodType);
    if ((paramReadableInstant1 == null) && (paramReadableInstant2 == null))
    {
      this.b = paramPeriodType;
      this.c = new int[size()];
      return;
    }
    long l1 = DateTimeUtils.getInstantMillis(paramReadableInstant1);
    long l2 = DateTimeUtils.getInstantMillis(paramReadableInstant2);
    paramReadableInstant1 = DateTimeUtils.getIntervalChronology(paramReadableInstant1, paramReadableInstant2);
    this.b = paramPeriodType;
    this.c = paramReadableInstant1.get(this, l1, l2);
  }
  
  protected BasePeriod(ReadablePartial paramReadablePartial1, ReadablePartial paramReadablePartial2, PeriodType paramPeriodType)
  {
    if ((paramReadablePartial1 == null) || (paramReadablePartial2 == null)) {
      throw new IllegalArgumentException("ReadablePartial objects must not be null");
    }
    if (((paramReadablePartial1 instanceof BaseLocal)) && ((paramReadablePartial2 instanceof BaseLocal)) && (paramReadablePartial1.getClass() == paramReadablePartial2.getClass()))
    {
      paramPeriodType = checkPeriodType(paramPeriodType);
      long l1 = ((BaseLocal)paramReadablePartial1).getLocalMillis();
      long l2 = ((BaseLocal)paramReadablePartial2).getLocalMillis();
      paramReadablePartial1 = DateTimeUtils.getChronology(paramReadablePartial1.getChronology());
      this.b = paramPeriodType;
      this.c = paramReadablePartial1.get(this, l1, l2);
      return;
    }
    if (paramReadablePartial1.size() != paramReadablePartial2.size()) {
      throw new IllegalArgumentException("ReadablePartial objects must have the same set of fields");
    }
    int i = 0;
    int j = paramReadablePartial1.size();
    while (i < j)
    {
      if (paramReadablePartial1.getFieldType(i) != paramReadablePartial2.getFieldType(i)) {
        throw new IllegalArgumentException("ReadablePartial objects must have the same set of fields");
      }
      i += 1;
    }
    if (!DateTimeUtils.isContiguous(paramReadablePartial1)) {
      throw new IllegalArgumentException("ReadablePartial objects must be contiguous");
    }
    this.b = checkPeriodType(paramPeriodType);
    paramPeriodType = DateTimeUtils.getChronology(paramReadablePartial1.getChronology()).withUTC();
    this.c = paramPeriodType.get(this, paramPeriodType.set(paramReadablePartial1, 0L), paramPeriodType.set(paramReadablePartial2, 0L));
  }
  
  protected BasePeriod(int[] paramArrayOfInt, PeriodType paramPeriodType)
  {
    this.b = paramPeriodType;
    this.c = paramArrayOfInt;
  }
  
  private void a(DurationFieldType paramDurationFieldType, int[] paramArrayOfInt, int paramInt)
  {
    int i = indexOf(paramDurationFieldType);
    if (i == -1)
    {
      if (paramInt != 0) {
        throw new IllegalArgumentException("Period does not support field '" + paramDurationFieldType.getName() + "'");
      }
    }
    else {
      paramArrayOfInt[i] = paramInt;
    }
  }
  
  private int[] a(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, int paramInt6, int paramInt7, int paramInt8)
  {
    int[] arrayOfInt = new int[size()];
    a(DurationFieldType.years(), arrayOfInt, paramInt1);
    a(DurationFieldType.months(), arrayOfInt, paramInt2);
    a(DurationFieldType.weeks(), arrayOfInt, paramInt3);
    a(DurationFieldType.days(), arrayOfInt, paramInt4);
    a(DurationFieldType.hours(), arrayOfInt, paramInt5);
    a(DurationFieldType.minutes(), arrayOfInt, paramInt6);
    a(DurationFieldType.seconds(), arrayOfInt, paramInt7);
    a(DurationFieldType.millis(), arrayOfInt, paramInt8);
    return arrayOfInt;
  }
  
  protected void addField(DurationFieldType paramDurationFieldType, int paramInt)
  {
    addFieldInto(this.c, paramDurationFieldType, paramInt);
  }
  
  protected void addFieldInto(int[] paramArrayOfInt, DurationFieldType paramDurationFieldType, int paramInt)
  {
    int i = indexOf(paramDurationFieldType);
    if (i == -1)
    {
      if ((paramInt != 0) || (paramDurationFieldType == null)) {
        throw new IllegalArgumentException("Period does not support field '" + paramDurationFieldType + "'");
      }
    }
    else {
      paramArrayOfInt[i] = FieldUtils.safeAdd(paramArrayOfInt[i], paramInt);
    }
  }
  
  protected void addPeriod(ReadablePeriod paramReadablePeriod)
  {
    if (paramReadablePeriod != null) {
      setValues(addPeriodInto(getValues(), paramReadablePeriod));
    }
  }
  
  protected int[] addPeriodInto(int[] paramArrayOfInt, ReadablePeriod paramReadablePeriod)
  {
    int i = 0;
    int j = paramReadablePeriod.size();
    while (i < j)
    {
      DurationFieldType localDurationFieldType = paramReadablePeriod.getFieldType(i);
      int k = paramReadablePeriod.getValue(i);
      if (k != 0)
      {
        int m = indexOf(localDurationFieldType);
        if (m == -1) {
          throw new IllegalArgumentException("Period does not support field '" + localDurationFieldType.getName() + "'");
        }
        paramArrayOfInt[m] = FieldUtils.safeAdd(getValue(m), k);
      }
      i += 1;
    }
    return paramArrayOfInt;
  }
  
  protected PeriodType checkPeriodType(PeriodType paramPeriodType)
  {
    return DateTimeUtils.getPeriodType(paramPeriodType);
  }
  
  public PeriodType getPeriodType()
  {
    return this.b;
  }
  
  public int getValue(int paramInt)
  {
    return this.c[paramInt];
  }
  
  public void mergePeriod(ReadablePeriod paramReadablePeriod)
  {
    if (paramReadablePeriod != null) {
      setValues(mergePeriodInto(getValues(), paramReadablePeriod));
    }
  }
  
  protected int[] mergePeriodInto(int[] paramArrayOfInt, ReadablePeriod paramReadablePeriod)
  {
    int i = 0;
    int j = paramReadablePeriod.size();
    while (i < j)
    {
      a(paramReadablePeriod.getFieldType(i), paramArrayOfInt, paramReadablePeriod.getValue(i));
      i += 1;
    }
    return paramArrayOfInt;
  }
  
  protected void setField(DurationFieldType paramDurationFieldType, int paramInt)
  {
    setFieldInto(this.c, paramDurationFieldType, paramInt);
  }
  
  protected void setFieldInto(int[] paramArrayOfInt, DurationFieldType paramDurationFieldType, int paramInt)
  {
    int i = indexOf(paramDurationFieldType);
    if (i == -1)
    {
      if ((paramInt != 0) || (paramDurationFieldType == null)) {
        throw new IllegalArgumentException("Period does not support field '" + paramDurationFieldType + "'");
      }
    }
    else {
      paramArrayOfInt[i] = paramInt;
    }
  }
  
  public void setPeriod(int paramInt1, int paramInt2, int paramInt3, int paramInt4, int paramInt5, int paramInt6, int paramInt7, int paramInt8)
  {
    setValues(a(paramInt1, paramInt2, paramInt3, paramInt4, paramInt5, paramInt6, paramInt7, paramInt8));
  }
  
  public void setPeriod(ReadablePeriod paramReadablePeriod)
  {
    if (paramReadablePeriod == null)
    {
      setValues(new int[size()]);
      return;
    }
    int[] arrayOfInt = new int[size()];
    int i = 0;
    int j = paramReadablePeriod.size();
    while (i < j)
    {
      a(paramReadablePeriod.getFieldType(i), arrayOfInt, paramReadablePeriod.getValue(i));
      i += 1;
    }
    setValues(arrayOfInt);
  }
  
  public void setValue(int paramInt1, int paramInt2)
  {
    this.c[paramInt1] = paramInt2;
  }
  
  protected void setValues(int[] paramArrayOfInt)
  {
    System.arraycopy(paramArrayOfInt, 0, this.c, 0, this.c.length);
  }
  
  public Duration toDurationFrom(ReadableInstant paramReadableInstant)
  {
    long l = DateTimeUtils.getInstantMillis(paramReadableInstant);
    return new Duration(l, DateTimeUtils.getInstantChronology(paramReadableInstant).add(this, l, 1));
  }
  
  public Duration toDurationTo(ReadableInstant paramReadableInstant)
  {
    long l = DateTimeUtils.getInstantMillis(paramReadableInstant);
    return new Duration(DateTimeUtils.getInstantChronology(paramReadableInstant).add(this, l, -1), l);
  }
}


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