/*
    *  Copyright 2009-2013 Stephen Colebourne
    *
    *  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 org.joda.money;
  
  import java.io.Externalizable;
  import java.io.IOException;
  import java.io.InvalidClassException;
  import java.io.InvalidObjectException;
  import java.io.ObjectInput;
  import java.io.ObjectOutput;
  import java.io.StreamCorruptedException;
  import java.math.BigDecimal;
  import java.math.BigInteger;
  
  /**
   * A package scoped class used to manage serialization efficiently.
   * <p>
   * This class is mutable and intended for use by a single thread.
   */
  final class Ser implements Externalizable {
  
      /** Type for BigMoney. */
      static final byte BIG_MONEY = 'B';
      /** Type for Money. */
      static final byte MONEY = 'M';
      /** Type for CurrencyUnit. */
      static final byte CURRENCY_UNIT = 'C';  // not in use yet
  
      /** The type. */
      private byte type;
      /** The data object. */
      private Object object;
  
      /**
       * Constructor for serialization.
       */
      public Ser() {
      }
  
      /**
       * Constructor for package.
       * 
       * @param type  the type
       * @param object  the object
       */
      Ser(byte type, Object object) {
          this.type = type;
          this.object = object;
      }
  
      //-----------------------------------------------------------------------
      /**
       * Outputs the data.
       *
       * @serialData One byte type code, then data specific to the type.
       * @param out  the output stream
       * @throws IOException if an error occurs
       */
      public void writeExternal(ObjectOutput out) throws IOException {
          out.writeByte(type);
          switch (type) {
              case BIG_MONEY: {
                  BigMoney obj = (BigMoney) object;
                  writeBigMoney(out, obj);
                  return;
              }
              case MONEY: {
                  Money obj = (Money) object;
                  writeBigMoney(out, obj.toBigMoney());
                  return;
              }
              case CURRENCY_UNIT: {
                  CurrencyUnit obj = (CurrencyUnit) object;
                  writeCurrency(out, obj);
                  return;
              }
          }
          throw new InvalidClassException("Joda-Money bug: Serialization broken");
      }
  
      private void writeBigMoney(ObjectOutput out, BigMoney obj) throws IOException {
          writeCurrency(out, obj.getCurrencyUnit());
          byte[] bytes = obj.getAmount().unscaledValue().toByteArray();
          out.writeInt(bytes.length);
          out.write(bytes);
          out.writeInt(obj.getScale());
     }
 
     private void writeCurrency(ObjectOutput out, CurrencyUnit obj) throws IOException {
         out.writeUTF(obj.getCode());
         out.writeShort(obj.getNumericCode());
         out.writeShort(obj.getDefaultFractionDigits());
     }
 
     /**
      * Outputs the data.
      *
      * @param in  the input stream
      * @throws IOException if an error occurs
      */
     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
         type = in.readByte();
         switch (type) {
             case BIG_MONEY: {
                 object = readBigMoney(in);
                 return;
             }
             case MONEY: {
                 object = new Money(readBigMoney(in));
                 return;
             }
             case CURRENCY_UNIT: {
                 object = readCurrency(in);
                 return;
             }
         }
         throw new StreamCorruptedException("Serialization input has invalid type");
     }
 
     private BigMoney readBigMoney(ObjectInput in) throws IOException {
         CurrencyUnit currency = readCurrency(in);
         byte[] bytes = new byte[in.readInt()];
         in.readFully(bytes);
         BigDecimal bd = new BigDecimal(new BigInteger(bytes), in.readInt());
         BigMoney bigMoney = new BigMoney(currency, bd);
         return bigMoney;
     }
 
     private CurrencyUnit readCurrency(ObjectInput in) throws IOException {
         String code = in.readUTF();
         CurrencyUnit singletonCurrency = CurrencyUnit.of(code);
         if (singletonCurrency.getNumericCode() != in.readShort()) {
             throw new InvalidObjectException("Deserialization found a mismatch in the numeric code for currency " + code);
         }
         if (singletonCurrency.getDefaultFractionDigits() != in.readShort()) {
             throw new InvalidObjectException("Deserialization found a mismatch in the decimal places for currency " + code);
         }
         return singletonCurrency;
     }
 
     /**
      * Returns the object that will replace this one.
      * 
      * @return the read object, should never be null
      */
     private Object readResolve() {
         return object;
     }
 
 }