/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.bestray.healthcarecommonutil.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.prefs.BackingStoreException;
import java.util.prefs.Preferences;

// TODO: Auto-generated Javadoc
/**
 * The Class PreferenceUtil.
 *
 * @author Girija Sahu
 */
public class PreferenceUtil {
   
// Max byte count is 3/4 max string length (see Preferences
  // documentation).
  /** The Constant pieceLength. */
static private final int pieceLength =
    ((3*Preferences.MAX_VALUE_LENGTH)/4);

  /**
   * Object2 bytes.
   *
   * @param o the o
   * @return the byte[]
   * @throws IOException Signals that an I/O exception has occurred.
   */
  static private byte[] object2Bytes( Object o ) throws IOException {
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream( baos );
    oos.writeObject( o );
    return baos.toByteArray();
  }

  /**
   * Break into pieces.
   *
   * @param raw the raw
   * @return the byte[][]
   */
  static private byte[][] breakIntoPieces( byte raw[] ) {
    int numPieces = (raw.length + pieceLength - 1) / pieceLength;
    byte pieces[][] = new byte[numPieces][];
    for (int i=0; i<numPieces; ++i) {
      int startByte = i * pieceLength;
      int endByte = startByte + pieceLength;
      if (endByte > raw.length) endByte = raw.length;
      int length = endByte - startByte;
      pieces[i] = new byte[length];
      System.arraycopy( raw, startByte, pieces[i], 0, length );
    }
    return pieces;
  }

  /**
   * Write pieces.
   *
   * @param prefs the prefs
   * @param key the key
   * @param pieces the pieces
   * @throws BackingStoreException the backing store exception
   */
  static private void writePieces( Preferences prefs, String key,
      byte pieces[][] ) throws BackingStoreException {
    Preferences node = prefs.node( key );
    node.clear();
    for (int i=0; i<pieces.length; ++i) {
      node.putByteArray( ""+i, pieces[i] );
    }
  }

  /**
   * Read pieces.
   *
   * @param prefs the prefs
   * @param key the key
   * @return the byte[][]
   * @throws BackingStoreException the backing store exception
   */
  static private byte[][] readPieces( Preferences prefs, String key )
      throws BackingStoreException {
    Preferences node = prefs.node( key );
    String keys[] = node.keys();
    int numPieces = keys.length;
    byte pieces[][] = new byte[numPieces][];
    for (int i=0; i<numPieces; ++i) {
      pieces[i] = node.getByteArray( ""+i, null );
    }
    return pieces;
  }

  /**
   * Combine pieces.
   *
   * @param pieces the pieces
   * @return the byte[]
   */
  static private byte[] combinePieces( byte pieces[][] ) {
    int length = 0;
    for (int i=0; i<pieces.length; ++i) {
      length += pieces[i].length;
    }
    byte raw[] = new byte[length];
    int cursor = 0;
    for (int i=0; i<pieces.length; ++i) {
      System.arraycopy( pieces[i], 0, raw, cursor, pieces[i].length );
      cursor += pieces[i].length;
    }
    return raw;
  }

  /**
   * Bytes2 object.
   *
   * @param raw the raw
   * @return the object
   * @throws IOException Signals that an I/O exception has occurred.
   * @throws ClassNotFoundException the class not found exception
   */
  static private Object bytes2Object( byte raw[] )
      throws IOException, ClassNotFoundException {
    ByteArrayInputStream bais = new ByteArrayInputStream( raw );
    ObjectInputStream ois = new ObjectInputStream( bais );
    Object o = ois.readObject();
    return o;
  }

  /**
   * Put object.
   *
   * @param prefs the prefs
   * @param key the key
   * @param o the o
   * @throws IOException Signals that an I/O exception has occurred.
   * @throws BackingStoreException the backing store exception
   * @throws ClassNotFoundException the class not found exception
   */
  static public void putObject( Preferences prefs, String key, Object o )
      throws IOException, BackingStoreException, ClassNotFoundException {
    byte raw[] = object2Bytes( o );
    byte pieces[][] = breakIntoPieces( raw );
    writePieces( prefs, key, pieces );
  }

  /**
   * Gets the object.
   *
   * @param prefs the prefs
   * @param key the key
   * @return the object
   * @throws IOException Signals that an I/O exception has occurred.
   * @throws BackingStoreException the backing store exception
   * @throws ClassNotFoundException the class not found exception
   */
  static public Object getObject( Preferences prefs, String key )
      throws IOException, BackingStoreException, ClassNotFoundException {
    byte pieces[][] = readPieces( prefs, key );
    byte raw[] = combinePieces( pieces );
    Object o = bytes2Object( raw );
    return o;
  }
}