/*
   Copyright (c) 2011 James Ahlborn
   
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
   
       http://www.apache.org/licenses/LICENSE-2.0
   
  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
  */
  
  package com.healthmarketscience.jackcess.impl.complex;
  
  import java.io.IOException;
  import java.time.LocalDateTime;
  import java.util.Date;
  import java.util.List;
  import java.util.Map;
  
  import com.healthmarketscience.jackcess.Column;
  import com.healthmarketscience.jackcess.Database;
  import com.healthmarketscience.jackcess.DateTimeType;
  import com.healthmarketscience.jackcess.Row;
  import com.healthmarketscience.jackcess.complex.Attachment;
  import com.healthmarketscience.jackcess.complex.AttachmentColumnInfo;
  import com.healthmarketscience.jackcess.complex.ComplexColumnInfo;
  import com.healthmarketscience.jackcess.complex.ComplexDataType;
  import com.healthmarketscience.jackcess.complex.ComplexValue;
  import com.healthmarketscience.jackcess.complex.ComplexValueForeignKey;
  import com.healthmarketscience.jackcess.complex.MultiValueColumnInfo;
  import com.healthmarketscience.jackcess.complex.SingleValue;
  import com.healthmarketscience.jackcess.complex.UnsupportedColumnInfo;
  import com.healthmarketscience.jackcess.complex.UnsupportedValue;
  import com.healthmarketscience.jackcess.complex.Version;
  import com.healthmarketscience.jackcess.complex.VersionHistoryColumnInfo;
  
  /**
   * Value which is returned for a complex column.  This value corresponds to a
   * foreign key in a secondary table which contains the actual complex data for
   * this row (which could be 0 or more complex values for a given row).  This
   * class contains various convenience methods for interacting with the actual
   * complex values.
   * <p>
   * This class will cache the associated complex values returned from one of
   * the lookup methods.  The various modification methods will clear this cache
   * automatically.  The {@link #reset} method may be called manually to clear
   * this internal cache.
   *
   * @author James Ahlborn
   */
  @SuppressWarnings("deprecation")
  public class ComplexValueForeignKeyImpl extends ComplexValueForeignKey
  {
    private static final long serialVersionUID = 20110805L;
  
    private transient final Column _column;
    private final int _value;
    private transient List<? extends ComplexValue> _values;
  
    public ComplexValueForeignKeyImpl(Column column, int value) {
      _column = column;
      _value = value;
    }
  
    @Override
    public int get() {
      return _value;
    }
  
    @Override
    public Column getColumn() {
      return _column;
    }
  
    @Override
    public ComplexDataType getComplexType() {
      return getComplexInfo().getType();
    }
  
    protected ComplexColumnInfo<? extends ComplexValue> getComplexInfo() {
      return _column.getComplexInfo();
    }
  
    protected VersionHistoryColumnInfo getVersionInfo() {
      return (VersionHistoryColumnInfo)getComplexInfo();
    }
  
    protected AttachmentColumnInfo getAttachmentInfo() {
      return (AttachmentColumnInfo)getComplexInfo();
    }
  
    protected MultiValueColumnInfo getMultiValueInfo() {
      return (MultiValueColumnInfo)getComplexInfo();
    }
 
   protected UnsupportedColumnInfo getUnsupportedInfo() {
     return (UnsupportedColumnInfo)getComplexInfo();
   }
 
   @Override
   public int countValues() throws IOException {
     return getComplexInfo().countValues(get());
   }
 
   public List<Row> getRawValues() throws IOException {
     return getComplexInfo().getRawValues(get());
   }
 
   @Override
   public List<? extends ComplexValue> getValues() throws IOException {
     if(_values == null) {
       _values = getComplexInfo().getValues(this);
     }
     return _values;
   }
 
   @Override
   @SuppressWarnings("unchecked")
   public List<Version> getVersions() throws IOException {
     if(getComplexType() != ComplexDataType.VERSION_HISTORY) {
       throw new UnsupportedOperationException();
     }
     return (List<Version>)getValues();
   }
 
   @Override
   @SuppressWarnings("unchecked")
   public List<Attachment> getAttachments() throws IOException {
     if(getComplexType() != ComplexDataType.ATTACHMENT) {
       throw new UnsupportedOperationException();
     }
     return (List<Attachment>)getValues();
   }
 
   @Override
   @SuppressWarnings("unchecked")
   public List<SingleValue> getMultiValues() throws IOException {
     if(getComplexType() != ComplexDataType.MULTI_VALUE) {
       throw new UnsupportedOperationException();
     }
     return (List<SingleValue>)getValues();
   }
 
   @Override
   @SuppressWarnings("unchecked")
   public List<UnsupportedValue> getUnsupportedValues() throws IOException {
     if(getComplexType() != ComplexDataType.UNSUPPORTED) {
       throw new UnsupportedOperationException();
     }
     return (List<UnsupportedValue>)getValues();
   }
 
   @Override
   public void reset() {
     // discard any cached values
     _values = null;
   }
 
   @Override
   public Version addVersion(String value) throws IOException {
     return addVersionImpl(value, now());
   }
 
   @Override
   public Version addVersion(String value, Date modifiedDate) throws IOException {
     return addVersionImpl(value, modifiedDate);
   }
 
   @Override
   public Version addVersion(String value, LocalDateTime modifiedDate) throws IOException {
     return addVersionImpl(value, modifiedDate);
   }
 
   private Version addVersionImpl(String value, Object modifiedDate) throws IOException {
     reset();
     Version v = VersionHistoryColumnInfoImpl.newVersion(this, value, modifiedDate);
     getVersionInfo().addValue(v);
     return v;
   }
 
   @Override
   public Attachment addAttachment(byte[] data) throws IOException {
     return addAttachmentImpl(null, null, null, data, null, null);
   }
 
   @Override
   public Attachment addAttachment(
       String url, String name, String type, byte[] data,
       Date timeStamp, Integer flags)
     throws IOException
   {
     return addAttachmentImpl(url, name, type, data, timeStamp, flags);
   }
 
   @Override
   public Attachment addAttachment(
       String url, String name, String type, byte[] data,
       LocalDateTime timeStamp, Integer flags)
     throws IOException
   {
     return addAttachmentImpl(url, name, type, data, timeStamp, flags);
   }
 
   private Attachment addAttachmentImpl(
       String url, String name, String type, byte[] data,
       Object timeStamp, Integer flags)
     throws IOException
   {
     reset();
     Attachment a = AttachmentColumnInfoImpl.newAttachment(
         this, url, name, type, data, timeStamp, flags);
     getAttachmentInfo().addValue(a);
     return a;
   }
 
   @Override
   public Attachment addEncodedAttachment(byte[] encodedData)
     throws IOException
   {
     return addEncodedAttachmentImpl(null, null, null, encodedData, null, null);
   }
 
   @Override
   public Attachment addEncodedAttachment(
       String url, String name, String type, byte[] encodedData,
       Date timeStamp, Integer flags)
     throws IOException
   {
     return addEncodedAttachmentImpl(url, name, type, encodedData, timeStamp,
                                     flags);
   }
 
   @Override
   public Attachment addEncodedAttachment(
       String url, String name, String type, byte[] encodedData,
       LocalDateTime timeStamp, Integer flags)
     throws IOException
   {
     return addEncodedAttachmentImpl(url, name, type, encodedData, timeStamp,
                                     flags);
   }
 
   private Attachment addEncodedAttachmentImpl(
       String url, String name, String type, byte[] encodedData,
       Object timeStamp, Integer flags)
     throws IOException
   {
     reset();
     Attachment a = AttachmentColumnInfoImpl.newEncodedAttachment(
         this, url, name, type, encodedData, timeStamp, flags);
     getAttachmentInfo().addValue(a);
     return a;
   }
 
   @Override
   public Attachment/../com/healthmarketscience/jackcess/complex/Attachment.html#Attachment">Attachment updateAttachment(Attachment attachment) throws IOException {
     reset();
     getAttachmentInfo().updateValue(attachment);
     return attachment;
   }
 
   @Override
   public Attachment/../com/healthmarketscience/jackcess/complex/Attachment.html#Attachment">Attachment deleteAttachment(Attachment attachment) throws IOException {
     reset();
     getAttachmentInfo().deleteValue(attachment);
     return attachment;
   }
 
   @Override
   public SingleValue addMultiValue(Object value) throws IOException {
     reset();
     SingleValue v = MultiValueColumnInfoImpl.newSingleValue(this, value);
     getMultiValueInfo().addValue(v);
     return v;
   }
 
   @Override
   public SingleValue../com/healthmarketscience/jackcess/complex/SingleValue.html#SingleValue">SingleValue updateMultiValue(SingleValue value) throws IOException {
     reset();
     getMultiValueInfo().updateValue(value);
     return value;
   }
 
   @Override
   public SingleValue../com/healthmarketscience/jackcess/complex/SingleValue.html#SingleValue">SingleValue deleteMultiValue(SingleValue value) throws IOException {
     reset();
     getMultiValueInfo().deleteValue(value);
     return value;
   }
 
   @Override
   public UnsupportedValue addUnsupportedValue(Map<String,?> values)
     throws IOException
   {
     reset();
     UnsupportedValue v = UnsupportedColumnInfoImpl.newValue(this, values);
     getUnsupportedInfo().addValue(v);
     return v;
   }
 
   @Override
   public UnsupportedValuethmarketscience/jackcess/complex/UnsupportedValue.html#UnsupportedValue">UnsupportedValue updateUnsupportedValue(UnsupportedValue value)
     throws IOException
   {
     reset();
     getUnsupportedInfo().updateValue(value);
     return value;
   }
 
   @Override
   public UnsupportedValuethmarketscience/jackcess/complex/UnsupportedValue.html#UnsupportedValue">UnsupportedValue deleteUnsupportedValue(UnsupportedValue value)
     throws IOException
   {
     reset();
     getUnsupportedInfo().deleteValue(value);
     return value;
   }
 
   @Override
   public void deleteAllValues() throws IOException {
     reset();
     getComplexInfo().deleteAllValues(this);
   }
 
   @Override
   public boolean equals(Object o) {
     return(super.equals(o) &&
            (_column == ((ComplexValueForeignKeyImpl)o)._column));
   }
 
   private Object now() {
     Database db = getColumn().getDatabase();
     if(db.getDateTimeType() == DateTimeType.DATE) {
       return new Date();
     }
     return LocalDateTime.now(db.getZoneId());
   }
 }