/*

 Copyright (c) 2008 Health Market Science, Inc.

 This library is free software; you can redistribute it and/or

 modify it under the terms of the GNU Lesser General Public

 License as published by the Free Software Foundation; either

 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,

 but WITHOUT ANY WARRANTY; without even the implied warranty of

 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public

 License along with this library; if not, write to the Free Software

 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307

 USA

 You can contact Health Market Science at info@healthmarketscience.com

 or at the following address:

 Health Market Science

 2700 Horizon Drive

 Suite 200

 King of Prussia, PA 19406

 */

 package com.healthmarketscience.jackcess;

 import java.io.IOException;

 import java.util.List;

 /**

  * Simple implementation of an Access table index

  * @author Tim McCune

  */

 public class SimpleIndex extends Index {

   /** data for the single index page.  if this data came from multiple pages,

       the index is read-only. */

   private SimpleDataPage _dataPage;

   public SimpleIndex(Table table, int uniqueEntryCount,

                      int uniqueEntryCountOffset)

   {

     super(table, uniqueEntryCount, uniqueEntryCountOffset);

   }

   @Override

   protected void updateImpl() throws IOException {

     writeDataPage(_dataPage);

   }

   @Override

   protected void readIndexEntries()

     throws IOException

   {

     // find first leaf page

     int nextPageNumber = getRootPageNumber();

     SimpleDataPage indexPage = null;

     while(true) {

       indexPage = new SimpleDataPage(nextPageNumber);

       readDataPage(indexPage);

       if(!indexPage.isLeaf()) {

         // FIXME we can't modify this index at this point in time

         setReadOnly();

         // found another node page

         nextPageNumber = indexPage.getEntries().get(0).getSubPageNumber();

         indexPage = null;

       } else {

         // found first leaf

         break;

       }

     }

     // save the first leaf page

     _dataPage = indexPage;

     nextPageNumber = indexPage.getNextPageNumber();

     _dataPage.setNextPageNumber(INVALID_INDEX_PAGE_NUMBER);

     indexPage = null;

     // read all leaf pages.

     while(nextPageNumber != INVALID_INDEX_PAGE_NUMBER) {

       // FIXME we can't modify this index at this point in time

       setReadOnly();

       // found another one

       indexPage = new SimpleDataPage(nextPageNumber);

       readDataPage(indexPage);

       // since we read all the entries in sort order, we can insert them

       // directly into the entries list

       _dataPage.getEntries().addAll(indexPage.getEntries());

       int totalSize = (_dataPage.getTotalEntrySize() +

                        indexPage.getTotalEntrySize());

       _dataPage.setTotalEntrySize(totalSize);

       nextPageNumber = indexPage.getNextPageNumber();

     }

     // check the entry order, just to be safe

     List<Entry> entries = _dataPage.getEntries();

     for(int i = 0; i < (entries.size() - 1); ++i) {

       Entry e1 = entries.get(i);

       Entry e2 = entries.get(i + 1);

       if(e1.compareTo(e2) > 0) {

         throw new IOException("Unexpected order in index entries, " +

                               e1 + " is greater than " + e2);

       }

     }

   }

   @Override

   protected DataPage findDataPage(Entry entry)

     throws IOException

   {

     return _dataPage;

   }

   @Override

   protected DataPage getDataPage(int pageNumber)

     throws IOException

   {

     throw new UnsupportedOperationException();

   }

   /**

    * Simple implementation of a DataPage

    */

   private static final class SimpleDataPage extends DataPage {

     private final int _pageNumber;

     private boolean _leaf;

     private int _nextPageNumber;

     private int _totalEntrySize;

     private List<Entry> _entries;

     private SimpleDataPage(int pageNumber) {

       _pageNumber = pageNumber;

     }

     @Override

     public int getPageNumber() {

       return _pageNumber;

     }

     @Override

     public boolean isLeaf() {

       return _leaf;

     }

     @Override

     public void setLeaf(boolean isLeaf) {

       _leaf = isLeaf;

     }

     @Override

     public int getPrevPageNumber() { return 0; }

     @Override

     public void setPrevPageNumber(int pageNumber) {

       // ignored

     }

     @Override

     public int getNextPageNumber() {

       return _nextPageNumber;

     }

     @Override

     public void setNextPageNumber(int pageNumber) {

       _nextPageNumber = pageNumber;

     }

     @Override

     public int getChildTailPageNumber() { return 0; }

     @Override

     public void setChildTailPageNumber(int pageNumber) {

       // ignored

     }

     @Override

     public int getTotalEntrySize() {

       return _totalEntrySize;

     }

     @Override

     public void setTotalEntrySize(int totalSize) {

       _totalEntrySize = totalSize;

     }

     @Override

     public byte[] getEntryPrefix() {

       return EMPTY_PREFIX;

     }

     @Override

     public void setEntryPrefix(byte[] entryPrefix) {

       // ignored

     }

     @Override

     public List<Entry> getEntries() {

       return _entries;

     }

     @Override

     public void setEntries(List<Entry> entries) {

       _entries = entries;

     }

     @Override

     public void addEntry(int idx, Entry entry) {

       _entries.add(idx, entry);

       _totalEntrySize += entry.size();

     }

     @Override

     public void removeEntry(int idx) {

       Entry oldEntry = _entries.remove(idx);

       _totalEntrySize -= oldEntry.size();

     }

   }

 }