source: other-projects/the-macronizer/trunk/src/java/monogram/restorer/MonogramRestorer.java@ 35719

/*
 * This class dose all the hard work. I will look up the input token in the MonogramModel and return.
 */
package monogram.restorer;

import monogram.model.MonogramFactory;
import monogram.model.MonogramModel;
import monogram.model.ListModel;
import util.StringUtil;

/**
 * @author University of Waikato - Te Whare Wānanga o Waikato
 * @version 1.0
 * @since 2014-11-20
 */
public class MonogramRestorer {

    private boolean preserveMacrons;
    private MonogramModel macronModel;
    private MonogramModel doubleVowelModel;
    private ListModel blackListModel;

    private String previousToken;
    private String currentToken;
    private Selector selector;

    public MonogramRestorer(boolean preserveMacrons) {
        this.preserveMacrons = preserveMacrons;
        macronModel = MonogramFactory.getMacronModel();
        doubleVowelModel = MonogramFactory.getDoubleVowelModel();
        blackListModel = MonogramFactory.getBlackList();
        previousToken = "";
        selector = new Selector(3);
    }

    public String restore(String token, Boolean markupChangedWords) {
        // Test to see if it should preserve the macrons already in the input texts. If
        // not remove all macrons.
        if (!preserveMacrons && StringUtil.containsAccents(token)) {
            token = StringUtil.removeAccents(token);
        }

        // Make lower case copy of token.
        final String tokenLowerCase = token.toLowerCase();

        String restoredToken = token;
        // If the word is in the black list return the token with no macron.
        if (blackListModel.contains(token)) {
            return restoredToken;
        }
        // Is selector > 0 it is on a sequence
        if (selector.isMacronTokenSequence()) {
            if (restoreByMacronModel(tokenLowerCase)) {
                // Restore capitalization
                restoredToken = StringUtil.copyCapitalization(token, currentToken);
                // If restoredToken is not the same as token then macron/s have been add so add
                // <mark> html. This is the yellow background around the words on the front end.
                if (!restoredToken.equals(token)) {
                    // only add <mark> html tag if it directinput and not being output to a file.
                    if (markupChangedWords) {
                        restoredToken = "<mark>" + restoredToken + "</mark> ";
                    }
                }

                // if the tonken can not be restored by the MacronModel try and restor it with
                // the DoubleVowelModel.
            } else if (restoreByDoubleVowelModel(tokenLowerCase)) {
                restoredToken = StringUtil.copyDVowelCapitalization(token, currentToken);
            } else {
                currentToken = tokenLowerCase;
            }
        }
        // else if it is not in a sequence
        else {
            // Try and restor it with the DoubleVowelModel
            if (restoreByDoubleVowelModel(tokenLowerCase)) {
                restoredToken = StringUtil.copyDVowelCapitalization(token, currentToken);
            }
            // try and restor it with the MacronModel
            else if (restoreByMacronModel(tokenLowerCase)) {
                restoredToken = StringUtil.copyCapitalization(token, currentToken);
            }
            // Dose not need to be restored
            else {
                currentToken = tokenLowerCase;
            }
        }
        previousToken = currentToken;
        return restoredToken;
    }

    // trys to restore by using the MacronModel and return boolean if it has.
    private boolean restoreByMacronModel(String token) {

        // Test to see if token is in the Distinct Transformation hashset.
        if (macronModel.isDistinctTransformation(token)) {
            // if token is in Distinct Transformation hashset make the distinct
            // ransformation then move along the sequence.
            currentToken = macronModel.getDistinctTransformation(token);
            selector.incrementMacronTokenSequence();
            return true;
        }
        // If token is in Indistinct Transformation hashset
        else if (macronModel.isIndistinctTransformation(token)) {
            final String[] transformations = macronModel.getIndistinctTransformation(token);
            double maxProbability = Double.MIN_VALUE;
            String maxToken = token;
            // loops all transformation and finds the one with the highest probability given
            // the previous token.
            for (String transformation : transformations) {
                // double probability = macronModel.getIndistinctProbability(transformation);
                double probability = 1.0;
                // if macron model has a probability for this transformation then get its
                // probability.
                if (macronModel.containsMonogramProbability(transformation, previousToken)) {
                    probability *= macronModel.getMonogramProbability(transformation, previousToken);
                }

                // if transformation not in macron model then try and find probability in
                // Indistinct probability
                if (probability == 1.0) {
                    probability = macronModel.getIndistinctProbability(transformation);
                }

                // If probability is better then any before it update maxProbability and
                // maxToken.
                if (probability >= maxProbability) {
                    maxProbability = probability;
                    maxToken = transformation;
                }
            }
            currentToken = maxToken;
            selector.incrementMacronTokenSequence();
            return true;
        }
        return false;
    }

    private boolean restoreByDoubleVowelModel(String token) {
        if (doubleVowelModel.isDistinctTransformation(token)) {
            try {
                currentToken = doubleVowelModel.getDistinctTransformation(token);
                selector.incrementDoubleVowelTokenSequence();
                return true;
            } catch (Exception e) {
                System.err.println("double vowel error 1");
                System.exit(0);
            }
        } else if (doubleVowelModel.isIndistinctTransformation(token)) {
            String[] transformations = doubleVowelModel.getIndistinctTransformation(token);
            Double maxProbability = Double.MIN_VALUE;
            String maxToken = token;
            for (String transformation : transformations) {
                // double probability =
                // doubleVowelModel.getIndistinctProbability(transformation);

                double probability = 1.0;
                if (doubleVowelModel.containsMonogramProbability(transformation, previousToken)) {
                    probability *= doubleVowelModel.getMonogramProbability(transformation, previousToken);
                }
                if (probability == 1.0) {
                    probability = doubleVowelModel.getIndistinctProbability(transformation);
                }
                if (probability >= maxProbability) {
                    maxProbability = probability;
                    maxToken = transformation;
                }
            }
            currentToken = maxToken;
            selector.incrementDoubleVowelTokenSequence();
            return true;
        }
        return false;
    }

    private class Selector {

        private int max;
        private int current;

        public Selector(int max) {
            this.max = max;
            current = max;
        }

        public void incrementMacronTokenSequence() {
            if (current < max) {
                current++;
            }
        }

        public void incrementDoubleVowelTokenSequence() {
            if (current > 0) {
                current--;
            }
        }

        public boolean isMacronTokenSequence() {
            return current > 0;
        }

        // public boolean isDoubleVowelTokenSequence() {
        //     return current == 0;
        // }
    }
}