using System;
using System.Collections.Generic;
using System.Reflection;
using System.Diagnostics;
using System.Text;

namespace Ink
{
	public class StringParser
	{
		public delegate object ParseRule();

        public delegate T SpecificParseRule<T>() where T : class;

        public delegate void ErrorHandler(string message, int index, int lineIndex, bool isWarning);

		public StringParser (string str)
		{
            str = PreProcessInputString (str);

            state = new StringParserState();

            if (str != null) {
                _chars = str.ToCharArray ();
            } else {
                _chars = new char[0];
            }

			inputString = str;
		}

		public class ParseSuccessStruct {};
		public static ParseSuccessStruct ParseSuccess = new ParseSuccessStruct();

		public static CharacterSet numbersCharacterSet = new CharacterSet("0123456789");

        protected ErrorHandler errorHandler { get; set; }

		public char currentCharacter
		{
			get
			{
				if (index >= 0 && remainingLength > 0) {
					return _chars [index];
				} else {
					return (char)0;
				}
			}
		}

		public StringParserState state { get; private set; }

        public bool hadError { get; protected set; }

        // Don't do anything by default, but provide ability for subclasses
        // to manipulate the string before it's used as input (converted to a char array)
        protected virtual string PreProcessInputString(string str)
        {
            return str;
        }

		//--------------------------------
		// Parse state
		//--------------------------------

        protected int BeginRule()
        {
            return state.Push ();
        }

        protected object FailRule(int expectedRuleId)
        {
            state.Pop (expectedRuleId);
            return null;
        }

        protected void CancelRule(int expectedRuleId)
        {
            state.Pop (expectedRuleId);
        }

        protected object SucceedRule(int expectedRuleId, object result = null)
        {
            // Get state at point where this rule stared evaluating
            var stateAtSucceedRule = state.Peek(expectedRuleId);
            var stateAtBeginRule = state.PeekPenultimate ();


            // Allow subclass to receive callback
            RuleDidSucceed (result, stateAtBeginRule, stateAtSucceedRule);

            // Flatten state stack so that we maintain the same values,
            // but remove one level in the stack.
            state.Squash();

            if (result == null) {
                result = ParseSuccess;
            }

            return result;
        }

        protected virtual void RuleDidSucceed(object result, StringParserState.Element startState, StringParserState.Element endState)
        {

        }

        protected object Expect(ParseRule rule, string message = null, ParseRule recoveryRule = null)
		{
            object result = ParseObject(rule);
			if (result == null) {
				if (message == null) {
                    message = rule.Method.Name;
				}

                string butSaw;
                string lineRemainder = LineRemainder ();
                if (lineRemainder == null || lineRemainder.Length == 0) {
                    butSaw = "end of line";
                } else {
                    butSaw = "'" + lineRemainder + "'";
                }

                Error ("Expected "+message+" but saw "+butSaw);

				if (recoveryRule != null) {
					result = recoveryRule ();
				}
			}
			return result;
		}

        protected void Error(string message, bool isWarning = false)
		{
            ErrorOnLine (message, lineIndex + 1, isWarning);
		}

        protected void ErrorWithParsedObject(string message, Parsed.Object result, bool isWarning = false)
        {
            ErrorOnLine (message, result.debugMetadata.startLineNumber, isWarning);
        }

        protected void ErrorOnLine(string message, int lineNumber, bool isWarning)
        {
            if ( !state.errorReportedAlreadyInScope ) {

                var errorType = isWarning ? "Warning" : "Error";

                if (errorHandler == null) {
                    throw new System.Exception (errorType+" on line " + lineNumber + ": " + message);
                } else {
                    errorHandler (message, index, lineNumber-1, isWarning);
                }

                state.NoteErrorReported ();
            }

            if( !isWarning )
                hadError = true;
        }

        protected void Warning(string message)
        {
            Error(message, isWarning:true);
        }

		public bool endOfInput
		{
			get { return index >= _chars.Length; }
		}

		public string remainingString
		{
			get {
				return new string(_chars, index, remainingLength);
			}
		}

        public string LineRemainder()
		{
            return (string) Peek (() => ParseUntilCharactersFromString ("\n\r"));
		}

		public int remainingLength
		{
			get {
				return _chars.Length - index;
			}
		}

		public string inputString { get; private set; }


        public int lineIndex
        {
            set {
                state.lineIndex = value;
            }
            get {
                return state.lineIndex;
            }
        }

        public int characterInLineIndex
        {
            set {
                state.characterInLineIndex = value;
            }
            get {
                return state.characterInLineIndex;
            }
        }

        public int index
        {
            // If we want subclass parsers to be able to set the index directly,
            // then we would need to know what the lineIndex of the new
            // index would be - would we have to step through manually
            // counting the newlines to do so?
            private set {
                state.characterIndex = value;
            }
            get {
                return state.characterIndex;
            }
        }

        public void SetFlag(uint flag, bool trueOrFalse) {
            if (trueOrFalse) {
                state.customFlags |= flag;
            } else {
                state.customFlags &= ~flag;
            }
        }

        public bool GetFlag(uint flag) {
            return (state.customFlags & flag) != 0;
        }

		//--------------------------------
		// Structuring
		//--------------------------------

        public object ParseObject(ParseRule rule)
        {
            int ruleId = BeginRule ();

            var stackHeightBefore = state.stackHeight;

            var result = rule ();

            if (stackHeightBefore != state.stackHeight) {
                throw new System.Exception ("Mismatched Begin/Fail/Succeed rules");
            }

            if (result == null)
                return FailRule (ruleId);

            SucceedRule (ruleId, result);
            return result;
        }

        public T Parse<T>(SpecificParseRule<T> rule) where T : class
        {
            int ruleId = BeginRule ();

            var result = rule () as T;
            if (result == null) {
                FailRule (ruleId);
                return null;
            }

            SucceedRule (ruleId, result);
            return result;
        }

		public object OneOf(params ParseRule[] array)
		{
			foreach (ParseRule rule in array) {
                object result = ParseObject(rule);
				if (result != null)
                    return result;
			}

			return null;
		}

		public List<object> OneOrMore(ParseRule rule)
		{
			var results = new List<object> ();

			object result = null;
			do {
                result = ParseObject(rule);
				if( result != null ) {
					results.Add(result);
				}
			} while(result != null);

			if (results.Count > 0) {
				return results;
			} else {
				return null;
			}
		}

		public ParseRule Optional(ParseRule rule)
		{
			return () => {
                object result = ParseObject(rule);
				if( result == null ) {
					result = ParseSuccess;
				}
				return result;
			};
		}

        // Return ParseSuccess instead the real result so that it gets excluded
        // from result arrays (e.g. Interleave)
        public ParseRule Exclude(ParseRule rule)
        {
            return () => {
                object result = ParseObject(rule);
                if( result == null ) {
                    return null;
                }
                return ParseSuccess;
            };
        }

        // Combination of both of the above
        public ParseRule OptionalExclude(ParseRule rule)
        {
            return () => {
                ParseObject(rule);
                return ParseSuccess;
            };
        }

        // Convenience method for creating more readable ParseString rules that can be combined
        // in other structuring rules (like OneOf etc)
        // e.g. OneOf(String("one"), String("two"))
        protected ParseRule String(string str)
        {
            return () => ParseString (str);
        }

		private void TryAddResultToList<T>(object result, List<T> list, bool flatten = true)
		{
			if (result == ParseSuccess) {
				return;
			}

			if (flatten) {
				var resultCollection = result as System.Collections.ICollection;
				if (resultCollection != null) {
					foreach (object obj in resultCollection) {
						Debug.Assert (obj is T);
						list.Add ((T)obj);
					}
					return;
				}
			}

			Debug.Assert (result is T);
			list.Add ((T)result);
		}


		public List<T> Interleave<T>(ParseRule ruleA, ParseRule ruleB, ParseRule untilTerminator = null, bool flatten = true)
		{
            int ruleId = BeginRule ();

			var results = new List<T> ();

			// First outer padding
            var firstA = ParseObject(ruleA);
			if (firstA == null) {
                return (List<T>) FailRule(ruleId);
			} else {
				TryAddResultToList(firstA, results, flatten);
			}

			object lastMainResult = null, outerResult = null;
			do {

				// "until" condition hit?
				if( untilTerminator != null && Peek(untilTerminator) != null ) {
					break;
				}

				// Main inner
                lastMainResult = ParseObject(ruleB);
				if( lastMainResult == null ) {
					break;
				} else {
					TryAddResultToList(lastMainResult, results, flatten);
				}

				// Outer result (i.e. last A in ABA)
				outerResult = null;
				if( lastMainResult != null ) {
                    outerResult = ParseObject(ruleA);
					if (outerResult == null) {
						break;
					} else {
						TryAddResultToList(outerResult, results, flatten);
					}
				}

			// Stop if there are no results, or if both are the placeholder "ParseSuccess" (i.e. Optional success rather than a true value)
			} while((lastMainResult != null || outerResult != null)
				 && !(lastMainResult == ParseSuccess && outerResult == ParseSuccess) && remainingLength > 0);

			if (results.Count == 0) {
                return (List<T>) FailRule(ruleId);
			}

            return (List<T>) SucceedRule(ruleId, results);
		}

		//--------------------------------
		// Basic string parsing
		//--------------------------------

		public string ParseString(string str)
		{
			if (str.Length > remainingLength) {
				return null;
			}

            int ruleId = BeginRule ();

            // Optimisation from profiling:
            // Store in temporary local variables
            // since they're properties that would have to access
            // the rule stack every time otherwise.
            int i = index;
            int cli = characterInLineIndex;
            int li = lineIndex;

			bool success = true;
			foreach (char c in str) {
				if ( _chars[i] != c) {
					success = false;
					break;
				}
                if (c == '\n') {
                    li++;
                    cli = -1;
                }
				i++;
                cli++;
			}

            index = i;
            characterInLineIndex = cli;
            lineIndex = li;

			if (success) {
                return (string) SucceedRule(ruleId, str);
			}
			else {
                return (string) FailRule (ruleId);
			}
		}

        public char ParseSingleCharacter()
        {
            if (remainingLength > 0) {
                char c = _chars [index];
                if (c == '\n') {
                    lineIndex++;
                    characterInLineIndex = -1;
                }
                index++;
                characterInLineIndex++;
                return c;
            } else {
                return (char)0;
            }
        }

		public string ParseUntilCharactersFromString(string str, int maxCount = -1)
		{
			return ParseCharactersFromString(str, false, maxCount);
		}

		public string ParseUntilCharactersFromCharSet(CharacterSet charSet, int maxCount = -1)
		{
			return ParseCharactersFromCharSet(charSet, false, maxCount);
		}

		public string ParseCharactersFromString(string str, int maxCount = -1)
		{
			return ParseCharactersFromString(str, true, maxCount);
		}

		public string ParseCharactersFromString(string str, bool shouldIncludeStrChars, int maxCount = -1)
		{
			return ParseCharactersFromCharSet (new CharacterSet(str), shouldIncludeStrChars);
		}

		public string ParseCharactersFromCharSet(CharacterSet charSet, bool shouldIncludeChars = true, int maxCount = -1)
		{
			if (maxCount == -1) {
				maxCount = int.MaxValue;
			}

			int startIndex = index;

            // Optimisation from profiling:
            // Store in temporary local variables
            // since they're properties that would have to access
            // the rule stack every time otherwise.
            int i = index;
            int cli = characterInLineIndex;
            int li = lineIndex;

			int count = 0;
            while ( i < _chars.Length && charSet.Contains (_chars [i]) == shouldIncludeChars && count < maxCount ) {
                if (_chars [i] == '\n') {
                    li++;
                    cli = -1;
                }
                i++;
                cli++;
				count++;
			}

            index = i;
            characterInLineIndex = cli;
            lineIndex = li;

			int lastCharIndex = index;
			if (lastCharIndex > startIndex) {
				return new string (_chars, startIndex, index - startIndex);
			} else {
				return null;
			}
		}

		public object Peek(ParseRule rule)
		{
			int ruleId = BeginRule ();
			object result = rule ();
            CancelRule (ruleId);
			return result;
		}

		public string ParseUntil(ParseRule stopRule, CharacterSet pauseCharacters = null, CharacterSet endCharacters = null)
		{
			int ruleId = BeginRule ();


			CharacterSet pauseAndEnd = new CharacterSet ();
			if (pauseCharacters != null) {
				pauseAndEnd.UnionWith (pauseCharacters);
			}
			if (endCharacters != null) {
				pauseAndEnd.UnionWith (endCharacters);
			}

			StringBuilder parsedString = new StringBuilder ();
			object ruleResultAtPause = null;

			// Keep attempting to parse strings up to the pause (and end) points.
			//  - At each of the pause points, attempt to parse according to the rule
			//  - When the end point is reached (or EOF), we're done
			do {

				// TODO: Perhaps if no pause or end characters are passed, we should check *every* character for stopRule?
				string partialParsedString = ParseUntilCharactersFromCharSet(pauseAndEnd);
				if( partialParsedString != null ) {
					parsedString.Append(partialParsedString);
				}

				// Attempt to run the parse rule at this pause point
				ruleResultAtPause = Peek(stopRule);

				// Rule completed - we're done
				if( ruleResultAtPause != null ) {
					break;
				} else {

					if( endOfInput ) {
						break;
					}

					// Reached a pause point, but rule failed. Step past and continue parsing string
					char pauseCharacter = currentCharacter;
					if( pauseCharacters != null && pauseCharacters.Contains(pauseCharacter) ) {
						parsedString.Append(pauseCharacter);
                        if( pauseCharacter == '\n' ) {
                            lineIndex++;
                            characterInLineIndex = -1;
                        }
						index++;
                        characterInLineIndex++;
						continue;
					} else {
						break;
					}
				}

			} while(true);

			if (parsedString.Length > 0) {
                return (string) SucceedRule (ruleId, parsedString.ToString ());
			} else {
                return (string) FailRule (ruleId);
			}

		}

        // No need to Begin/End rule since we never parse a newline, so keeping oldIndex is good enough
		public int? ParseInt()
		{
			int oldIndex = index;
            int oldCharacterInLineIndex = characterInLineIndex;

			bool negative = ParseString ("-") != null;

			// Optional whitespace
			ParseCharactersFromString (" \t");

			var parsedString = ParseCharactersFromCharSet (numbersCharacterSet);
            if(parsedString == null) {
                // Roll back and fail
                index = oldIndex;
                characterInLineIndex = oldCharacterInLineIndex;
                return null;
            }

			int parsedInt;
			if (int.TryParse (parsedString, out parsedInt)) {
				return negative ? -parsedInt : parsedInt;
			}

            Error("Failed to read integer value: " + parsedString + ". Perhaps it's out of the range of acceptable numbers ink supports? (" + int.MinValue + " to " + int.MaxValue + ")");
            return null;
        }

        // No need to Begin/End rule since we never parse a newline, so keeping oldIndex is good enough
        public float? ParseFloat()
        {
            int oldIndex = index;
            int oldCharacterInLineIndex = characterInLineIndex;

            int? leadingInt = ParseInt ();
            if (leadingInt != null) {

                if (ParseString (".") != null) {

                    var afterDecimalPointStr = ParseCharactersFromCharSet (numbersCharacterSet);
                    return float.Parse (leadingInt+"." + afterDecimalPointStr, System.Globalization.CultureInfo.InvariantCulture);
                }
            }

            // Roll back and fail
            index = oldIndex;
            characterInLineIndex = oldCharacterInLineIndex;
            return null;
        }

        // You probably want "endOfLine", since it handles endOfFile too.
        protected string ParseNewline()
        {
            int ruleId = BeginRule();

            // Optional \r, definite \n to support Windows (\r\n) and Mac/Unix (\n)
            // 2nd May 2016: Always collapse \r\n to just \n
            ParseString ("\r");

            if( ParseString ("\n") == null ) {
                return (string) FailRule(ruleId);
            } else {
                return (string) SucceedRule(ruleId, "\n");
            }
        }

		private char[] _chars;
	}
}