namespace Ink
{
	public class StringParserState
	{
		public int lineIndex {
			get { return currentElement.lineIndex; }
			set { currentElement.lineIndex = value; }
		}

		public int characterIndex {
			get { return currentElement.characterIndex; }
			set { currentElement.characterIndex = value; }
		}

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

        public uint customFlags {
            get { return currentElement.customFlags; }
            set { currentElement.customFlags = value; }
        }

        public bool errorReportedAlreadyInScope {
            get {
                return currentElement.reportedErrorInScope;
            }
        }

        public int stackHeight {
            get {
                return _numElements;
            }
        }

		public class Element {
			public int characterIndex;
            public int characterInLineIndex;
			public int lineIndex;
            public bool reportedErrorInScope;
            public int uniqueId;
            public uint customFlags;

			public Element() {

            }

            public void CopyFrom(Element fromElement)
            {
                _uniqueIdCounter++;
                this.uniqueId = _uniqueIdCounter;
                this.characterIndex = fromElement.characterIndex;
                this.characterInLineIndex = fromElement.characterInLineIndex;
                this.lineIndex = fromElement.lineIndex;
                this.customFlags = fromElement.customFlags;
                this.reportedErrorInScope = false;
            }

            // Squash is used when succeeding from a rule,
            // so only the state information we wanted to carry forward is
            // retained. e.g. characterIndex and lineIndex are global,
            // however uniqueId is specific to the individual rule,
            // and likewise, custom flags are designed for the temporary
            // state of the individual rule too.
            public void SquashFrom(Element fromElement)
            {
                this.characterIndex = fromElement.characterIndex;
                this.characterInLineIndex = fromElement.characterInLineIndex;
                this.lineIndex = fromElement.lineIndex;
                this.reportedErrorInScope = fromElement.reportedErrorInScope;
                this.customFlags = fromElement.customFlags;
            }

            static int _uniqueIdCounter;
		}

		public StringParserState ()
		{
            const int kExpectedMaxStackDepth = 200;
            _stack = new Element[kExpectedMaxStackDepth];

            for (int i = 0; i < kExpectedMaxStackDepth; ++i) {
                _stack [i] = new Element ();
            }

            _numElements = 1;
		}

		public int Push()
		{
            if (_numElements >= _stack.Length)
                throw new System.Exception ("Stack overflow in parser state");

            var prevElement = _stack [_numElements - 1];
            var newElement = _stack[_numElements];
            _numElements++;

            newElement.CopyFrom (prevElement);

            return newElement.uniqueId;
		}

        public void Pop(int expectedRuleId)
		{
            if (_numElements == 1) {
				throw new System.Exception ("Attempting to remove final stack element is illegal! Mismatched Begin/Succceed/Fail?");
			}

            if ( currentElement.uniqueId != expectedRuleId)
                throw new System.Exception ("Mismatched rule IDs - do you have mismatched Begin/Succeed/Fail?");

			// Restore state
            _numElements--;
		}

        public Element Peek(int expectedRuleId)
		{
            if (currentElement.uniqueId != expectedRuleId)
                throw new System.Exception ("Mismatched rule IDs - do you have mismatched Begin/Succeed/Fail?");

            return _stack[_numElements-1];
		}

        public Element PeekPenultimate()
        {
            if (_numElements >= 2) {
                return _stack [_numElements - 2];
            } else {
                return null;
            }
        }

		// Reduce stack height while maintaining currentElement
		// Remove second last element: i.e. "squash last two elements together"
        // Used when succeeding from a rule (and ONLY when succeeding, since
        // the state of the top element is retained).
		public void Squash()
		{
            if (_numElements < 2) {
				throw new System.Exception ("Attempting to remove final stack element is illegal! Mismatched Begin/Succceed/Fail?");
			}

            var penultimateEl = _stack [_numElements - 2];
            var lastEl = _stack [_numElements - 1];

            penultimateEl.SquashFrom (lastEl);

            _numElements--;
		}

        public void NoteErrorReported()
        {
            foreach (var el in _stack) {
                el.reportedErrorInScope = true;
            }
        }

		protected Element currentElement
		{
			get {
                return _stack [_numElements - 1];
			}
		}

        private Element[] _stack;
        private int _numElements;
	}
}