/*
 * Dictionary.cs - Handles dictionaries of Level 9 games.
 *
 * Copyright (C) 2004 - 2011 Andreas Scherrer
 *
 * This is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this software; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,
 * USA.
 */

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Windows.Forms;

namespace Level9
{
	/// <summary>
	/// Handles dictionaries of Level 9 games.
	/// </summary>
	public sealed class Dictionary
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The one and only Dictionary instance (singleton).
		/// </summary>
		static Dictionary instance = null;

		/// <summary>
		/// The dictionary hash table (one bucket per character).
		/// </summary>
		Dictionary<char, ArrayList> dictionary;

		/// <summary>
		/// The dictionary hash table keys.
		/// </summary>
		char[] keys =
		{
			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
			'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
			'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
		};

		/// <summary>
		/// This property indicates whether the dictionary has no entries.
		/// </summary>
		bool empty = true;

		/// <summary>
		/// The split characters for strings containing dictionary entries.
		/// </summary>
		char[] split = new char[] {' ', '\r', '\n'};

		/// <summary>
		/// The Dictionary representation as a string.
		/// </summary>
		string output = null;

		/// <summary>
		/// The text viewer component that displays the dictionary.
		/// </summary>
		TextForm dictionaryView = null;

		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the Dictionary class.
		/// </summary>
		private Dictionary ()
		{
			dictionary = new Dictionary<char, ArrayList>();
			for (int i = 0; i < keys.Length; i++) {
				dictionary.Add(keys[i], new ArrayList());
			}

			dictionaryView = new TextForm(false,Config.Instance.DictViewerSize);
			dictionaryView.Text = "Dictionary";

			Interpreter.NewGameFile +=
				new NewGameFileEventHandler(InterpreterNewGameFile);
		}

		// -- Event handling -------------------------------------------------

		/// <summary>
		/// Invoked when a new game file has been loaded.
		/// </summary>
		/// <param name="e">
		/// a NewGameFileEventArgs that contains the event data
		/// </param>
		void InterpreterNewGameFile(NewGameFileEventArgs e)
		{
			IEnumerator it = dictionary.Values.GetEnumerator();
			while (it.MoveNext()) {
				((ArrayList)it.Current).Clear();
			}
			empty = true;
		}

		// -- Methods --------------------------------------------------------

		/// <summary>
		/// Imports dictionary entries from the given string.
		/// </summary>
		/// <param name="words">a string with dictionary entries</param>
		public void Add(string words)
		{
			if (words == null || (words != null && words.Length == 0)) {
				return;
			}

			Logger.Log(this, words);
			string[] tokens = words.Split(split);

			for (int i = 0; i < tokens.Length; i++) {
				if (tokens[i].Length == 0) {
					continue;
				}
				char key = Char.ToLower(tokens[i][0]);
				if (!dictionary.ContainsKey(key)) {
					continue;
				}
				ArrayList bucket = dictionary[key];
				if (!bucket.Contains(tokens[i])) {
					bucket.Add(tokens[i]);
				}
			}
			empty = false;
		}

		/// <summary>
		/// Initiates the dictionary import, displays a progress form and opens
		/// a text viewer for dictionary examination.
		/// </summary>
		/// <param name="owner">
		/// the dialog owner window to be set for the text viewer
		/// </param>
		public void Show(IWin32Window owner)
		{
			if (empty) {
				Interpreter.AddInputRequest(Interpreter.Commands.Dictionary);
				GameThread.Resume();
				DictionaryProgressForm dpf = new DictionaryProgressForm();
				dpf.ShowDialog();
				output = CreateOutput();
				dictionaryView.Clear();
				dictionaryView.AppendText(output);
			}
			dictionaryView.SetCaretPosition(0);
			dictionaryView.BringToFront();
			dictionaryView.Show();
		}

		/// <summary>
		/// Creates a string representation of the dictionary.
		/// </summary>
		/// <returns>a string representation of the dictionary</returns>
		string CreateOutput()
		{
			StringBuilder output = new StringBuilder();

			output.Append("# LEVEL 9 GAME DICTIONARY");
			output.Append("\n# Game file: <" + Interpreter.GameFilePath + ">");

			IEnumerator it = dictionary.Values.GetEnumerator();
			while (it.MoveNext()) {
				((ArrayList)it.Current).Sort();
			}

			ArrayList keys = new ArrayList(dictionary.Keys);
			keys.Sort();

			ArrayList bucket;
			char key;
			bool first = true;

			//
			// 0 - 9
			//
			for (int i = 0; i < keys.Count; i++) {
				key = (char)keys[i];
				if (key >= 'a' && key <= 'z') {
					continue;
				}
				bucket = dictionary[key];
				if (bucket.Count == 0) {
					continue;
				}
				if (first) {
					output.Append("\n\n- 0-9 -\n\n");
				}
				for (int j = 0; j < bucket.Count; j++) {
					if (first) {
						first = false;
					}
					else {
						output.Append(", ");
					}
					output.Append(bucket[j]);
				}
			}
			//
			// a - z
			//
			for (int i = 0; i < keys.Count; i++) {
				key = (char)keys[i];
				if (key >= '0' && key <= '9') {
					continue;
				}
				bucket = dictionary[key];
				if (bucket.Count == 0) {
					continue;
				}
				output.Append("\n\n- " + Char.ToUpper(key) + " -\n\n");
				for (int j = 0; j < bucket.Count; j++) {
					output.Append(bucket[j]);
					if (j < bucket.Count - 1) {
						output.Append(", ");
					}
				}
			}

			return output.ToString();
		}

		// -- Accessors ------------------------------------------------------

		/// <summary>
		/// Gets the one and only Dictionary instance (singleton).
		/// </summary>
		public static Dictionary Instance
		{
			get {
				if (instance == null) {
					instance = new Dictionary();
				}
				return instance;
			}
		}
	}
}