/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: 
*
*/
namespace analysis {
	
	template<class Encoding>
	StateMachineBreakIterator<Encoding>::StateMachineBreakIterator(
		StateMachine<Encoding>& machine)
	:	machine_( machine ),
		state_(), 
		current_(-1),
		next_(-1), 
		text_(0)
	{
	}
	
	template<class Encoding>
	StateMachineBreakIterator<Encoding>::~StateMachineBreakIterator() {}
	
	template<class Encoding>
	void StateMachineBreakIterator<Encoding>::setText(const wchar_t* text) 
	{
		// Let's point to the begining of new text
		text_ = text;
		cursor_ = 0; 
		
		// First boundary is in the beginning of buffer 
		current_ = 0; 
		// We haven't searched for next boundary yet
		next_ = -1; 
	}
	
	template<class Encoding>
	bool StateMachineBreakIterator<Encoding>::hasNext()
	{
		prepareNext(); 
		return next_ != -1; 
	}
	
	template<class Encoding>
	int StateMachineBreakIterator<Encoding>::current()
	{
		return current_; 
	}
	
	template<class Encoding>
	int StateMachineBreakIterator<Encoding>::next()
	{
		prepareNext();
		current_ = next_; 
		next_ = -1; 
		return current_;
	}
	
	template<class Encoding>
	void StateMachineBreakIterator<Encoding>::prepareNext()
	{
		// Implements longest matching word algorithm. The used 
		// state machine contains an entire dictionary. Each state
		// transition interprets as incremental search in dictionary. 
		// Each final (or terminal) state, marks location, where the 
		// consumed states form a valid word. We try to find the 
		// longest matching word. 
		// 
		
		// Prepare next_ only, if new next_ hasn't been prepared before 
		if (next_ == -1 && text_ && text_[cursor_]) {
			// Reset state machine
			machine_.rootState(state_);

			// lastBreak points to the end of last recognized word
			int lastBreak = -1;  
			// Continue until EOF
			while (text_[cursor_]) {
				// Feed next character to the state machine 
				// and try to transit the state
				if (!state_.next(text_[cursor_++])) {
					// Check last final state
					if (lastBreak != -1) { 
						// Final state marked a valid word
						// This is word boundary we were lookign
						cursor_ = lastBreak; 
					}
					break;
				} else if (state_.isFinal()) {
					// Found a valid word! Mark the location 
					lastBreak = cursor_; 
					// Still, continue and try to find even a longer word
				}
			}
			next_ = cursor_;
		}
	}

}