/*
* Copyright (c) 2004-2008 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: 
*
*/

using System;
using System.Text;
using System.Collections;
using SymBuildParsingLib.Utils;

namespace SymBuildParsingLib.Token
{
	public class SymToken
	{
		#region Enumerations
		public enum TClass
		{
			// The lexer only deals at this level of abstraction
			EClassNull = 0,
			EClassWhiteSpace,
			EClassAlphaNumeric,
			EClassSymbol,
			EClassNewLine,
			
			// The grouper also can identify these types
			EClassComment,
			EClassQuotation,
			EClassContinuation,
			EClassPreProcessor,
		};

		public enum TType
		{
			ETypeUnidentified = 0,
			ETypeCommentFullLine,
			ETypeCommentBlock,
			ETypeQuotationSingle, 
			ETypeQuotationDouble,
			ETypeAlphaNumericNormal,
			ETypeAlphaNumericUnderscore,
		}
		#endregion

		#region Constructors & destructor
		public static SymToken NullToken()
		{
			return new SymToken( "", TClass.EClassNull, new SymTextPosition() );
		}

		public SymToken( string aValue, TClass aClass, TType aType )
		{
			iValue = aValue;
			iClass = aClass;
			iType = aType;
		}

		public SymToken( string aValue, TClass aClass, SymTextPosition aPosition )
		{
			iValue = aValue;
			iClass = aClass;
			iPosition = aPosition;
		}

		public SymToken( SymToken aToken )
		{
			iValue = aToken.Value;
			iClass = aToken.Class;
			iType = aToken.Type;
			iPosition = aToken.Position;
			iTag = aToken.Tag;
		}
		#endregion

		#region API
		public void RefineTokenClass()
		{
			if	( Class == SymToken.TClass.EClassSymbol )
			{
				if	( Value.Length == 1 )
				{
					if	( Value == "\"" )
					{
						Class = SymToken.TClass.EClassQuotation; 
					}
					else if ( Value == "\'" )
					{
						Class = SymToken.TClass.EClassQuotation; 
					}
					else if ( Value == "_" )
					{
						Class = SymToken.TClass.EClassAlphaNumeric;
					}
					else if ( Value == "#" )
					{
						Class = SymToken.TClass.EClassPreProcessor;
					}
				}
			}
		}

		public void RefineTokenType()
		{
			if	( Type == SymToken.TType.ETypeUnidentified )
			{
				if	( Class == SymToken.TClass.EClassQuotation )
				{
					if	( Value.Length == 1 )
					{
						if	( Value == "\"" )
						{
							Type = SymToken.TType.ETypeQuotationDouble; 
						}
						else if ( Value == "\'" )
						{
							Type = SymToken.TType.ETypeQuotationSingle; 
						}
					}
				}
				else if ( Class == SymToken.TClass.EClassAlphaNumeric )
				{
					if	( Value.Length == 1 && Value == "_" )
					{
						Type = SymToken.TType.ETypeAlphaNumericUnderscore; 
					}
					else
					{
						Type = SymToken.TType.ETypeAlphaNumericNormal; 
					}
				}
			}
		}

		public void Combine( SymToken aToken )
		{
			if	( aToken.Value == ")" || Value == ")" )
			{
				int x = 9;
			}

			System.Diagnostics.Debug.Assert( Class != SymToken.TClass.EClassNull );
			System.Diagnostics.Debug.Assert( aToken.CombiningAllowed == true );
			System.Diagnostics.Debug.Assert( CombiningAllowed == true );
			//
			ForceCombine( aToken );
		}

		public void ForceCombine( SymToken aToken )
		{
			System.Diagnostics.Debug.Assert( Class != SymToken.TClass.EClassNull );
			//
			string newValue = iValue + aToken.Value;
			iValue = newValue;
		}
		#endregion

		#region Properties
		public bool CombiningAllowed
		{
			get
			{
				// We don't permit combining for new lines at all.
				// However, other combining is permitted (irrespective of class type).
				bool okayToCombine = ( Class != TClass.EClassNewLine );
				//
				if	( Value.Length == 1 )
				{
					// Check its not a disallowed character
					int index = KDisallowedCombiningCharacters.IndexOf( Value[ 0 ] );
					okayToCombine = ( index < 0 );
				}
				//
				return okayToCombine;
			}
		}

		public string Value
		{
			get { return iValue; }
		}

		public TClass Class
		{
			get { return iClass; }
			set
			{
				iClass = value;

				// When changing from some other type to a continuation, then
				// we also ensure we preseve the new line value
				if	( iClass == SymToken.TClass.EClassContinuation )
				{
					iValue = @"\" + System.Environment.NewLine;
				}
			}
		}

		public TType Type
		{
			get { return iType; }
			set { iType = value; }
		}

		public SymTextPosition Position
		{
			get { return iPosition; }
		}

		public object Tag
		{
			get { return iTag; }
			set { iTag = value; }
		}
		#endregion

		#region From System.Object
		public override string ToString()
		{
			return Value;
		}

		public override bool Equals( object aObject )
		{
			bool same = false;
			//
			if	( aObject is SymToken )
			{
				SymToken otherToken = (SymToken) aObject;
				//
				if	( otherToken.Class == Class )
				{
					if	( otherToken.Type == Type )
					{
						same = ( otherToken.Value == Value );
					}
				}
			}
			//
			return same;
		}
		#endregion

		#region Internal Constants
		private string KDisallowedCombiningCharacters = "!()\'\";";
		#endregion

		#region Data members
		private string iValue;
		private TClass iClass = TClass.EClassNull;
		private TType iType = TType.ETypeUnidentified;
		private object iTag;
		private SymTextPosition iPosition = new SymTextPosition();
		#endregion
	}
}