my dude

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;
using Chloe.Configuration;
using Chloe.Models;
using Chloe.Parsers;
using Chloe.Repositories;
using Newtonsoft.Json;

namespace Chloe
{
    public class MGuiRetriever : IDisposable
    {
        private readonly ChloeLogger _logger;
        private readonly ChloeOptions _options;
        private readonly int _defaultLimit = 100;
        private readonly ChloeDiscordClient _client;
        private readonly IParserRepository _parserRepository;
        private readonly ChloeProgressLogger _progressLogger;
        private readonly ICollection<ChloeAccount> _accounts;

        public MGuiRetriever(ChloeOptions options, IParserRepository parserRepository, ChloeProgressLogger progressLogger, ChloeLogger chloeLogger)
        {
            _options = options;
            _logger = chloeLogger;
            _progressLogger = progressLogger;
            _parserRepository = parserRepository;
            _accounts = new HashSet<ChloeAccount>();
            _client = new ChloeDiscordClient(_options.Token);
        }

        public async Task<int> RetrieveAsync()
        {
            ICollection<Task> parserTasks = new HashSet<Task>();

            int totalCount = 0;
            bool messageExists = true;
            ulong? previousMessageId = null;
            List<Message> _totalMessages = new List<Message>();

            while (messageExists)
            {
                IEnumerable<Message> messages = await _client.GetMessagesAsync(_options.ChannelId, _defaultLimit, previousMessageId);
                previousMessageId = messages.LastOrDefault()?.Id;
                _progressLogger.LogMessageCount(messages.Count());
                totalCount += messages.Count();
                _totalMessages.AddRange(messages);

             //   Task parserTask = await Task.Factory.StartNew(async () => await ParseMessagesAsync(messages));
              //  parserTasks.Add(parserTask);

                if (_options.HasMaxMessage && messages.Any(m => m.Id == _options.MaxMessageId))
                {
                    messageExists = false;
                    break;
                }

                //_options.HasLimit && totalCount >= _options.ParseLimit ||
                if (messages.Count() < 100)
                {
                    messageExists = false;
                    break;
                }
            }

            _progressLogger.LogMessagesFinished();
            Task.WaitAll(parserTasks.ToArray());
            _progressLogger.LogAccountsFinished();

            File.WriteAllText("messages.json", JsonConvert.SerializeObject(_totalMessages));

            //SerializeAccounts(_accounts.ToArray());
            return 0;
        }

        private Task ParseMessagesAsync(IEnumerable<Message> messages)
        {
            Message[] incomingMessages = messages
                .Where(m => m.Type == MessageType.Default)
                .Where(m => m.Embeds.Count >= 1)
                .ToArray();

            for (int mLoc = 0; mLoc < incomingMessages.Length; mLoc++)
            {
                IParser parser = _parserRepository.TryGetParserFromMessage(incomingMessages[mLoc]);
                if (parser == null)
                {
                    _progressLogger.LogFailedParse();
                    _logger.Log("Unable to find parser for message " + incomingMessages[mLoc].Id);
                    continue;
                }

                ChloeAccount account = parser.Parse(incomingMessages[mLoc]);

                if (account != null)
                {
                    if (!_accounts.Any(a => a.Username == account.Username && a.Password == account.Password))
                    {
                        _accounts.Add(account);
                        _progressLogger.LogAccount();
                        _logger.Log("Account " + account.Username + " (" + account.Id + ") parsed from " + parser.Name + ".");
                    }
                    else
                    {
                        _logger.Log("Account " + account.Username + " (" + account.Id + ") was already parsed.");
                    }
                }
                else
                {
                    _progressLogger.LogFailedParse();
                    _logger.Log("Failed to parsed account from message ID " + incomingMessages[mLoc].Id);
                }
            }

            return Task.CompletedTask;
        }

        private void SerializeAccounts(ChloeAccount[] accounts)
        {
            /* ISerializer serializer;

            switch(_options.FormatType)
            {
                case OutFormatType.Csv:
                    serializer = new CsvSerializer();
                    break;
                case OutFormatType.Simple:
                    serializer = new RawSerializer();
                    break;
                case OutFormatType.Json:
                default:
                    serializer = new JsonSerializer();
                    break;
            } */
            //Move the above code into a serialization repository

            string totalAccounts;

            if (_options.FormatType == OutFormatType.Simple)
            {

                totalAccounts = string.Join("\n", accounts.Select(a => a.Username + ":" + a.Password));
            }
            else
            {
                totalAccounts = JsonConvert.SerializeObject(accounts, Formatting.Indented);
            }

            if (!File.Exists(_options.OutputFilePath))
            {
                File.Create(_options.OutputFilePath).Close();
                File.WriteAllText(_options.OutputFilePath, totalAccounts);
            }

            totalAccounts = null;
        }


        public void Dispose() => Dispose(true);

        protected virtual void Dispose(bool disposing)
        {
            _client.Dispose();
            _accounts.Clear();
            // _logger.Dispose();
            //  _options.Dispose();
            //  _progressLogger.Dispose();
            //  _parserRepository.Dispose();

            if (disposing)
            {
                GC.SuppressFinalize(this);
            }
        }
    }
}