/**
 *  IndexTable
 *  Copyright 2014 by Michael Peter Christen
 *  First released 11.11.2014 at http://yacy.net
 *
 *  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 program in the file lgpl21.txt
 *  If not, see <http://www.gnu.org/licenses/>.
 */

package net.yacy.kelondro.table;

import java.io.File;
import java.io.IOException;

import net.yacy.cora.order.NaturalOrder;
import net.yacy.cora.util.SpaceExceededException;
import net.yacy.kelondro.index.Row;
import net.yacy.kelondro.util.kelondroException;

/**
 * this is a stored index for primary keys. Each key is associated to a single long value
 */
public class IndexTable {

    private final Table table;

    /**
     * create an index with given (fixed) key and value length 
     * @param location
     * @param keysize
     * @param payloadsize
     * @param useTailCache
     * @param exceed134217727
     * @throws IOException
     */
    public IndexTable(
            final File location, int keysize, int payloadsize,
            final boolean useTailCache,
            final boolean exceed134217727) throws IOException {
        final Row row = new Row(
                "byte[] key-" + keysize + ", " +
                "long num-" + payloadsize + " {b256}",
                NaturalOrder.naturalOrder);
        Table t;
        try {
            t = new Table(location, row, 1024*1024, 0, useTailCache, exceed134217727, true);
        } catch (final SpaceExceededException e) {
            try {
                t = new Table(location, row, 0, 0, false, exceed134217727, true);
            } catch (kelondroException | SpaceExceededException e1) {
                throw new IOException(e);
            }
        }
        this.table = t;
    }

    /**
     * Write an index entry. All written values are persistent.
     * @param key
     * @param value
     * @return
     * @throws IOException
     */
    public Long put(final byte[] key, final long value) throws IOException {
        final Row.Entry entry = table.row().newEntry();
        entry.setCol(0, key);
        entry.setCol(1, value);
        Row.Entry oldentry;
        try {
            oldentry = table.replace(entry);
            if (oldentry == null) return null;
            return oldentry.getColLong(1);
        } catch (SpaceExceededException e) {
            throw new IOException(e);
        }
    }

    /**
     * get a value from the index
     * @param key
     * @return the value of the relation or -1 if that does not exist
     * @throws IOException
     */
    public long get(final byte[] key) throws IOException {
        final Row.Entry entry = table.get(key, false);
        if (entry == null) return -1;
        Long l = entry.getColLong(1);
        return l == null ? -1 : l.longValue();
    }
    
    /**
     * check if a given value exists in the index. The check is very efficient because all operations are done in the RAM.
     * @param key
     * @return true if the key already existed, false otherwise
     */
    public boolean has(final byte[] key) {
        return table.has(key);
    }

    /**
     * remove a given key from the index
     * @param key
     * @return the previous value of the relation
     * @throws IOException
     */
    public Long remove(final byte[] key) throws IOException {
        final Row.Entry entry = table.remove(key);
        if (entry == null) return null;
        return entry.getColLong(1);
    }

    /**
     * clear the index
     * @throws IOException
     */
    public void clear() throws IOException {
        this.table.clear();
    }
    
    /**
     * close the index. must be called to finally write all data to disc
     */
    public void close() {
        this.table.close();
    }
}