/tinymce4-parent/tinymce4/src/main/java/wicket/contrib/tinymce4/settings/JazzySpellChecker.java

/*
 * $Id: org.eclipse.jdt.ui.prefs 5004 2006-03-17 20:47:08 -0800 (Fri, 17 Mar
 * 2006) eelco12 $ $Revision: 5004 $ $Date: 2006-03-17 20:47:08 -0800 (Fri, 17
 * Mar 2006) $
 * 
 * ==============================================================================
 * Licensed 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 wicket.contrib.tinymce4.settings;

import com.swabunga.spell.engine.SpellDictionary;
import com.swabunga.spell.engine.SpellDictionaryHashMap;
import com.swabunga.spell.event.SpellCheckEvent;
import com.swabunga.spell.event.SpellCheckListener;
import com.swabunga.spell.event.SpellChecker;
import com.swabunga.spell.event.StringWordTokenizer;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import javax.servlet.ServletInputStream;
import javax.servlet.http.HttpServletRequest;
import org.apache.wicket.ajax.json.JSONArray;
import org.apache.wicket.ajax.json.JSONException;
import org.apache.wicket.ajax.json.JSONObject;
import org.apache.wicket.ajax.json.JSONTokener;
import org.apache.wicket.protocol.http.servlet.ServletWebRequest;
import org.apache.wicket.request.cycle.RequestCycle;
import org.apache.wicket.request.http.WebResponse;
import org.apache.wicket.request.resource.AbstractResource;
import org.apache.wicket.util.resource.StringBufferResourceStream;
import org.apache.wicket.util.time.Time;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Wicket web resource that acts as backend spell checker for tinymce component.
 * 
 * @author ivaynberg
 * @author Iulian Costan (iulian.costan@gmail.com)
 * @author Boris Goldowsky
 */
class JazzySpellChecker extends AbstractResource
{
	protected static final String dictFile = "wicket/contrib/tinymce/jazzy/english.0";

	private SpellDictionary dict;

	private final StringBufferResourceStream resourceStream;

	protected static final String contentType = "application/json";

	private static final Logger LOG = LoggerFactory.getLogger(JazzySpellChecker.class);

	private static final long serialVersionUID = 1L;

	/**
	 * Construct spell checker resource.
	 */
	public JazzySpellChecker()
	{
		// todo load dict file from jazzy.jar archive.
		InputStream inputStream = getClass().getClassLoader().getResourceAsStream(dictFile);
		InputStreamReader reader = new InputStreamReader(inputStream);
		try
		{
			dict = new SpellDictionaryHashMap(reader);
		}
		catch (IOException e)
		{
			throw new RuntimeException(e);
		}
		finally
		{
			try
			{
				reader.close();
			}
			catch (IOException e)
			{
				throw new RuntimeException(e);
			}
		}
		resourceStream = new StringBufferResourceStream(contentType);
	}

	// /**
	// * Read the Request and do the processing needed to construct a response.
	// * Why here? configureResponse is one of the few Resource methods that is
	// * called only once per Request. Running the spellcheck anew each time
	// * getResourceStream is called, for example, would be wasteful.
	// *
	// * @see org.apache.wicket.Resource#configureResponse(Response response)
	// */
	@Override
	protected ResourceResponse newResourceResponse(Attributes attributes)
	{
		buildResourceStream();
		if (attributes.getResponse() instanceof WebResponse)
			((WebResponse)attributes.getResponse()).setHeader("Cache-Control",
				"no-cache, must-revalidate");
		ResourceResponse resourceResponse = new ResourceResponse();
		resourceResponse.setWriteCallback(new WriteCallback()
		{
			@Override
			public void writeData(Attributes attributes)
			{
				attributes.getResponse().write(resourceStream.asString());
			}
		});
		return resourceResponse;
	}

	//
	// /**
	// * @see org.apache.wicket.Resource#getResourceStream()
	// */
	// public IResourceStream getResourceStream()
	// {
	// return resourceStream;
	// }

	/**
	 * Read the Request and construct an appropriate ResourceStream to respond with.
	 */
	public void buildResourceStream()
	{
		JSONObject json;
		String cmd = null, id = null;
		JSONArray paramArray = null;

		HttpServletRequest req = ((ServletWebRequest)RequestCycle.get().getRequest()).getContainerRequest();
		BufferedReader reader = null;
		try
		{
			ServletInputStream sis = req.getInputStream();
			reader = new BufferedReader(new InputStreamReader(sis, "UTF-8"));
			// Used for debugging:
			// reader.mark(10);
			// if (reader.read() == -1) {
			// LOG.error("No request seen");
			// }
			// reader.reset();

			json = new JSONObject(new JSONTokener(reader));
			// LOG.debug("JSON Object: {}", json);

			id = json.getString("id");
			cmd = json.getString("method");
			paramArray = json.getJSONArray("params");

		}
		catch (IOException e)
		{
			jsonError("I/O exception while parsing");
		}
		catch (JSONException e)
		{
			jsonError("Could not parse command");
		}
		finally
		{
			try
			{
				if (reader != null)
					reader.close();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
		}

		if (paramArray == null)
		{
			handleEmptyCheckList(cmd, id);
		}
		else if ("checkWords".equals(cmd))
		{
			doSpell(cmd, id, paramArray);
		}
		else if ("getSuggestions".equals(cmd))
		{
			doSuggest(cmd, id, paramArray);
		}
		else
		{
			jsonError("Unknown command");
		}

		// LOG.debug("Processed command {}; output will be {}", cmd,
		// resourceStream.asString());
	}


	private void handleEmptyCheckList(final String cmd, final String id)
	{
		respond(null, cmd, id);
	}

	@SuppressWarnings("unchecked")
	private void doSuggest(final String cmd, final String id, final JSONArray paramArray)
	{
		final SpellChecker checker = new SpellChecker(dict);
		String word = paramArray.optString(1);
		List<String> suggestions = checker.getSuggestions(word, 2);

		respond(suggestions.iterator(), cmd, id);
	}

	private void doSpell(final String cmd, final String id, final JSONArray paramArray)
	{
		final SpellChecker checker = new SpellChecker(dict);

		final Set<String> errors = new HashSet<>();

		checker.addSpellCheckListener(new SpellCheckListener()
		{
            @Override
			public void spellingError(SpellCheckEvent event)
			{
				errors.add(event.getInvalidWord());
			}
		});

		JSONArray words = paramArray.optJSONArray(1);
		checker.checkSpelling(new StringWordTokenizer(words.toString()));
		respond(errors.iterator(), cmd, id);
	}

	private void respond(Iterator<String> words, String cmd, String id)
	{
		JSONArray array = new JSONArray();
		if (words != null)
		{
			while (words.hasNext())
				array.put(words.next());
		}

		JSONObject response = new JSONObject();
		try
		{
			response.put("id", id);
			response.put("error", (String)null);
			response.put("result", array);
			setResponse(response.toString());
		}
		catch (JSONException e)
		{
			jsonError("Failed to construct response");
		}
	}

	private void setResponse(String response)
	{
		resourceStream.clear();
		resourceStream.append(response);
		resourceStream.setLastModified(Time.now());
	}

	// Simple method of returning a user-visible error message to TinyMCE
	private void jsonError(String message)
	{
		setResponse("{\"error\":\"" + message + "\"}");
		LOG.debug("Error message return from RPC call: {}", message);
	}

}