/*
 * Script.cs - Manages Level9.Net script files.
 *
 * 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.Generic;
using System.Text;

using Antlr.Runtime;

namespace Level9
{
	/// <summary>
	/// Manages Level9.Net script files.
	/// </summary>
	public sealed class Script
	{
		// -- Constants ------------------------------------------------------

		/// <summary>
		/// The line length in Level9.Net script files.
		/// </summary>
		const int SCRIPT_LINE_LENGTH = 80;

		/// <summary>
		/// The title prefix in Level9.Net script files.
		/// </summary>
		const string SCRIPT_TITLE   = "#title: ";

		/// <summary>
		/// The comment prefix in Level9.Net script files.
		/// </summary>
		const string SCRIPT_COMMENT = "#comment: ";

		/// <summary>
		/// The newline characters in Level9.Net script files.
		/// </summary>
		const string SCRIPT_NEWLINE = "\r\n";

		/// <summary>
		/// The command separator in Level9.Net script files.
		/// </summary>
		const string SCRIPT_COMMAND_SEPARATOR = ";";

		/// <summary>
		/// The starting bracket of comments in Level9.Net script files.
		/// </summary>
		const string SCRIPT_COMMAND_BRACKET_BEGIN = "[";

		/// <summary>
		/// The ending bracket of comments in Level9.Net script files.
		/// </summary>
		const string SCRIPT_COMMAND_BRACKET_END = "]";

		// -- Attributes -----------------------------------------------------

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

		/// <summary>
		/// This property indicates whether script recording is active.
		/// </summary>
		bool isrecording = false;

		/// <summary>
		/// This property indicates whether script playback is active.
		/// </summary>
		bool isplaying = false;

		/// <summary>
		/// The current script's title.
		/// </summary>
		string title   = null;

		/// <summary>
		/// The current script's comment.
		/// </summary>
		string comment = null;

		/// <summary>
		/// A list of script entries. A script entry consists of a command and
		/// a comment.
		/// </summary>
		List<ScriptEntry> entries = new List<ScriptEntry>();

		/// <summary>
		/// A list of errors that occurred while parsing the current script.
		/// </summary>
		List<LexerError> errors = new List<LexerError>();

		/// <summary>
		/// The start index of the script's playback range.
		/// </summary>
		int startIndex = -1;

		/// <summary>
		/// The end index of the script's playback range.
		/// </summary>
		int endIndex = int.MaxValue;

		/// <summary>
		/// The script's current playback position.
		/// </summary>
		int playbackPos = 0;

		/// <summary>
		/// This property indicates whether ScriptChanged events are fired or
		/// not.
		/// </summary>
		bool fireEvents = true;

		// -- Events ---------------------------------------------------------

		/// <summary>Occurs when the script has changed.</summary>
		public event ScriptChangedEventHandler ScriptChanged;

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

		/// <summary>
		/// Initializes a new instance of the Script class.
		/// </summary>
		private Script()
		{
			Interpreter.InputFinished +=
				new InputFinishedEventHandler(InterpreterInputFinished);
		}

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

		/// <summary>
		/// Notifies the listeners that the script has changed.
		/// </summary>
		public void FireScriptChanged()
		{
			if (ScriptChanged != null && fireEvents) {
				ScriptChanged(new ScriptChangedEventArgs());
			}
		}

		/// <summary>
		/// Invoked when the user has finished an input line.
		/// </summary>
		/// <param name="e">
		/// a InputFinishedEventArgs that contains the event data
		/// </param>
		void InterpreterInputFinished(InputFinishedEventArgs e)
		{
			if (isrecording && e.Input != null && e.Input.Length > 0) {
				entries.Add(new ScriptEntry(e.Input, null));
				FireScriptChanged();
			}
		}

		/// <summary>
		/// Adds a script entry.
		/// </summary>
		/// <param name="entry">the script entry</param>
		/// <returns>
		/// false if script playback is active or an error occurred, else true
		/// </returns>
		public bool AddEntry(ScriptEntry entry)
		{
			if (isplaying || entry == null) {
				return false;
			}
			entries.Add(new ScriptEntry(entry.Input, entry.Comment));
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Inserts a script entry before or after the given entry.
		/// </summary>
		/// <param name="index">the script entry's index</param>
		/// <returns>
		/// false if script playback is active or an error occurred, else true
		/// </returns>
		public bool InsertEntry(int index)
		{
			if (isplaying || index < 0
					|| (index > 0 && index > entries.Count)) {
				return false;
			}
			entries.Insert(index, new ScriptEntry());
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Removes script entries.
		/// </summary>
		/// <param name="index">the script entries' index</param>
		/// <returns>
		/// false if script playback is active or an error occurred, else true
		/// </returns>
		public bool RemoveEntry(int index)
		{
			if (isplaying || index < 0
					|| (index > 0 && index > entries.Count)) {
				return false;
			}
			entries.RemoveAt(index);
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Removes the control mark from a script entry.
		/// </summary>
		/// <param name="index">the script entries' index</param>
		/// <returns>
		/// false if script playback is active or an error occurred, else true
		/// </returns>
		public bool RemoveControlMark(int index)
		{
			if (isplaying || index < 0 || index >= entries.Count) {
				return false;
			}
			if (index == startIndex) {
				startIndex = -1;
			}
			if (index == endIndex) {
				endIndex = int.MaxValue;
			}
			entries[index].Pause = false;
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Provides a copy of the script entry at the given index.
		/// </summary>
		/// <param name="index">the script entry's index</param>
		/// <returns>a script entry or null if an error occurred</returns>
		public ScriptEntry GetEntryAt(int index)
		{
			if (index < 0 || index >= entries.Count) {
				return null;
			}
			ScriptEntry entry = new ScriptEntry(entries[index].Input,
				entries[index].Comment);
			entry.Pause = entries[index].Pause;

			return entry;
		}

		/// <summary>
		/// Sets the input of a script entry at the given index.
		/// </summary>
		/// <param name="index">the entry's index</param>
		/// <param name="input">the entry's input</param>
		/// <returns>
		/// false if script playback is active or an error occurred, else true
		/// </returns>
		public bool SetInputAt(int index, string input)
		{
			if (isplaying || index < 0 || index >= entries.Count) {
				return false;
			}
			entries[index].Input = input;
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Sets the comment of a script entry at the given index.
		/// </summary>
		/// <param name="index">the script entry's index</param>
		/// <param name="comment">the script entry's comment</param>
		/// <returns>
		/// false if script playback is active or an error occurred, else true
		/// </returns>
		public bool SetCommentAt(int index, string comment)
		{
			if (isplaying || index < 0 || index >= entries.Count) {
				return false;
			}
			entries[index].Comment = comment;
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Sets the 'pause' property of a script entry at the given index.
		/// </summary>
		/// <param name="index">the script entry's index</param>
		/// <returns>
		/// false if script playback is active or an error occurred, else true
		/// </returns>
		public bool SetPauseAt(int index)
		{
			if (isplaying || index < 0 || index >= entries.Count) {
				return false;
			}
			entries[index].Pause = true;
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Searches the script entries for the occurrence of a search
		/// term.
		/// </summary>
		/// <param name="text">the search term</param>
		/// <param name="start">the start index</param>
		/// <param name="previous">
		/// if set to true the search looks for previous occurrences of the
		/// search term
		/// </param>
		/// <returns>
		/// the index of a script entry if the search term has been found,
		/// else -1
		/// </returns>
		public int FindText(string text, int start, bool previous)
		{
			if (start < 0 || start >= entries.Count
					||  text == null
					|| (text != null && text.Length == 0)) {
				return -1;
			}

			int i = start;
			int count = entries.Count;

			for (; count >= 0; count--) {
				if (EntryMatch(text, entries[i])) {
					return i;
				}
				if (previous) {
					i = (i == 0) ? entries.Count - 1 : i - 1;
				}
				else {
					i = (i == entries.Count - 1) ? 0 : i + 1;
				}
			}

			return -1;
		}


		/// <summary>
		/// Checks if a given text is contained in the input or comment of a
		/// script entry.
		/// </summary>
		/// <param name="text">the search term</param>
		/// <param name="entry">the script entry</param>
		/// <returns>
		/// true if the input or comment of the script entry contains the
		/// given text, else false
		/// </returns>
		bool EntryMatch(string text, ScriptEntry entry)
		{
			string s1 = text.ToLower();
			string s2 = null;

			if (entry.Input != null) {
				s2 = entry.Input.ToLower();
				if (s2.Contains(s1)) {
					return true;
				}
			}
			if (entry.Comment != null) {
				s2 = entry.Comment.ToLower();
				if (s2.Contains(s1)) {
					return true;
				}
			}

			return false;
		}

		/// <summary>
		/// Returns the number of script entries.
		/// </summary>
		/// <returns>the number of script entries</returns>
		public int GetEntriesCount()
		{
			return entries.Count;
		}

		/// <summary>
		/// Clears the script content.
		/// </summary>
		/// <returns>false if script playback is active, else true</returns>
		public bool Clear()
		{
			if (isplaying) {
				return false;
			}
			title      = null;
			comment    = null;
			startIndex = -1;
			endIndex   = int.MaxValue;
			errors.Clear();
			entries.Clear();
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Loads a Level9.Net script.
		/// </summary>
		/// <param name="filename">the script's file name</param>
		/// <returns>false if script playback is active, else true</returns>
		public bool Load(string filename)
		{
			if (isplaying) {
				return false;
			}

			fireEvents = false;
			ICharStream input = new ANTLRFileStream(filename);
			L9Script lex = new L9Script(input);
			try {
				Logger.Log(this, "Load: " + filename);
				Clear();
				while (lex.NextToken() != Token.EOF_TOKEN);
				if (errors.Count > 0) {
					ErrorHandler.Handle(this, "Error parsing script file: "
						+ errors[0].Message + ", line: " + errors[0].Line
						+ ", column: " + errors[0].Column);
				}
			}
			catch (Exception ex) {
				ErrorHandler.Handle(this, "Error parsing script file: "
					+ ex.Message, ex);
			}
			fireEvents = true;
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Creates a string representation of the current script.
		/// </summary>
		/// <param name="includeComments">
		/// if set to true the script includes comments for each entry
		/// </param>
		/// <param name="oneEntryPerLine">
		/// if set to true the script contains one entry per line
		/// </param>
		/// <returns>a string representation of the current script</returns>
		public string Create(bool includeComments, bool oneEntryPerLine)
		{
			StringBuilder script = new StringBuilder();

			//
			// Script header
			//
			if (title != null && title.Length > 0) {
				List<string> lines = TextUtils.SplitParagraph(
					SCRIPT_TITLE + title + SCRIPT_COMMAND_SEPARATOR,
					SCRIPT_LINE_LENGTH);
				for (int i = 0; i < lines.Count; i++) {
					script.Append(lines[i]);
					script.Append(SCRIPT_NEWLINE);
				}
			}
			if (comment != null && comment.Length > 0) {
				List<string> lines = TextUtils.SplitParagraph(
					SCRIPT_COMMENT + comment + SCRIPT_COMMAND_SEPARATOR,
					SCRIPT_LINE_LENGTH);
				for (int i = 0; i < lines.Count; i++) {
					script.Append(lines[i]);
					script.Append(SCRIPT_NEWLINE);
				}
			}
			if (script.Length > 0) {
				script.Append(SCRIPT_NEWLINE);
			}
			//
			// Commands
			//
			if (oneEntryPerLine) {
				for (int i = 0; i < entries.Count; i++) {
					ScriptEntry entry = entries[i];
					if ((entry.Input != null && entry.Input.Length == 0)
							|| entry.Input == null) {
						continue;
					}
					script.Append(entry.Input);
					if (includeComments && entry.Comment != null
							&& entry.Comment.Length > 0) {
						script.Append(" ");
						script.Append(SCRIPT_COMMAND_BRACKET_BEGIN);
						script.Append(entry.Comment);
						script.Append(SCRIPT_COMMAND_BRACKET_END);
					}
					script.Append(SCRIPT_COMMAND_SEPARATOR);
					script.Append(SCRIPT_NEWLINE);
				}
			}
			else {
				StringBuilder entriesStr = new StringBuilder();
				for (int i = 0; i < entries.Count; i++) {
					ScriptEntry entry = entries[i];
					if ((entry.Input != null && entry.Input.Length == 0)
							|| entry.Input == null) {
						continue;
					}
					entriesStr.Append(entry.Input);
					if (includeComments && entry.Comment != null
							&& entry.Comment.Length > 0) {
						entriesStr.Append(" ");
						entriesStr.Append(SCRIPT_COMMAND_BRACKET_BEGIN);
						entriesStr.Append(entry.Comment);
						entriesStr.Append(SCRIPT_COMMAND_BRACKET_END);
					}
					entriesStr.Append(SCRIPT_COMMAND_SEPARATOR);
					if (i < entries.Count - 1) {
						entriesStr.Append(" ");
					}
				}
				List<string> lines = TextUtils.SplitParagraph(
					entriesStr.ToString(), SCRIPT_LINE_LENGTH);
				for (int i = 0; i < lines.Count; i++) {
					script.Append(lines[i]);
					script.Append(SCRIPT_NEWLINE);
				}
			}

			return script.ToString();
		}

		/// <summary>
		/// Starts the script recording.
		/// </summary>
		/// <returns>false if script playback is active, else true</returns>
		public bool StartRecording()
		{
			if (isplaying) {
				return false;
			}
			Logger.Log(this, "StartRecording");
			isrecording = true;
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Stops the script recording.
		/// </summary>
		public void StopRecording()
		{
			Logger.Log(this, "StopRecording");
			isrecording = false;
			FireScriptChanged();
		}

		/// <summary>
		/// Starts the script playback.
		/// </summary>
		/// <returns>
		/// false if script recording is active or an error occurred, else true
		/// </returns>
		public bool StartPlayback()
		{
			if (isrecording || entries.Count == 0) {
				return false;
			}
			playbackPos = StartIndex;
			Logger.Log(this, "StartPlayback");
			isplaying = true;
			FireScriptChanged();

			return true;
		}

		/// <summary>
		/// Stops the script playback.
		/// </summary>
		public void StopPlayback()
		{
			Logger.Log(this, "StopPlayback");
			isplaying = false;
			FireScriptChanged();
		}

		/// <summary>
		/// Provides the next script entry in playback mode.
		/// </summary>
		/// <param name="input">the script entry (return value)</param>
		/// <param name="pause">
		/// if set to true playback should be paused (return value)
		/// </param>
		/// <returns>
		/// the script entry's index or -1 if script playback isn't active
		/// or the playback range has been exceeded
		/// </returns>
		public int GetNextInput(out string input, out bool pause)
		{
			input = null;
			pause = false;

			if (!isplaying) {
				return -1;
			}

			if (playbackPos > EndIndex) {
				StopPlayback();
				return -1;
			}

			while (playbackPos <= EndIndex) {
				input = entries[playbackPos].Input;
				if (input == null || (input != null && input.Length == 0)) {
					playbackPos++;
				}
				else {
					pause = entries[playbackPos].Pause;
					Logger.Log(this, "GetNextInput: [" + playbackPos + "] "
						+ input + ", pause: " + pause);
					playbackPos++;
					return playbackPos - 1;
				}
			}

			return -1;
		}

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

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

		/// <summary>
		/// Gets a value that indicates whether script recording is active.
		/// </summary>
		public bool IsRecording
		{
			get {
				return isrecording;
			}
		}

		/// <summary>
		/// Gets a value that indicates whether script playback is active.
		/// </summary>
		public bool IsPlaying
		{
			get {
				return isplaying;
			}
		}

		/// <summary>
		/// Gets the current playback position.
		/// </summary>
		public int PlaybackPos
		{
			get {
				return playbackPos;
			}
		}

		/// <summary>
		/// Gets s list of errors that occurred while parsing the current
		/// script.
		/// </summary>
		public List<LexerError> Errors
		{
			get {
				return errors;
			}
		}

		/// <summary>
		/// Gets or sets the current script's title.
		/// </summary>
		public string Title
		{
			get {
				return title;
			}
			set {
				this.title = value;
				FireScriptChanged();
			}
		}

		/// <summary>
		/// Gets or sets the current script's comment.
		/// </summary>
		public string Comment
		{
			get {
				return comment;
			}
			set {
				this.comment = value;
				FireScriptChanged();
			}
		}

		/// <summary>
		/// Gets or sets the start index of the script's playback range.
		/// </summary>
		public int StartIndex
		{
			get {
				return startIndex == -1  ? 0 : startIndex;
			}
			set {
				if (!isplaying) {
					this.startIndex = value;
					FireScriptChanged();
				}
			}
		}

		/// <summary>
		/// Gets or sets the end index of the script's playback range.
		/// </summary>
		public int EndIndex
		{
			get {
				if (endIndex == int.MaxValue) {
					return (entries.Count > 0 ? entries.Count - 1 : 0);
				}
				else {
					return endIndex;
				}
			}
			set {
				if (!isplaying) {
					this.endIndex = value;
					FireScriptChanged();
				}
			}
		}
	}

	/// <summary>
	/// Represents a Level9.Net script entry that consists of user input and
	/// a comment.
	/// </summary>
	public class ScriptEntry
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The script entry's user input.
		/// </summary>
		string input = null;

		/// <summary>
		/// The script entry's comment.
		/// </summary>
		string comment = null;

		/// <summary>
		/// This property indicates whether the script playback should be
		/// interrupted at this entry.
		/// </summary>
		bool pause = false;

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

		/// <summary>
		/// Initializes a new instance of the ScriptEntry class.
		/// </summary>
		public ScriptEntry() {}

		/// <summary>
		/// Initializes a new instance of the ScriptEntry class.
		/// </summary>
		/// <param name="input">the user input</param>
		/// <param name="comment">a comment</param>
		public ScriptEntry(string input, string comment)
		{
			this.input   = input;
			this.comment = comment;
		}

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

		/// <summary>
		/// Gets or sets the script entry's user input.
		/// </summary>
		public string Input
		{
			get {
				return input;
			}
			set {
				this.input = value;
			}
		}

		/// <summary>
		/// Gets or sets the script entry's comment.
		/// </summary>
		public string Comment
		{
			get {
				return comment;
			}
			set {
				this.comment = value;
			}
		}

		/// <summary>
		/// Gets or sets a value that indicates whether the script playback
		/// should be interrupted at this entry.
		/// </summary>
		public bool Pause
		{
			get {
				return pause;
			}
			set {
				this.pause = value;
			}
		}
	}

	/// <summary>
	/// Represents a grammar error that occurs while parsing a Level9.Net
	/// script file.
	/// </summary>
	public class LexerError
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The script line containing the grammar error.
		/// </summary>
		int line;

		/// <summary>
		/// The column position of the grammar error.
		/// </summary>
		int column;

		/// <summary>
		/// The error message.
		/// </summary>
		string message = null;

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

		/// <summary>
		/// Initializes a new instance of the ScriptEntry class.
		/// </summary>
		/// <param name="message">the error message</param>
		/// <param name="line">
		/// the script line containing the grammar error
		/// </param>
		/// <param name="column">
		/// the column position of the grammar error
		/// </param>
		public LexerError(string message, int line, int column)
		{
			this.message = message;
			this.line    = line;
			this.column  = column;
		}

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

		/// <summary>
		/// Gets or sets the script line containing the grammar error.
		/// </summary>
		public int Line
		{
			get {
				return line;
			}
			set {
				line = value;
			}
		}

		/// <summary>
		/// Gets or sets the column position of the grammar error.
		/// </summary>
		public int Column
		{
			get {
				return column;
			}
			set {
				column = value;
			}
		}

		/// <summary>
		/// Gets or sets the error message.
		/// </summary>
		public string Message
		{
			get {
				return message;
			}
			set {
				message = value;
			}
		}
	}

	/// <summary>
	/// Represents the method that handles a ScriptChanged event.
	/// </summary>
	public delegate void ScriptChangedEventHandler(ScriptChangedEventArgs e);

	/// <summary>
	/// Provides data for the ScriptChanged event.
	/// </summary>
	public class ScriptChangedEventArgs : EventArgs
	{
		// -- Constructors ---------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the ScriptChangedEventArgs class.
		/// </summary>
		public ScriptChangedEventArgs() { }
	}
}