/*
 * TextUtils.cs - Utilities for text handling.
 *
 * 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;

namespace Level9
{
	/// <summary>
	/// Utilities for text handling.
	/// </summary>
	public class TextUtils
	{
		/// <summary>
		/// Splits a paragraph into separate lines with a given number of
		/// columns.
		/// </summary>
		/// <param name="paragraph">the paragraph string</param>
		/// <param name="columns">the number of columns per line</param>
		/// <returns>a list of lines</returns>
		public static List<string> SplitParagraph(string paragraph, int columns)
		{
			return SplitParagraph(paragraph, int.MaxValue, columns);
		}

		/// <summary>
		/// Splits a paragraph into separate lines with a given number of
		/// columns.
		/// </summary>
		/// <param name="paragraph">the paragraph string</param>
		/// <param name="numLines">the number of lines</param>
		/// <param name="columns">the number of columns per line</param>
		/// <returns>a list of lines</returns>
		public static List<string> SplitParagraph(string paragraph,
			int numLines, int columns)
		{
			List<string> lines = new List<string>();

			if (paragraph == null || paragraph.Length == 0 || columns <= 0
					|| numLines <= 0) {
				return lines;
			}

			StringBuilder line = new StringBuilder();

			int textLength = paragraph.Length;
			int textEnd    = textLength - 1;
			int textPos    = 0;
			int lineStart  = 0;
			int wordStart  = 0;

			while (true) {
				if ((textPos > 0 && textPos < textEnd
							&& paragraph[textPos] == ' '
							&& paragraph[textPos + 1] != ' ')
						|| textPos == textEnd) {
					wordStart = textPos + 1;
				}
				if (line.Length == columns || textPos == textLength) {
					//
					// Cut line
					//
					if (wordStart > lineStart && textPos > wordStart) {
						int cut = textPos - wordStart;
						line.Remove(line.Length - cut, cut);
						textPos -= cut;
					}
					//
					// Ignore blank at the end of a line
					//
					if (textPos < textEnd && paragraph[textPos] == ' ') {
						textPos++;
					}
					//
					// Add line
					//
					lines.Add(line.ToString().Trim());
					if (lines.Count == numLines) {
						break;
					}
					line      = new StringBuilder();
					lineStart = textPos;
					//
					// End of paragraph
					//
					if (textPos == textLength) {
						break;
					}
				}
				else {
					line.Append(paragraph[textPos++]);
				}
			}

			return lines;
		}

		/// <summary>
		/// Splits a list of paragraphs into separate lines with a given number
		/// of columns.
		/// </summary>
		/// <param name="paragraphs">the list of paragraphs</param>
		/// <param name="lines">the number of lines</param>
		/// <param name="columns">the number of columns per line</param>
		/// <param name="topDown">
		/// if set to true the paragraphs are handled from top to bottom.
		/// If set to false the paragraphs are handled from bottom to top
		/// </param>
		/// <returns>a list of lines</returns>
		public static List<AttributedText> SplitParagraphs(
			List<AttributedText> paragraphs, int lines, int columns,
			bool topDown)
		{
			return SplitParagraphs(paragraphs, lines, columns,
				new TextPosition(0, 0), topDown);
		}

		/// <summary>
		/// Splits a list of paragraphs into separate lines with a given number
		/// of columns.
		/// </summary>
		/// <param name="paragraphs">the list of paragraphs</param>
		/// <param name="lines">the number of lines</param>
		/// <param name="columns">the number of columns per line</param>
		/// <param name="offset">
		/// the offset position in the list of paragraphs (top-down mode only)
		/// </param>
		/// <param name="topDown">
		/// if set to true the paragraphs are handled from top to bottom.
		/// If set to false the paragraphs are handled from bottom to top
		/// </param>
		/// <returns>a list of lines</returns>
		public static List<AttributedText> SplitParagraphs(
			List<AttributedText> paragraphs, int lines, int columns,
			TextPosition offset, bool topDown)
		{
			List<AttributedText> outputLines = new List<AttributedText>();

			if (paragraphs == null || offset == null || lines <= 0
					|| columns <= 0 || offset.Paragraph >= paragraphs.Count) {
				return outputLines;
			}

			if (topDown) {
				for (int i = offset.Paragraph; i < paragraphs.Count; i++) {
					int offsetCol = (i == offset.Paragraph) ? offset.Column : 0;
					outputLines.AddRange(SplitParagraph(paragraphs[i],
						columns, offsetCol, i));
					if (outputLines.Count > lines) {
						while (outputLines.Count > lines) {
							outputLines.RemoveAt(outputLines.Count - 1);
						}
						break;
					}
				}
			}
			else {
				for (int i = paragraphs.Count - 1; i >= 0; i--) {
					outputLines.InsertRange(
						0, SplitParagraph(paragraphs[i], columns, 0, i));
					if (outputLines.Count > lines) {
						while (outputLines.Count > lines) {
							outputLines.RemoveAt(0);
						}
						break;
					}
				}
			}

			return outputLines;
		}

		/// <summary>
		/// Splits a paragraph into separate lines with a given number of
		/// columns.
		/// </summary>
		/// <param name="paragraph">the paragraph string</param>
		/// <param name="columns">the number of columns per line</param>
		/// <param name="offset">
		/// the offset position within the paragraph
		/// </param>
		/// <param name="paragraphIndex">the paragraph's index</param>
		/// <returns>a list of lines</returns>
		static List<AttributedText> SplitParagraph(
			AttributedText paragraph, int columns, int offset,
			int paragraphIndex)
		{
			List<AttributedText> lines = new List<AttributedText>();

			if (offset > paragraph.GetLength()) {
				return lines;
			}

			char[] lineChars    = new char[columns];
			AttributedText line = new AttributedText(lineChars);
			uint[] lineAttr     = line.Attributes;

			char[] text    = paragraph.Text;
			uint[] attr    = paragraph.Attributes;
			int textLength = text.Length;
			int textEnd    = textLength - 1;
			int textPos    = offset;
			int lineStart  = offset;
			int linePos    = 0;
			int wordStart  = 0;

			while (true) {
				if ((textPos > 0 && textPos < textEnd
							&& text[textPos] == ' '
							&& text[textPos + 1] != ' ')
						|| (textPos == textEnd && linePos < columns)) {
					wordStart = textPos + 1;
				}
				if (linePos == columns || textPos == textLength) {
					//
					// Cut line
					//
					if (wordStart > lineStart) {
						while (textPos > wordStart) {
							lineChars[--linePos] = '\0';
							lineAttr[linePos] = 0;
							textPos--;
						}
					}
					//
					// Ignore blank at the end of a line
					//
					if (textPos < textEnd && text[textPos] == ' ') {
						textPos++;
					}
					//
					// Add line
					//
					line.Origin.Column = lineStart;
					line.Origin.Paragraph = paragraphIndex;
					lines.Add(line);
					lineChars = new char[columns];
					line      = new AttributedText(lineChars);
					lineAttr  = line.Attributes;
					linePos   = 0;
					lineStart = textPos;
					//
					// End of paragraph
					//
					if (textPos == textLength) {
						break;
					}
				}
				else {
					if (attr[textPos] != 0) {
						line.AddAttribute(attr[textPos], linePos);
					}
					lineChars[linePos++] = text[textPos++];
				}
			}

			return lines;
		}

		/// <summary>
		/// Extracts the substring from 'text' that's located between the given
		/// strings 'start' and 'end'.
		/// </summary>
		/// <param name="text">the text</param>
		/// <param name="start">the start string</param>
		/// <param name="end">the end string</param>
		/// <returns></returns>
		public static string Substring(string text, string start, string end)
		{
			if (text  == null || (text  != null && text.Length  == 0)
					|| start == null || (start != null && start.Length == 0)
					|| end   == null || (end   != null && end.Length   == 0)) {
				return null;
			}

			string result  = null;
			int startIndex = -1;

			if ((startIndex = text.IndexOf(start)) > -1) {
				startIndex += start.Length;
				int length  = text.IndexOf(end, startIndex) - startIndex;
				if (length > 0) {
					result = text.Substring(startIndex, length);
				}
			}

			return result;
		}
	}

	/// <summary>
	/// Represents a text position defined via paragraph and column.
	/// </summary>
	public class TextPosition : IComparable
	{
		// -- Attributes -----------------------------------------------------

		/// <summary>
		/// The text position's paragraph.
		/// </summary>
		int paragraph = 0;

		/// <summary>
		/// The text position's column.
		/// </summary>
		int column = 0;

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

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

		/// <summary>
		/// Initializes a new instance of the TextPosition class.
		/// </summary>
		/// <param name="paragraph">a paragraph</param>
		/// <param name="column">a column</param>
		public TextPosition(int paragraph, int column)
		{
			this.column    = column;
			this.paragraph = paragraph;
		}

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

		/// <summary>
		/// Copies the paragraph and column values of a given text position.
		/// </summary>
		/// <param name="pos">a text position</param>
		public void Copy(TextPosition pos)
		{
			if (pos != null) {
				column = pos.column;
				paragraph = pos.paragraph;
			}
		}

		/// <summary>
		/// Clears the paragraph and column values.
		/// </summary>
		public void Clear()
		{
			column = paragraph = 0;
		}

		/// <summary>
		/// Determines whether the specified Object is equal to the current
		/// Object.
		/// </summary>
		/// <param name="obj">
		/// the Object to compare with the current Object
		/// </param>
		/// <returns>
		/// true if the specified Object is equal to the current Object;
		/// otherwise, false
		/// </returns>
		public override bool Equals(Object obj)
		{
			if (obj == null) return false;
			if (this.GetType() != obj.GetType()) return false;

			TextPosition pos = (TextPosition)obj;
			return (paragraph == pos.Paragraph && column == pos.Column);
		}

		/// <summary>
		/// Serves as a hash function for a particular type.
		/// </summary>
		/// <returns>a hash code for the current Object</returns>
		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		/// <summary>
		/// Compares the current instance with another object of the same type
		/// and returns an integer that indicates whether the current instance
		/// precedes, follows, or occurs in the same position in the sort order
		/// as the other object.
		/// </summary>
		/// <param name="obj">an object to compare with this instance</param>
		/// <returns>
		/// a value that indicates the relative order of the objects being
		/// compared
		/// </returns>
		public int CompareTo(Object obj)
		{
			TextPosition pos = (TextPosition)obj;
			if (paragraph > pos.Paragraph) {
				return 1;
			}
			if (paragraph < pos.Paragraph) {
				return -1;
			}
			if (column > pos.Column) {
				return 1;
			}
			if (column < pos.Column) {
				return -1;
			}
			return 0;
		}

		/// <summary>
		/// Returns a String that represents the current Object.
		/// </summary>
		/// <returns>a String that represents the current Object</returns>
		public override string ToString()
		{
			return "TextPosition { Paragraph=" + paragraph + ", Column="
				+ column + " }";
		}

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

		/// <summary>
		/// Gets or sets the text position's column.
		/// </summary>
		public int Column
		{
			get {
				return column;
			}
			set {
				column = value;
			}
		}

		/// <summary>
		/// Gets or sets the text position's paragraph.
		/// </summary>
		public int Paragraph
		{
			get {
				return paragraph;
			}
			set {
				paragraph = value;
			}
		}
	}

	/// <summary>
	/// Represents text with attribute information.
	/// </summary>
	public class AttributedText
	{
		// -- Constants ------------------------------------------------------

		/// <summary>
		/// The text attribute that indicates the start of user input.
		/// </summary>
		public const uint ATTR_INPUT_START = 0x00000001;

		/// <summary>
		/// The text attribute that indicates the end of user input.
		/// </summary>
		public const uint ATTR_INPUT_END = 0x00000002;

		/// <summary>
		/// The text attribute that indicates the caret position.
		/// </summary>
		public const uint ATTR_INPUT_CARET = 0x00000004;

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

		/// <summary>
		/// The text associated with this instance.
		/// </summary>
		char[] text = null;

		/// <summary>
		/// An array with text attributes. The indices correspond to the
		/// indices of the <see cref="AttributedText.text"></see> array.
		/// </summary>
		uint[] attributes = null;

		/// <summary>
		/// The text position this attributed text came from.
		/// </summary>
		TextPosition origin = new TextPosition();

		// -- Constructor ----------------------------------------------------

		/// <summary>
		/// Initializes a new instance of the AttributedText class.
		/// </summary>
		/// <param name="text">the text associated with this instance</param>
		public AttributedText(string text)
		{
			this.text = text.ToCharArray();
			this.attributes = new uint[text.Length];
		}

		/// <summary>
		/// Initializes a new instance of the AttributedText class.
		/// </summary>
		/// <param name="text">the text associated with this instance</param>
		public AttributedText(char[] text)
		{
			this.text = text;
			this.attributes = new uint[text.Length];
		}

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

		/// <summary>
		/// Appends a string to the attributed text.
		/// </summary>
		/// <param name="append">the string to append</param>
		public void Append(string append)
		{
			Append(append.ToCharArray());
		}

		/// <summary>
		/// Appends a character array to the attributed text.
		/// </summary>
		/// <param name="append">the character array to append</param>
		public void Append(char[] append)
		{
			int oldSize = text.Length;
			int resize  = oldSize + append.Length;
			Array.Resize(ref text, resize);
			Array.Resize(ref attributes, resize);
			Array.Copy(append, 0, text, oldSize, resize - oldSize);
		}

		/// <summary>
		/// Inserts a string in the attributed text.
		/// </summary>
		/// <param name="insert">the string to insert</param>
		/// <param name="pos">the insert position</param>
		public void Insert(string insert, int pos)
		{
			Insert(insert.ToCharArray(), pos);
		}

		/// <summary>
		/// Inserts a character array in the attributed text.
		/// </summary>
		/// <param name="insert">the character array to insert</param>
		/// <param name="pos">the insert position</param>
		public void Insert(char[] insert, int pos)
		{
			if (insert.Length == 0 || pos < 0 || pos >= text.Length) {
				return;
			}

			int insSize = insert.Length;
			int oldSize = text.Length;
			int newSize = oldSize + insSize;
			Array.Resize(ref text, newSize);
			Array.Resize(ref attributes, newSize);
			Array.Copy(text, pos, text, pos + insSize, oldSize - pos);
			Array.Copy(insert, 0, text, pos, insSize);
		}

		/// <summary>
		/// Removes a range of the attributed text.
		/// </summary>
		/// <param name="start">the start position</param>
		/// <param name="end">the end position</param>
		public void RemoveRange(int start, int end)
		{
			if (start < 0  || start > end || end >= text.Length) {
				return;
			}

			int oldSize  = text.Length;
			int moveSize = oldSize - end - 1;
			if (end < text.Length - 1) {
				Array.Copy(text, end + 1, text, start, moveSize);
			}
			Array.Resize(ref text, start + moveSize);
			Array.Resize(ref attributes, start + moveSize);
		}

		/// <summary>
		/// Provides a range of the attributed text.
		/// </summary>
		/// <param name="start">the start position</param>
		/// <param name="end">the end position</param>
		/// <returns>
		/// a range of the attributed text or null if an error occurred
		/// </returns>
		public AttributedText GetRange(int start, int end)
		{
			if (start < 0  || start > end || end >= text.Length) {
				return null;
			}

			char[] range = new char[end - start + 1];
			Array.Copy(text, start, range, 0, end - start + 1);
			return new AttributedText(range);
		}

		/// <summary>
		/// Removes blanks at the attributed text's end.
		/// </summary>
		public void TrimEnd()
		{
			int cut = text.Length;
			while (--cut >= 0 && text[cut] == ' ');
			Array.Resize(ref text, cut + 1);
			Array.Resize(ref attributes, cut + 1);
		}

		/// <summary>
		/// Adds an attribute at the given position.
		/// </summary>
		/// <param name="attribute">a text attribute</param>
		/// <param name="pos">the text position</param>
		public void AddAttribute(uint attribute, int pos)
		{
			if (attributes == null || pos < 0 || pos >= attributes.Length) {
				return;
			}
			attributes[pos] = attributes[pos] | attribute;
		}

		/// <summary>
		/// Removes an attribute at the given position.
		/// </summary>
		/// <param name="attribute">a text attribute</param>
		/// <param name="pos">the text position</param>
		public void RemoveAttribute(uint attribute, int pos)
		{
			if (attributes == null || pos < 0 || pos >= attributes.Length) {
				return;
			}
			attributes[pos] = attributes[pos] & (~attribute);
		}

		/// <summary>
		/// Provides the text's length.
		/// </summary>
		/// <returns>the text's lenght</returns>
		public int GetLength()
		{
			return this.text.Length;
		}

		/// <summary>
		/// Determines whether the specified Object is equal to the current
		/// Object.
		/// </summary>
		/// <param name="obj">
		/// the Object to compare with the current Object
		/// </param>
		/// <returns>
		/// true if the specified Object is equal to the current Object;
		/// otherwise, false
		/// </returns>
		public override bool Equals(Object obj)
		{
			if (obj == null) return false;
			if (this.GetType() != obj.GetType()) return false;

			bool equal = true;
			AttributedText compare = (AttributedText)obj;

			if (text.Length == compare.GetLength()) {
				char[] compareChars = compare.Text;
				uint[] compareAttr  = compare.Attributes;
				for (int i = 0; i < text.Length; i++) {
					if (text[i] != compareChars[i]
							|| attributes[i] != compareAttr[i]) {
						equal = false;
						break;
					}
				}
			}
			else {
				equal = false;
			}

			return equal;
		}

		/// <summary>
		/// Serves as a hash function for a particular type.
		/// </summary>
		/// <returns>a hash code for the current Object</returns>
		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		/// <summary>
		/// Returns a String that represents the current Object.
		/// </summary>
		/// <returns>a String that represents the current Object</returns>
		public override string ToString()
		{
			return new string(text);
		}

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

		/// <summary>
		/// Gets the text attributes.
		/// </summary>
		public uint[] Attributes
		{
			get {
				return attributes;
			}
		}

		/// <summary>
		/// Gets the text associated with this instance.
		/// </summary>
		public char[] Text
		{
			get {
				return text;
			}
		}

		/// <summary>
		/// Gets the text position this attributed text came from.
		/// </summary>
		public TextPosition Origin
		{
			get {
				return origin;
			}
		}
	}
}