package nl.mprog.ghost.datastructure;

import android.app.Activity;
import android.content.Context;
import android.util.Log;

import java.io.Serializable;

import nl.mprog.ghost.enumeration.Language;

public class Vocabulary implements Serializable {
    RadixTree mRadixTree;
    Language mLanguage;

    public Vocabulary(Context context, Language language) {
        this.mLanguage = language;
        mRadixTree = new RadixTree(context, language);
    }

    public boolean isWord(String word) {
        return mRadixTree.isWord(word);
    }

package nl.mprog.ghost.datastructure;

import android.content.Context;
import android.util.Log;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Scanner;

import nl.mprog.ghost.R;
import nl.mprog.ghost.enumeration.Language;

public class RadixTree implements Serializable {
    private RadixTreeNode mRoot = new RadixTreeNode();
    private ArrayList<RadixTreeNode> mActiveNodes;

    public RadixTree(Context context, Language language) {
        readInWords(getFileScanner(context, language));
    }

    public void readInWords(Scanner scanner) {
        String word;

        while(scanner.hasNextLine()) {
            word = scanner.nextLine();
            mRoot.insertWord(word, mRoot);
        }

        scanner.close();
    }

    public Scanner getFileScanner(Context context, Language language) {
        Scanner scanner;

        switch (language) {
            case DUTCH:
                scanner = new Scanner(context.getResources().openRawResource(R.raw.dutch));
                break;
            case ENGLISH:
            scanner = new Scanner(context.getResources().openRawResource(R.raw.english));
            break;
            default:
            scanner = new Scanner(context.getResources().openRawResource(R.raw.english));
            break;
        }

        return scanner;
    }

    public boolean isWord(String word) {
        RadixTreeNode activeNode = mRoot;
        char[] chars = word.toCharArray();

        for(int i = 0; i < chars.length; i++) {
            activeNode = activeNode.findNode(activeNode, chars[i]);
            if(activeNode == null) return false;
        }

        if(activeNode.mIsWordEnd) {
            return true;
        } else {
            return false;
        }
    }
}

import android.util.Log;

import java.io.Serializable;

public class RadixTreeNode implements Serializable {
    RadixTreeNode[] mChildren = new RadixTreeNode[0];
    char mCharacter = '0';
    boolean mIsWordEnd;

    public RadixTreeNode() {
    }

    public RadixTreeNode(char character) {
        this.mCharacter = character;
    }

    public RadixTreeNode(char character, boolean isWordEnd) {
        this.mCharacter = character;
        this.mIsWordEnd = isWordEnd;
    }

    public void insert(char character) {
        for(RadixTreeNode node : mChildren) {
            if(node.mCharacter == character) {
                return;
            }
        }

        addChild(new RadixTreeNode(character));
    }

    public void insert(char character, boolean isWordEnd) {
        for(RadixTreeNode node : mChildren) {
            if(node.mCharacter == character) {
                return;
            }
        }

        addChild(new RadixTreeNode(character, isWordEnd));
    }

    private void addChild(RadixTreeNode node) {
        if(mChildren.length == 0) {
            mChildren = new RadixTreeNode[1];
            mChildren[0] = node;
        } else {
            RadixTreeNode[] temp = new RadixTreeNode[mChildren.length + 1];
            System.arraycopy(mChildren, 0, temp, 0, mChildren.length);
            temp[mChildren.length] = node;
            mChildren = temp;
        }
    }

    public RadixTreeNode[] getChildren() {
        return mChildren;
    }

    public void insertWord(String word, RadixTreeNode root) {
        RadixTreeNode activeNode = root;
        char[] array = word.toCharArray();

        for(int i = 0; i < (array.length - 1); i++) {
            activeNode.insert(array[i]);
            activeNode = findNode(activeNode, array[i]);
        }

            activeNode.insert(array[array.length - 1], true);
    }

    public RadixTreeNode findNode(RadixTreeNode startPosition, char character) {
        RadixTreeNode[] children = startPosition.getChildren();
        if(children.length == 0) {
            return null;
        } else {
            for(RadixTreeNode rtn : children) {
                if(rtn.mCharacter == character) return rtn;
            }
        }

        return null;
    }
}