/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package opennlp.tools.disambiguator.lesk;

import java.security.InvalidParameterException;
import java.util.ArrayList;
import java.util.Collections;

import opennlp.tools.disambiguator.Constants;
import opennlp.tools.disambiguator.Loader;
import opennlp.tools.disambiguator.Node;
import opennlp.tools.disambiguator.PreProcessor;
import opennlp.tools.disambiguator.WSDParameters;
import opennlp.tools.disambiguator.WSDisambiguator;
import opennlp.tools.disambiguator.WordPOS;
import opennlp.tools.disambiguator.WordSense;
import opennlp.tools.util.Span;
import net.sf.extjwnl.data.Synset;

/**
 * Implementation of the <b>Overlap Of Senses</b> approach originally proposed by Lesk.
 * The main idea is to check for word overlaps in the sense definitions of the surrounding context. 
 * An overlap is when two words have similar stems.
 * The more overlaps a word has the higher its score.
 * Different variations of the approach are included in this class.
 * 
 */
public class Lesk implements WSDisambiguator {

  /**
   * The lesk specific parameters
   */
  protected LeskParameters params;
  
  public Lesk() {
    this(null);
  }

  /**
   * Initializes the loader object and sets the input parameters
   * @param Input Parameters
   * @throws InvalidParameterException
   */
  public Lesk(LeskParameters params) throws InvalidParameterException {
    Loader loader = new Loader();
    this.setParams(params);
  }
  

  /**
   * If the parameters are null set the default ones, else only set them if they valid.
   * Invalid parameters will return a exception
   * 
   * @param Input parameters
   * @throws InvalidParameterException
   */
  @Override
  public void setParams(WSDParameters params) throws InvalidParameterException {
    if (params == null) {
      this.params = new LeskParameters();
    } else {
      if (params.isValid()) {
        this.params = (LeskParameters) params;
      } else {
        throw new InvalidParameterException("wrong params");
      }
    }
  }

  /** 
   * @return the parameter settings
   */
  public LeskParameters getParams() {
    return params;
  }

  /**
   * The basic Lesk method where the entire context is considered for overlaps
   * 
   * @param The word to disambiguate 
   * @return The array of WordSenses with their scores
   */
  public ArrayList<WordSense> basic(WTDLesk wtd) {

    ArrayList<WordPOS> relvWords = PreProcessor.getAllRelevantWords(wtd);
    WordPOS word = new WordPOS(wtd.getWord(), Constants.getPOS(wtd.getPosTag()));

    ArrayList<Synset> synsets = word.getSynsets();
    ArrayList<Node> nodes = new ArrayList<Node>();

    for (Synset synset : synsets) {
      Node node = new Node(synset, relvWords);
      nodes.add(node);
    }

    ArrayList<WordSense> scoredSenses = updateSenses(nodes);

    for (WordSense wordSense : scoredSenses) {
      wordSense.setWTDLesk(wtd);
      int count = 0;
      for (WordPOS senseWordPOS : wordSense.getNode().getSenseRelevantWords()) {
        ArrayList stems = (ArrayList) PreProcessor.Stem(senseWordPOS);
        for (WordPOS sentenceWordPOS : relvWords) {
          // TODO change to lemma check
          if (sentenceWordPOS.isStemEquivalent(senseWordPOS)) {
            count = count + 1;
          }
        }
      }
      wordSense.setScore(count);
    }

    return scoredSenses;
  }

  /**
   * The basic Lesk method but applied to a default context windows
   * @param The word to disambiguate 
   * @return The array of WordSenses with their scores
   */
  public ArrayList<WordSense> basicContextual(WTDLesk wtd) {
    return this.basicContextual(wtd, LeskParameters.DFLT_WIN_SIZE);
  }

  /**
   * The basic Lesk method but applied to a custom context windows
   * @param The word to disambiguate 
   * @param windowSize
   * @return The array of WordSenses with their scores
   */
  public ArrayList<WordSense> basicContextual(WTDLesk wtd, int windowSize) {
    return this.basicContextual(wtd, windowSize, windowSize);
  }

  /**
   * The basic Lesk method but applied to a context windows set by custom backward and forward window lengths
   * @param wtd the word to disambiguate 
   * @param windowBackward 
   * @return the array of WordSenses with their scores
   */
  public ArrayList<WordSense> basicContextual(WTDLesk wtd, int windowBackward,
      int windowForward) {

    ArrayList<WordPOS> relvWords = PreProcessor.getRelevantWords(wtd,
        windowBackward, windowForward);
    WordPOS word = new WordPOS(wtd.getWord(), Constants.getPOS(wtd.getPosTag()));

    ArrayList<Synset> synsets = word.getSynsets();
    ArrayList<Node> nodes = new ArrayList<Node>();

    for (Synset synset : synsets) {
      Node node = new Node(synset, relvWords);
      nodes.add(node);
    }

    ArrayList<WordSense> scoredSenses = updateSenses(nodes);

    for (WordSense wordSense : scoredSenses) {
      wordSense.setWTDLesk(wtd);

      int count = 0;
      for (WordPOS senseWordPOS : wordSense.getNode().getSenseRelevantWords()) {

        for (WordPOS sentenceWordPOS : relvWords) {
          // TODO change to lemma check
          if (sentenceWordPOS.isStemEquivalent(senseWordPOS)) {
            count = count + 1;
          }
        }

      }
      wordSense.setScore(count);

    }

    Collections.sort(scoredSenses);

    return scoredSenses;
  }

  /**
   * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps across the entire context
   * The scoring function uses linear weights.
   * @param wtd the word to disambiguate
   * @param depth how deep to go into each feature tree
   * @param depthScoreWeight the weighing per depth level
   * @param includeSynonyms
   * @param includeHypernyms
   * @param includeHyponyms
   * @param includeMeronyms
   * @param includeHolonyms
   * @return the array of WordSenses with their scores
   */
  public ArrayList<WordSense> extended(WTDLesk wtd, int depth,
      double depthScoreWeight, boolean includeSynonyms,
      boolean includeHypernyms, boolean includeHyponyms,
      boolean includeMeronyms, boolean includeHolonyms) {

    return extendedContextual(wtd, 0, depth, depthScoreWeight, includeSynonyms,
        includeHypernyms, includeHyponyms, includeMeronyms, includeHolonyms);

  }

  /**
   * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a default context window
   * The scoring function uses linear weights.
   * @param wtd the word to disambiguate 
   * @param depth how deep to go into each feature tree
   * @param depthScoreWeight the weighing per depth level
   * @param includeSynonyms
   * @param includeHypernyms
   * @param includeHyponyms
   * @param includeMeronyms
   * @param includeHolonyms
   * @return the array of WordSenses with their scores
   */
  public ArrayList<WordSense> extendedContextual(WTDLesk wtd, int depth,
      double depthScoreWeight, boolean includeSynonyms,
      boolean includeHypernyms, boolean includeHyponyms,
      boolean includeMeronyms, boolean includeHolonyms) {

    return extendedContextual(wtd, LeskParameters.DFLT_WIN_SIZE, depth,
        depthScoreWeight, includeSynonyms, includeHypernyms, includeHyponyms,
        includeMeronyms, includeHolonyms);

  }

  /**
   * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a custom context window
   * The scoring function uses linear weights.
   * @param wtd the word to disambiguate 
   * @param windowSize the custom context window size
   * @param depth how deep to go into each feature tree
   * @param depthScoreWeight the weighing per depth level
   * @param includeSynonyms
   * @param includeHypernyms
   * @param includeHyponyms
   * @param includeMeronyms
   * @param includeHolonyms
   * @return the array of WordSenses with their scores
   */
  public ArrayList<WordSense> extendedContextual(WTDLesk wtd, int windowSize,
      int depth, double depthScoreWeight, boolean includeSynonyms,
      boolean includeHypernyms, boolean includeHyponyms,
      boolean includeMeronyms, boolean includeHolonyms) {

    return extendedContextual(wtd, windowSize, windowSize, depth,
        depthScoreWeight, includeSynonyms, includeHypernyms, includeHyponyms,
        includeMeronyms, includeHolonyms);
  }


  /**
   * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a custom context window
   * The scoring function uses linear weights.
   * @param wtd the word to disambiguate 
   * @param windowBackward the custom context backward window size
   * @param windowForward the custom context forward window size
   * @param depth how deep to go into each feature tree
   * @param depthScoreWeight the weighing per depth level
   * @param includeSynonyms
   * @param includeHypernyms
   * @param includeHyponyms
   * @param includeMeronyms
   * @param includeHolonyms
   * @return the array of WordSenses with their scores
   */
  public ArrayList<WordSense> extendedContextual(WTDLesk wtd,
      int windowBackward, int windowForward, int depth,
      double depthScoreWeight, boolean includeSynonyms,
      boolean includeHypernyms, boolean includeHyponyms,
      boolean includeMeronyms, boolean includeHolonyms) {

    ArrayList<WordPOS> relvWords = PreProcessor.getRelevantWords(wtd,
        windowBackward, windowForward);
    WordPOS word = new WordPOS(wtd.getWord(), Constants.getPOS(wtd.getPosTag()));

    ArrayList<Synset> synsets = word.getSynsets();
    ArrayList<Node> nodes = new ArrayList<Node>();

    for (Synset synset : synsets) {
      Node node = new Node(synset, relvWords);
      nodes.add(node);
    }

    ArrayList<WordSense> scoredSenses = basicContextual(wtd, windowBackward,
        windowForward);

    for (WordSense wordSense : scoredSenses) {

      if (includeSynonyms) {
        wordSense.setScore(wordSense.getScore() + depthScoreWeight
            * assessSynonyms(wordSense.getNode().getSynonyms(), relvWords));
      }

      if (includeHypernyms) {
        fathomHypernyms(wordSense, wordSense.getNode().synset, relvWords,
            depth, depth, depthScoreWeight);
      }

      if (includeHyponyms) {

        fathomHyponyms(wordSense, wordSense.getNode().synset, relvWords, depth,
            depth, depthScoreWeight);
      }

      if (includeMeronyms) {

        fathomMeronyms(wordSense, wordSense.getNode().synset, relvWords, depth,
            depth, depthScoreWeight);

      }

      if (includeHolonyms) {

        fathomHolonyms(wordSense, wordSense.getNode().synset, relvWords, depth,
            depth, depthScoreWeight);

      }

    }

    return scoredSenses;

  }

  
  /**
   * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in all the context.
   * The scoring function uses exponential weights.
   * @param wtd the word to disambiguate 
   * @param depth how deep to go into each feature tree
   * @param intersectionExponent
   * @param depthExponent
   * @param includeSynonyms
   * @param includeHypernyms
   * @param includeHyponyms
   * @param includeMeronyms
   * @param includeHolonyms
   * @return the array of WordSenses with their scores
   */
  public ArrayList<WordSense> extendedExponential(WTDLesk wtd, int depth,
      double intersectionExponent, double depthExponent,
      boolean includeSynonyms, boolean includeHypernyms,
      boolean includeHyponyms, boolean includeMeronyms, boolean includeHolonyms) {

    return extendedExponentialContextual(wtd, 0, depth, intersectionExponent,
        depthExponent, includeSynonyms, includeHypernyms, includeHyponyms,
        includeMeronyms, includeHolonyms);

  }
  
  /**
   * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a default window in the context.
   * The scoring function uses exponential weights.
   * @param wtd the word to disambiguate 
   * @param depth how deep to go into each feature tree
   * @param intersectionExponent
   * @param depthExponent
   * @param includeSynonyms
   * @param includeHypernyms
   * @param includeHyponyms
   * @param includeMeronyms
   * @param includeHolonyms
   * @return the array of WordSenses with their scores
   */
  public ArrayList<WordSense> extendedExponentialContextual(WTDLesk wtd,
      int depth, double intersectionExponent, double depthExponent,
      boolean includeSynonyms, boolean includeHypernyms,
      boolean includeHyponyms, boolean includeMeronyms, boolean includeHolonyms) {

    return extendedExponentialContextual(wtd, LeskParameters.DFLT_WIN_SIZE,
        depth, intersectionExponent, depthExponent, includeSynonyms,
        includeHypernyms, includeHyponyms, includeMeronyms, includeHolonyms);
  }
  
  /**
   * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a custom window in the context.
   * The scoring function uses exponential weights.
   * @param wtd the word to disambiguate 
   * @param windowSize 
   * @param depth how deep to go into each feature tree
   * @param intersectionExponent
   * @param depthExponent
   * @param includeSynonyms
   * @param includeHypernyms
   * @param includeHyponyms
   * @param includeMeronyms
   * @param includeHolonyms
   * @return the array of WordSenses with their scores
   */
  public ArrayList<WordSense> extendedExponentialContextual(WTDLesk wtd,
      int windowSize, int depth, double intersectionExponent,
      double depthExponent, boolean includeSynonyms, boolean includeHypernyms,
      boolean includeHyponyms, boolean includeMeronyms, boolean includeHolonyms) {

    return extendedExponentialContextual(wtd, windowSize, windowSize, depth,
        intersectionExponent, depthExponent, includeSynonyms, includeHypernyms,
        includeHyponyms, includeMeronyms, includeHolonyms);
  }

  /**
   * An extended version of the Lesk approach that takes into consideration semantically related feature overlaps in a custom window in the context.
   * The scoring function uses exponential weights.
   * @param wtd the word to disambiguate 
   * @param windowBackward
   * @param windowForward
   * @param depth
   * @param intersectionExponent
   * @param depthExponent
   * @param includeSynonyms
   * @param includeHypernyms
   * @param includeHyponyms
   * @param includeMeronyms
   * @param includeHolonyms
   * @return the array of WordSenses with their scores
   */
  public ArrayList<WordSense> extendedExponentialContextual(WTDLesk wtd,
      int windowBackward, int windowForward, int depth,
      double intersectionExponent, double depthExponent,
      boolean includeSynonyms, boolean includeHypernyms,
      boolean includeHyponyms, boolean includeMeronyms, boolean includeHolonyms) {
    ArrayList<WordPOS> relvWords = PreProcessor.getRelevantWords(wtd,
        windowBackward, windowForward);
    WordPOS word = new WordPOS(wtd.getWord(), Constants.getPOS(wtd.getPosTag()));

    ArrayList<Synset> synsets = word.getSynsets();
    ArrayList<Node> nodes = new ArrayList<Node>();

    for (Synset synset : synsets) {
      Node node = new Node(synset, relvWords);
      nodes.add(node);
    }

    ArrayList<WordSense> scoredSenses = basicContextual(wtd, windowForward,
        windowBackward);

    for (WordSense wordSense : scoredSenses) {

      if (includeSynonyms) {
        wordSense.setScore(wordSense.getScore()
            + Math.pow(
                assessSynonyms(wordSense.getNode().getSynonyms(), relvWords),
                intersectionExponent));
      }

      if (includeHypernyms) {
        fathomHypernymsExponential(wordSense, wordSense.getNode().synset,
            relvWords, depth, depth, intersectionExponent, depthExponent);
      }

      if (includeHyponyms) {

        fathomHyponymsExponential(wordSense, wordSense.getNode().synset,
            relvWords, depth, depth, intersectionExponent, depthExponent);
      }

      if (includeMeronyms) {

        fathomMeronymsExponential(wordSense, wordSense.getNode().synset,
            relvWords, depth, depth, intersectionExponent, depthExponent);

      }

      if (includeHolonyms) {

        fathomHolonymsExponential(wordSense, wordSense.getNode().synset,
            relvWords, depth, depth, intersectionExponent, depthExponent);

      }

    }

    return scoredSenses;

  }

  /**
   * Recursively score the hypernym tree linearly
   * @param wordSense
   * @param child
   * @param relvWords
   * @param depth
   * @param maxDepth
   * @param depthScoreWeight
   */
  private void fathomHypernyms(WordSense wordSense, Synset child,
      ArrayList<WordPOS> relvWords, int depth, int maxDepth,
      double depthScoreWeight) {
    if (depth == 0)
      return;

    String[] tokenizedGloss = Loader.getTokenizer().tokenize(
        child.getGloss().toString());
    ArrayList<WordPOS> relvGlossWords = PreProcessor
        .getAllRelevantWords(tokenizedGloss);

    Node childNode = new Node(child, relvGlossWords);

    childNode.setHypernyms();
    wordSense.setScore(wordSense.getScore()
        + Math.pow(depthScoreWeight, maxDepth - depth + 1)
        * assessFeature(childNode.getHypernyms(), relvWords));
    for (Synset hypernym : childNode.getHypernyms()) {
      fathomHypernyms(wordSense, hypernym, relvGlossWords, depth - 1, maxDepth,
          depthScoreWeight);
    }
  }

  /**
   * Recursively score the hypernym tree exponentially 
   * @param wordSense
   * @param child
   * @param relvWords
   * @param depth
   * @param maxDepth
   * @param intersectionExponent
   * @param depthScoreExponent
   */
  private void fathomHypernymsExponential(WordSense wordSense, Synset child,
      ArrayList<WordPOS> relvWords, int depth, int maxDepth,
      double intersectionExponent, double depthScoreExponent) {
    if (depth == 0)
      return;

    String[] tokenizedGloss = Loader.getTokenizer().tokenize(
        child.getGloss().toString());
    ArrayList<WordPOS> relvGlossWords = PreProcessor
        .getAllRelevantWords(tokenizedGloss);

    Node childNode = new Node(child, relvGlossWords);

    childNode.setHypernyms();
    wordSense.setScore(wordSense.getScore()
        + Math.pow(assessFeature(childNode.getHypernyms(), relvWords),
            intersectionExponent) / Math.pow(depth, depthScoreExponent));
    for (Synset hypernym : childNode.getHypernyms()) {

      fathomHypernymsExponential(wordSense, hypernym, relvGlossWords,
          depth - 1, maxDepth, intersectionExponent, depthScoreExponent);
    }
  }

  /**
   * Recursively score the hyponym tree linearly
   * @param wordSense
   * @param child
   * @param relvWords
   * @param depth
   * @param maxDepth
   * @param depthScoreWeight
   */
  private void fathomHyponyms(WordSense wordSense, Synset child,
      ArrayList<WordPOS> relvWords, int depth, int maxDepth,
      double depthScoreWeight) {
    if (depth == 0)
      return;

    String[] tokenizedGloss = Loader.getTokenizer().tokenize(
        child.getGloss().toString());
    ArrayList<WordPOS> relvGlossWords = PreProcessor
        .getAllRelevantWords(tokenizedGloss);

    Node childNode = new Node(child, relvGlossWords);

    childNode.setHyponyms();
    wordSense.setScore(wordSense.getScore()
        + Math.pow(depthScoreWeight, maxDepth - depth + 1)
        * assessFeature(childNode.getHyponyms(), relvWords));
    for (Synset hyponym : childNode.getHyponyms()) {

      fathomHyponyms(wordSense, hyponym, relvGlossWords, depth - 1, maxDepth,
          depthScoreWeight);
    }
  }

  /**
   * Recursively score the hyponym tree exponentially
   * @param wordSense
   * @param child
   * @param relvWords
   * @param depth
   * @param maxDepth
   * @param intersectionExponent
   * @param depthScoreExponent
   */
  private void fathomHyponymsExponential(WordSense wordSense, Synset child,
      ArrayList<WordPOS> relvWords, int depth, int maxDepth,
      double intersectionExponent, double depthScoreExponent) {
    if (depth == 0)
      return;

    String[] tokenizedGloss = Loader.getTokenizer().tokenize(
        child.getGloss().toString());
    ArrayList<WordPOS> relvGlossWords = PreProcessor
        .getAllRelevantWords(tokenizedGloss);

    Node childNode = new Node(child, relvGlossWords);

    childNode.setHyponyms();
    wordSense.setScore(wordSense.getScore()
        + Math.pow(assessFeature(childNode.getHyponyms(), relvWords),
            intersectionExponent) / Math.pow(depth, depthScoreExponent));
    for (Synset hyponym : childNode.getHyponyms()) {

      fathomHyponymsExponential(wordSense, hyponym, relvGlossWords, depth - 1,
          maxDepth, intersectionExponent, depthScoreExponent);
    }
  }

  /**
   * Recursively score the meronym tree linearly
   * @param wordSense
   * @param child
   * @param relvWords
   * @param depth
   * @param maxDepth
   * @param depthScoreWeight
   */
  private void fathomMeronyms(WordSense wordSense, Synset child,
      ArrayList<WordPOS> relvWords, int depth, int maxDepth,
      double depthScoreWeight) {
    if (depth == 0)
      return;

    String[] tokenizedGloss = Loader.getTokenizer().tokenize(
        child.getGloss().toString());
    ArrayList<WordPOS> relvGlossWords = PreProcessor
        .getAllRelevantWords(tokenizedGloss);

    Node childNode = new Node(child, relvGlossWords);

    childNode.setMeronyms();
    wordSense.setScore(wordSense.getScore()
        + Math.pow(depthScoreWeight, maxDepth - depth + 1)
        * assessFeature(childNode.getMeronyms(), relvWords));
    for (Synset meronym : childNode.getMeronyms()) {

      fathomMeronyms(wordSense, meronym, relvGlossWords, depth - 1, maxDepth,
          depthScoreWeight);
    }
  }

  /**
   * Recursively score the meronym tree exponentially
   * @param wordSense
   * @param child
   * @param relvWords
   * @param depth
   * @param maxDepth
   * @param intersectionExponent
   * @param depthScoreExponent
   */
  private void fathomMeronymsExponential(WordSense wordSense, Synset child,
      ArrayList<WordPOS> relvWords, int depth, int maxDepth,
      double intersectionExponent, double depthScoreExponent) {
    if (depth == 0)
      return;

    String[] tokenizedGloss = Loader.getTokenizer().tokenize(
        child.getGloss().toString());
    ArrayList<WordPOS> relvGlossWords = PreProcessor
        .getAllRelevantWords(tokenizedGloss);

    Node childNode = new Node(child, relvGlossWords);

    childNode.setMeronyms();
    wordSense.setScore(wordSense.getScore()
        + Math.pow(assessFeature(childNode.getMeronyms(), relvWords),
            intersectionExponent) / Math.pow(depth, depthScoreExponent));
    for (Synset meronym : childNode.getMeronyms()) {

      fathomMeronymsExponential(wordSense, meronym, relvGlossWords, depth - 1,
          maxDepth, intersectionExponent, depthScoreExponent);
    }
  }

  /**
   * Recursively score the holonym tree linearly
   * @param wordSense
   * @param child
   * @param relvWords
   * @param depth
   * @param maxDepth
   * @param depthScoreWeight
   */
  private void fathomHolonyms(WordSense wordSense, Synset child,
      ArrayList<WordPOS> relvWords, int depth, int maxDepth,
      double depthScoreWeight) {
    if (depth == 0)
      return;

    String[] tokenizedGloss = Loader.getTokenizer().tokenize(
        child.getGloss().toString());
    ArrayList<WordPOS> relvGlossWords = PreProcessor
        .getAllRelevantWords(tokenizedGloss);

    Node childNode = new Node(child, relvGlossWords);

    childNode.setHolonyms();
    wordSense.setScore(wordSense.getScore()
        + Math.pow(depthScoreWeight, maxDepth - depth + 1)
        * assessFeature(childNode.getHolonyms(), relvWords));
    for (Synset holonym : childNode.getHolonyms()) {

      fathomHolonyms(wordSense, holonym, relvGlossWords, depth - 1, maxDepth,
          depthScoreWeight);
    }
  }

  /**
   * Recursively score the holonym tree exponentially
   * @param wordSense
   * @param child
   * @param relvWords
   * @param depth
   * @param maxDepth
   * @param intersectionExponent
   * @param depthScoreExponent
   */
  private void fathomHolonymsExponential(WordSense wordSense, Synset child,
      ArrayList<WordPOS> relvWords, int depth, int maxDepth,
      double intersectionExponent, double depthScoreExponent) {
    if (depth == 0)
      return;

    String[] tokenizedGloss = Loader.getTokenizer().tokenize(
        child.getGloss().toString());
    ArrayList<WordPOS> relvGlossWords = PreProcessor
        .getAllRelevantWords(tokenizedGloss);

    Node childNode = new Node(child, relvGlossWords);

    childNode.setHolonyms();
    wordSense.setScore(wordSense.getScore()
        + Math.pow(assessFeature(childNode.getHolonyms(), relvWords),
            intersectionExponent) / Math.pow(depth, depthScoreExponent));
    for (Synset holonym : childNode.getHolonyms()) {

      fathomHolonymsExponential(wordSense, holonym, relvGlossWords, depth - 1,
          maxDepth, intersectionExponent, depthScoreExponent);
    }
  }

  /**
   * Checks if the feature should be counted in the score
   * @param featureSynsets
   * @param relevantWords
   * @return count of features to consider
   */
  private int assessFeature(ArrayList<Synset> featureSynsets,
      ArrayList<WordPOS> relevantWords) {
    int count = 0;
    for (Synset synset : featureSynsets) {
      Node subNode = new Node(synset, relevantWords);

      String[] tokenizedSense = Loader.getTokenizer().tokenize(
          subNode.getSense());
      ArrayList<WordPOS> relvSenseWords = PreProcessor
          .getAllRelevantWords(tokenizedSense);

      for (WordPOS senseWord : relvSenseWords) {
        for (WordPOS sentenceWord : relevantWords) {
          if (sentenceWord.isStemEquivalent(senseWord)) {
            count = count + 1;
          }
        }
      }
    }
    return count;
  }

  /**
   * Checks if the synonyms should be counted in the score
   * @param synonyms
   * @param relevantWords
   * @return count of synonyms to consider
   */
  private int assessSynonyms(ArrayList<WordPOS> synonyms,
      ArrayList<WordPOS> relevantWords) {
    int count = 0;

    for (WordPOS synonym : synonyms) {
      for (WordPOS sentenceWord : relevantWords) {
        if (sentenceWord.isStemEquivalent(synonym)) {
          count = count + 1;
        }
      }
    }
    return count;
  }

  /**
   * Gets the senses of the nodes
   * @param nodes
   * @return senses from the nodes
   */
  public ArrayList<WordSense> updateSenses(ArrayList<Node> nodes) {
    ArrayList<WordSense> scoredSenses = new ArrayList<WordSense>();

    for (int i = 0; i < nodes.size(); i++) {
      ArrayList<WordPOS> sensesComponents = PreProcessor
          .getAllRelevantWords(PreProcessor.tokenize(nodes.get(i).getSense()));
      WordSense wordSense = new WordSense();
      nodes.get(i).setSenseRelevantWords(sensesComponents);
      wordSense.setNode(nodes.get(i));
      wordSense.setId(i);
      scoredSenses.add(wordSense);
    }
    return scoredSenses;

  }
  
  /**
   * Disambiguates an ambiguous word in its context
   * 
   * @param tokenizedContext
   * @param ambiguousTokenIndex
   * @return array of sense indexes from WordNet ordered by their score.
   * The result format is <b>POS</b>@<b>SenseID</b>@<b>Sense Score</b> 
   * If the input token is non relevant a null is returned.
   */
  @Override
  public String[] disambiguate(String[] tokenizedContext, int ambiguousTokenIndex) {
    
    WTDLesk wtd = new WTDLesk(tokenizedContext, ambiguousTokenIndex);
    // if the word is not relevant return null
    if (!Constants.isRelevant(wtd.getPosTag())){
      return null ;
    }
    
    ArrayList<WordSense> wsenses = null;

    switch (this.params.leskType) {
    case LESK_BASIC:
      wsenses = basic(wtd);
      break;
    case LESK_BASIC_CTXT:
      wsenses = basicContextual(wtd);
      break;
    case LESK_BASIC_CTXT_WIN:
      wsenses = basicContextual(wtd, this.params.win_b_size);
      break;
    case LESK_BASIC_CTXT_WIN_BF:
      wsenses = basicContextual(wtd, this.params.win_b_size,
          this.params.win_f_size);
      break;
    case LESK_EXT:
      wsenses = extended(wtd, this.params.depth, this.params.depth_weight,
          this.params.fathom_synonyms, this.params.fathom_hypernyms,
          this.params.fathom_hyponyms, this.params.fathom_meronyms,
          this.params.fathom_holonyms);
      break;
    case LESK_EXT_CTXT:
      wsenses = extendedContextual(wtd, this.params.depth,
          this.params.depth_weight, this.params.fathom_synonyms,
          this.params.fathom_hypernyms, this.params.fathom_hyponyms,
          this.params.fathom_meronyms, this.params.fathom_holonyms);
      break;
    case LESK_EXT_CTXT_WIN:
      wsenses = extendedContextual(wtd, this.params.win_b_size,
          this.params.depth, this.params.depth_weight,
          this.params.fathom_synonyms, this.params.fathom_hypernyms,
          this.params.fathom_hyponyms, this.params.fathom_meronyms,
          this.params.fathom_holonyms);
      break;
    case LESK_EXT_CTXT_WIN_BF:
      wsenses = extendedContextual(wtd, this.params.win_b_size,
          this.params.win_f_size, this.params.depth, this.params.depth_weight,
          this.params.fathom_synonyms, this.params.fathom_hypernyms,
          this.params.fathom_hyponyms, this.params.fathom_meronyms,
          this.params.fathom_holonyms);
      break;
    case LESK_EXT_EXP:
      wsenses = extendedExponential(wtd, this.params.depth, this.params.iexp,
          this.params.dexp, this.params.fathom_synonyms,
          this.params.fathom_hypernyms, this.params.fathom_hyponyms,
          this.params.fathom_meronyms, this.params.fathom_holonyms);
      break;
    case LESK_EXT_EXP_CTXT:
      wsenses = extendedExponentialContextual(wtd, this.params.depth,
          this.params.iexp, this.params.dexp, this.params.fathom_synonyms,
          this.params.fathom_hypernyms, this.params.fathom_hyponyms,
          this.params.fathom_meronyms, this.params.fathom_holonyms);
      break;
    case LESK_EXT_EXP_CTXT_WIN:
      wsenses = extendedExponentialContextual(wtd, this.params.win_b_size,
          this.params.depth, this.params.iexp, this.params.dexp,
          this.params.fathom_synonyms, this.params.fathom_hypernyms,
          this.params.fathom_hyponyms, this.params.fathom_meronyms,
          this.params.fathom_holonyms);
      break;
    case LESK_EXT_EXP_CTXT_WIN_BF:
      wsenses = extendedExponentialContextual(wtd, this.params.win_b_size,
          this.params.win_f_size, this.params.depth, this.params.iexp,
          this.params.dexp, this.params.fathom_synonyms,
          this.params.fathom_hypernyms, this.params.fathom_hyponyms,
          this.params.fathom_meronyms, this.params.fathom_holonyms);
      break;
    }

    wsenses = extendedExponentialContextual(wtd, LeskParameters.DFLT_WIN_SIZE,
        LeskParameters.DFLT_DEPTH, LeskParameters.DFLT_IEXP,
        LeskParameters.DFLT_DEXP, true, true, true, true, true);
    Collections.sort(wsenses);

    // TODO modify to longs but for now we have strings in the data for coarsing
    String[] senses = new String[wsenses.size()];
    for (int i = 0; i < wsenses.size(); i++) {
      senses[i] = Constants.getPOS(wsenses.get(i).getWTDLesk().getPosTag())
          .getKey()
          + "@"
          + Long.toString(wsenses.get(i).getNode().getSenseID())
          + "@"
          + wsenses.get(i).getScore();
    }
    return senses;
  }

  
  /**
   * Disambiguates an ambiguous word in its context
   * The user can set a span of inputWords from the tokenized input
   *  
   * @param inputText
   * @param inputWordSpans
   * @return array of array of sense indexes from WordNet ordered by their score.
   * The result format is <b>POS</b>@<b>SenseID</b>@<b>Sense Score</b> 
   * If the input token is non relevant a null is returned.
   */
  @Override 
  public String[][] disambiguate(String[] tokenizedContext, Span[] ambiguousTokenSpans) {
    // TODO need to work on spans
    return null;
  }

}