/// <summary>
				/// Inner parse method
				/// </summary>
				/// <param name="scanner">scanner</param>
				/// <returns>the match</returns>
				protected override ParserMatch ParseMain(IScanner scanner)
		{
			// save scanner state
			long offset = scanner.Offset;

			// apply the first parser
			ParserMatch m = FirstParser.Parse(scanner);
			// if m1 successful, do m2
			if (m.Success)
			{
				return m;
			}

			// not found try the next
			scanner.Seek(offset);

			// apply the second parser
			m = SecondParser.Parse(scanner);
			if (m.Success)
			{
				return m;
			}

			scanner.Seek(offset);
			return ParserMatch.CreateFailureMatch(scanner);
		}

        public CategoriesListViewModel(IProductService service, INavigationService navi, IScanner scanner)
        {
            _service = service;
            _navi = navi;
            _scanner = scanner;

            Items = new NotifyTaskCompletion<List<Product>>(_service.GetProducts());
            Categories = new NotifyTaskCompletion<List<string>>(_service.GetCategories());

            NavigateToCategory = new RelayCommand<string>(async cat =>
            {
                var items = (await _service.GetProductsForCategory(cat))
                    .OrderByDescending(i => i.Rating)
                    .ToList();

                if (items != null && items.Any())
                {
                    var page = App.GetProductsListPage(items, cat);
                    await _navi.PushAsync(page);
                }
                else
                {
                    await _navi.DisplayAlert("Error", "There are no items in the category " + cat);
                }
            });

            _searchCommand = new RelayCommand(Search, () => !string.IsNullOrWhiteSpace(SearchTerm));
            ScanCommand = new RelayCommand(async () =>
            {
                var result = await _scanner.Scan();

                SearchTerm = result.Text;
                Search();
            });
        }

		/// <summary>
		/// Inner parse method
		/// </summary>
		/// <param name="scanner">scanner</param>
		/// <returns>the match</returns>
		protected override ParserMatch ParseMain(IScanner scanner)
		{
			if (scanner == null)
				throw new ArgumentNullException("scanner");

			return ParserMatch.CreateFailureMatch(scanner);
		}

		/// <summary>
		/// Inner parse method
		/// </summary>
		/// <param name="scanner">scanner</param>
		/// <returns>the match</returns>
		protected override ParserMatch ParseMain(IScanner scanner)
		{
			long offset = scanner.Offset;

			ParserMatch m = FirstParser.Parse(scanner);
			if (!m.Success)
			{
				scanner.Seek(offset);
				return m;
			}

			while (!scanner.AtEnd)
			{
				offset = scanner.Offset;

				ParserMatch b = SecondParser.Parse(scanner);
				if (!b.Success)
				{
					scanner.Seek(offset);
					return m;
				}
				ParserMatch a = FirstParser.Parse(scanner);
				if (!a.Success)
				{
					scanner.Seek(offset);
					return m;
				}

				m.Concat(b);
				m.Concat(a);
			}

			return m;
		}

        /// <summary>
        /// Public scanner method. Test scanner input for this parser's patterns.
        /// </summary>
        /// <remarks>Most parsers won't need to override this method</remarks>
        /// <param name="scan">Scanner to parse from</param>
        /// <returns>Match (success of failure) of the parser against the scanne</returns>
        public virtual ParserMatch Parse(IScanner scan)
        {
            scan.Normalise();

            var st = new System.Diagnostics.StackTrace();
            scan.StackStats(st.FrameCount);

            if (scan.RecursionCheck(this, scan.Offset))
                if (!(this is Recursion))
                    return scan.NoMatch;

            ParserMatch m;

            if (this is IMatchingParser) m = ((IMatchingParser) this).TryMatch(scan);
            else m = Parse(scan);

            if (m.Success)
            {
                scan.ClearFailures();
            }
            else
            {
                scan.AddFailure(this, scan.Offset);
            }
            return m;
        }

        public override ParserMatch TryMatch(IScanner scan)
        {
            // save scanner state
            int offset = scan.Offset;

            // apply the first parser
            var m = LeftParser.Parse(scan);

            // rewind
            scan.Seek(offset);

            // apply the second parser
            var m2 = RightParser.Parse(scan);

            // pick the longest result
            if (m.Success || m2.Success)
            {
                if (m2.Length >= m.Length)
                {
                    scan.Seek(m2.Offset + m2.Length);
                    return m2;
                }
                scan.Seek(m.Offset + m.Length);
                return m;
            }

            // rewind to point of failure
            scan.Seek(offset);
            return scan.NoMatch;
        }

        public Register(IBasket basket, IDisplay display, IScanner scanner)
        {
            logger = LoggerFactory.GetLogger();

            this.basket = basket;
            this.display = display;
            this.scanner = scanner;

            basket.OnAdd += display.AddProduct;
            basket.AddSuccess += scanner.FlashLed;
            basket.AddFail += scanner.FlashLed;
            basket.OnUpdate += display.UpdateProduct;
            basket.OnRemove += display.RemoveProduct;
            basket.OnUpdateTotalCost += display.UpdateTotalCost;
            basket.OnUpdateProductCount += display.UpdateProductCount;

            display.OnStartScan += scanner.Start;
            display.OnStopScan += scanner.Stop;
            display.OnClear += basket.Clear;

            scanner.OnRead += new OnReadHandler(scanner_OnRead);

            logger.Write("Register", LogLevel.INFO, "Register initialized");

            display.Display();
        }

        public override ParserMatch TryMatch(IScanner scan)
        {
            int offset = scan.Offset;

            var m = LeftParser.Parse(scan);

            int goodOffset = scan.Offset;

            if (!m.Success)
            {
                scan.Seek(offset);
                return scan.NoMatch;
            }

            // doing difference
            scan.Seek(offset);
            var m2 = RightParser.Parse(scan);
            if (m2.Success)
            {
                // fail: must match left but NOT right
                scan.Seek(offset);
                return scan.NoMatch;
            }

            // Good match
            scan.Seek(goodOffset);
            return m;
        }

		/// <summary>
		/// Lookahead to determine if parser can be used to parse (does not consume input)
		/// </summary>
		/// <param name="scanner"></param>
		/// <returns></returns>
		internal ParserMatch TryAccept(IScanner scanner)
		{
			long offset = scanner.Offset;
			ParserMatch m = ParseMain(scanner);
			scanner.Offset = offset;
			return m;
		}

		/// <summary>
		/// Inner parse method
		/// </summary>
		/// <param name="scanner">scanner</param>
		/// <returns>the match</returns>
		protected override ParserMatch ParseMain(IScanner scanner)
		{
			long offset = scanner.Offset;
			int len = 0;

			if (scanner.Peek() == '\r')    // CR
			{
				scanner.Read();
				++len;
			}

			if (scanner.Peek() == '\n')    // LF
			{
				scanner.Read();
				++len;
			}

			if (len>0)
			{
				ParserMatch m = ParserMatch.CreateSuccessfulMatch(scanner, offset, len);
				return m;
			}
			scanner.Seek(offset);
			return ParserMatch.CreateFailureMatch(scanner);
		}

//        private IScanner scanner;
  //      private IVsTextLines buffer;
    //    private List<TokenInfo>[] tokenList;
      //  private string savedSqlText;

        public MySqlColorizer(LanguageService service, IVsTextLines buffer, IScanner scanner)
            : base(service, buffer, scanner)
        {
            (scanner as MySqlScanner).Colorizer = this;
//            this.scanner = scanner;
  //          this.buffer = buffer;
        }

        private static string Solve(IScanner scanner)
        {
            int numberOfPhoneNumbers = scanner.NextInt();
            Program.PhoneNode phoneBook = new Program.PhoneNode(String.Empty, false);
            string answer = null;

            for (int j = 0; j < numberOfPhoneNumbers; j++)
            {
                var no = scanner.Next();
                Debug.WriteLine("Processing: " + no);

                if (answer != null)
                    continue;

                var current = phoneBook;

                for (int index = 0; index < no.Length; index++)
                {
                    var digit = no[index] - '0';
                    if (current.Nodes[digit] == null)
                        current.Nodes[digit] = new PhoneNode(current.Id + digit, index == no.Length - 1);
                    else if (index == no.Length - 1 || current.Nodes[digit].IsStop)
                    {
                        // if this is my last digit and number already used - 'NO'
                        // if some other number finished here - 'NO'

                        // number already exists
                        answer = "NO";
                        break;
                    }
                    current = current.Nodes[digit];
                }
            }
            return answer ?? "YES";
        }

        public ParserMatch TryMatch(IScanner scan)
        {
            if (source == null) throw new Exception("Empty holding parser");
            if (! (source is IMatchingParser)) throw new Exception("Holding parser was non terminating");

            return (source as IMatchingParser).TryMatch(scan);
        }

        public BorrowController(IDisplay display, ICardReader reader, IScanner scanner, IPrinter printer,
                                    IBookDAO bookDAO, ILoanDAO loanDAO, IMemberDAO memberDAO)
        {
            if(display == null) throw new ArgumentException("Display object was not provided to begin the application");
            if (reader == null) throw new ArgumentException("Reader object was not provided to begin the application");
            if (scanner == null) throw new ArgumentException("Scanner object was not provided to begin the application");
            if (printer == null) throw new ArgumentException("Printer object was not provided to begin the application");
            if (bookDAO == null) throw new ArgumentException("BookDAO object was not provided to begin the application");
            if (loanDAO == null) throw new ArgumentException("LoanDAO object was not provided to begin the application");
            if (memberDAO == null) throw new ArgumentException("MemberDAO object was not provided to begin the application");

            _display = display;
            _reader = reader;
            _scanner = scanner;
            _printer = printer;

            _bookDAO = bookDAO;
            _loanDAO = loanDAO;
            _memberDAO = memberDAO;

            _ui = new BorrowControl(this);

            _reader.Listener = this;
            _scanner.Listener = this;

            _bookList = new List<IBook>();
            _loanList = new List<ILoan>();

            _state = EBorrowState.CREATED;
        }

        public ParserMatch TryMatch(IScanner scan)
        {
            int offset = scan.Offset;
            int len = 0;

            if (!scan.EndOfInput && scan.Peek() == '\r') // CR
            {
                scan.Read();
                len++;
            }

            if (!scan.EndOfInput && scan.Peek() == '\n') // LF
            {
                scan.Read();
                len++;
            }

            if (len > 0)
            {
                return scan.CreateMatch(this, offset, len);
            }

            scan.Seek(offset);
            return scan.NoMatch;
        }

 public ProcedureWorkItem(IScanner scanner, Program program, Address addr, string name) : base(addr)
 {
     this.scanner = scanner;
     this.program = program;
     this.addr = addr;
     this.name = name;
 }

        public override ParserMatch TryMatch(IScanner scan)
        {
            int offset = scan.Offset;

            var left = LeftParser.Parse(scan);

            if (left.Success)
            {
                var right = RightParser.Parse(scan);
                if (right.Success)
                {
                    return ParserMatch.Concat(this, left, right);
                }
            }
            else
            {
                scan.Seek(offset);
                left = RightParser.Parse(scan);
                if (left.Success)
                {
                    var right = LeftParser.Parse(scan);
                    if (right.Success)
                    {
                        return ParserMatch.Concat(this, left, right);
                    }
                }
            }

            scan.Seek(offset);
            return scan.NoMatch;
        }

		/// <summary>
		/// Builds a new successful match ending at the current position of the scanner
		/// </summary>
		/// <param name="scanner">The scanner used while matching</param>
		/// <param name="startOffset">The position at which the match started</param>
		public static ParserMatch CreateSuccessfulMatch(IScanner scanner, long startOffset)
		{
			if (scanner == null)
				throw new ArgumentNullException("scanner");

			return CreateSuccessfulMatch(scanner, startOffset, scanner.Offset);
		}

        public override ParserMatch TryMatch(IScanner scan)
        {
            int offset = scan.Offset;

            var m = new ParserMatch(this, scan, offset, -1);

            while (!scan.EndOfInput)
            {
                offset = scan.Offset;

                var a = LeftParser.Parse(scan);

                if (!a.Success)
                {
                    scan.Seek(offset);
                    return m;
                }

                var b = RightParser.Parse(scan);

                if (!b.Success)
                {
                    scan.Seek(offset);
                    return m;
                }

                m.AddSubmatch(a);
                m.AddSubmatch(b);
            }

            return m;
        }

        public override IScanner GetScanner(IVsTextLines buffer)
        {
            if (scanner == null)
                this.scanner = new LineScanner();

            return this.scanner;
        }