package dictionary;

import arraylist.ArrayIndexList;
import arraylist.IndexList;
import exceptions.HashExceptionKey;
import exceptions.InvalidEntryException;
import position.NodePositionList;
import position.PositionList;
import priorityqueue.Entry;
import priorityqueue.MyEntry;
import sun.rmi.log.ReliableLog;

import java.security.InvalidKeyException;
import java.util.Iterator;

/**
 * Created with MONSTER.
 * User: xgiovio
 * Date: 11/05/2014
 * Time: 19:28
 */
public class HashDictionaryChaining <K,V> implements Dictionary<K,V> {

        IndexList<Logfile<K,V>> table = null;
        Logfile<K,V> AVAIBLE = null;
        int avaible_slots = 0;
        int elements = 0;

    public HashDictionaryChaining ( Logfile<K,V> IN_AVAIBLE, int in_size){
        table = new ArrayIndexList<Logfile<K, V>>(in_size);
        AVAIBLE = IN_AVAIBLE;

        for (int i= 0 ; i< in_size ;i++){
            table.add(i,AVAIBLE);
            avaible_slots ++;
        }
    }

    public   float load_factor () throws InvalidKeyException{
        float ret =  (size() / (float)raw_size());
        if ( ret >= 0.9 ) {
            reformat();
            return load_factor();
        }
        return ret;
    }

    public  int raw_size (){
        return table.size();
    }

    @Override
    public int size() {
        return elements;
    }

    @Override
    public boolean isEmpty() {
        return (size() == 0);
    }

    protected int hash ( K key, int size){

        if (  (key instanceof String) )
            return com.xgiovio.hash.functions.hash_horner( (String)key ,size );
        throw new HashExceptionKey();
    }


    @Override
    public Entry<K, V> find(K key) throws InvalidKeyException {

            checkKey(key);
            int h = hash(key, raw_size());
            if (table.get(h) == AVAIBLE)
                return null;
            Logfile<K, V> n = table.get(h);
            return n.find(key);
    }

    @Override
    public Iterable<Entry<K, V>> findAll(K key) throws InvalidKeyException {
        checkKey(key);
        int h = hash(key,raw_size());
        if (table.get(h) == AVAIBLE)
            return null;
        Logfile<K, V> n = table.get(h);
        return n.entries();
    }

    @Override
    public Entry<K, V> insert(K key, V value) throws InvalidKeyException {
             checkKey(key);
             if (load_factor() >= 0.9 )
                 reformat();
             int h = hash(key,raw_size());
             if (table.get(h) == AVAIBLE) {
                 Logfile<K, V> n = new Logfile<K, V>();
                 table.set(h,n);
                 avaible_slots--;
                 elements++;
                 return n.insert(key,value);
             } else {
                 Logfile<K, V> n = table.get(h);
                 elements++;
                 return n.insert(key,value);
             }
    }

    @Override
    public Entry<K, V> remove(Entry<K, V> e) throws InvalidEntryException {
        if (e == null)
            throw new InvalidEntryException();
        int h = hash(e.getKey(),raw_size());
        if (table.get(h) == AVAIBLE)
            throw new InvalidEntryException();
        Logfile<K, V> n = table.get(h);
        Entry<K,V> t =  n.remove(e);
        elements--;
        if (n.size() == 0){
            table.set(h,AVAIBLE);
            avaible_slots++;
        }
       return t;
    }

    @Override
    public Iterable<Entry<K, V>> entries() {

        NodePositionList<Entry<K,V>> ret = new NodePositionList<Entry<K, V>>();

        for (int i = 0 ; i< raw_size() ;i++){
            if (table.get(i) != AVAIBLE){
                Iterator<Entry<K,V>> local_it = table.get(i).entries().iterator();
                for (;local_it.hasNext();){
                    ret.addLast(local_it.next());
                }
            }

        }
        return ret;
    }


    protected void checkKey(K key) throws InvalidKeyException {
        if (key == null )
            throw new InvalidKeyException("Invalid key");
    }


    void reformat () throws InvalidKeyException{

        Iterable<Entry<K,V>> ite = entries();
        int new_size = raw_size() * 2;
        IndexList<Logfile<K,V>>  table2 = new ArrayIndexList<Logfile<K, V>>(new_size);
        avaible_slots = 0;
        elements = 0;

        for (int i= 0 ; i< (new_size) ;i++){
            table2.add(i,AVAIBLE);
        }
        table = table2;

        for (Entry<K,V> e : ite){
            insert(e.getKey(),e.getValue());

        }
    }


    public String toString() {

        Iterator<Entry<K,V>> it = entries().iterator();

        String to_return = "";
        to_return = to_return + "[";

        for (;it.hasNext();){
            Entry<K,V>  t = it.next();

            if (it.hasNext())  {

                to_return+=(t.toString() + " , ");
            }    else {

                to_return+=(t.toString());
            }
        }

        return to_return+= "]";
    }
}