package basics.collections.index;

import java.util.Iterator;
import java.util.Set;
import basics.utl.NumUtl;

public abstract class HashedCharacterTreeBase
{

abstract HashNode<?> getRoot();

abstract void retrieveFuzzy(Collector results, HashNode<?> node, String term, int i, int size,
   int limit, int limit0, int r);

void retrieveFuzzy(Collector results, HashNode<?> root, String term, double likeness)
{
   int keylen = term.length();
   int limit = calcLimit(keylen, likeness);
   retrieveFuzzy(results, root, term, 0, keylen, limit, limit, 0);
}

boolean retrieveFuzzySet(Collector results, HashNode<?> node, String term, int i, int size,
   int limit, int limit0, int r)
{
   int matches = results.resultset.size();
   Set<String> morekeys = node.next.keySet();
   for(Iterator<String> mki = morekeys.iterator(); mki.hasNext();)
   {
      HashNode<?> altnode = (HashNode<?>)node.next.get(mki.next());
      retrieveFuzzy(results, altnode, term, i, size, limit, limit0, r + 1);
   }
   return matches < results.resultset.size();
}

HashNode<?> nextNode(String term, int i, int size, HashNode<?> currentNode)
{
   HashNode<?> next = null;
   if(i < size)
   {
      String c = term.substring(i, i + 1);
      next = (HashNode<?>)currentNode.next.get(c);
   }
   return next;
}

boolean matching(String term, int i, int size, int limit, HashNode<?> node, int r)
{
   return(i >= size && node.isMatch());
}

int calcLimit(int keylen, double likeness)
{
   if(likeness >= 1)
      return 0;
   return (int)NumUtl.round((((double)keylen) * (1D - likeness)), 0);
}

boolean deadNode(HashNode<?> node)
{
   return(node == null || node.next == null);
}

int flipflop(int n)
{
   return n % 2 == 0 ? n / 2 : (n + 1) / -2;
}

double matchRatio(String t, int initialLimit, int limit, int size, int depth)
{
   double diff = (double)(Math.abs(depth - size) + (initialLimit - limit));
   return NumUtl.round(1D - (diff / size), 5);
}
}