public async Task Update()
        {
            var lastVersion = await _versionRepository.GetLastVersion <T>();

            var nextEvents = await _eventRepository.Load(lastVersion.Version, 1000);

            while (nextEvents.Any())
            {
                foreach (var nextEvent in nextEvents)
                {
                    try
                    {
                        if (lastVersion.IsStopped)
                        {
                            return;
                        }

                        if (nextEvent.match.season > lastVersion.Season)
                        {
                            await _versionRepository.SaveLastVersion <T>(lastVersion.Version, nextEvent.match.season);

                            lastVersion = await _versionRepository.GetLastVersion <T>();
                        }

                        // Skip the cancel events for now
                        if (nextEvent.match.state != 3 && nextEvent.match.season == lastVersion.Season)
                        {
                            await _innerHandler.Update(nextEvent);
                        }

                        await _versionRepository.SaveLastVersion <T>(nextEvent.Id.ToString(), lastVersion.Season);
                    }
                    catch (Exception e)
                    {
                        _trackingService.TrackException(e, $"ReadmodelHandler: {typeof(T).Name} died on event{nextEvent.Id}");
                        throw;
                    }
                }

                nextEvents = await _eventRepository.Load(nextEvents.Last().Id.ToString());
            }
        }
        public async Task Update()
        {
            var handlerVersion = await _versionRepository.GetLastVersion <PadSyncHandler>();

            var lastVersion = handlerVersion.Version;

            if (lastVersion == null)
            {
                lastVersion = "0";
            }

            var offset = long.Parse(lastVersion);
            var events = await _padRepo.GetFrom(offset);

            if (!events.Any())
            {
                await _versionRepository.SaveLastVersion <PadSyncHandler>((offset + 100).ToString());

                Console.WriteLine("No events found anymore");
            }

            int count = 0;

            while (events.Any())
            {
                foreach (var finishedEvent in events)
                {
                    if (finishedEvent.state == 2)
                    {
                        var wasInserted = await _matchEventRepository.InsertIfNotExisting(
                            new MatchFinishedEvent { match = finishedEvent },
                            count);

                        if (wasInserted)
                        {
                            count++;
                        }
                    }
                }

                offset += 100;
                await _versionRepository.SaveLastVersion <PadSyncHandler>(offset.ToString());

                events = await _padRepo.GetFrom(offset);

                await Task.Delay(1000);
            }
        }