using System.Configuration;

namespace ChadSoft.Edificator
{
    public class WisdomService
    {
        public const int MaxGenerationRetryCount = 10;

        private readonly IWisdomGenerator _wisdomGenerator;
        private readonly IWisdomHistory _wisdomHistory;
        private readonly IMailService _mailService;

        public WisdomService(IWisdomGenerator wisdomGenerator, IWisdomHistory wisdomHistory, IMailService mailService)
        {
            _wisdomGenerator = wisdomGenerator;
            _wisdomHistory = wisdomHistory;
            _mailService = mailService;
        }

        /// <remarks>
        /// Yes, I know that it's actually "edify"...  so what?
        /// </remarks>
        public void Edificate()
        {
            WisdomBit bitOfWisdom = _wisdomGenerator.GetMostRecentlyAddedBitOfWisdom();

            int retryCount = 0;
            while ((retryCount++ < MaxGenerationRetryCount) && IsWisdomInvalid(bitOfWisdom))
            {
                System.Diagnostics.Debug.WriteLine(string.Format("Wisdom generation attempt #{0}...", retryCount+1));
                bitOfWisdom = _wisdomGenerator.GenerateRandomBitOfWisdom();
            }

            if (bitOfWisdom == null)
            {
                System.Diagnostics.Debug.WriteLine("No Wisdom found for today... returning empty-handed.  :(");
                return;
            }

            if (retryCount >= MaxGenerationRetryCount)
                System.Diagnostics.Debug.WriteLine("Max retry count reached - just using the last bit of wisdom we got.");

            Disseminate(bitOfWisdom);
        }

        public void Edificate(string identifier)
        {
            WisdomBit bitOfWisdom = _wisdomGenerator.GetSpecificBitOfWisdom(identifier);
            Disseminate(bitOfWisdom);
        }

        protected virtual void Disseminate(WisdomBit bitOfWisdom)
        {
            _mailService.Mail(bitOfWisdom);
            _wisdomHistory.WisdomSent(bitOfWisdom);
        }

        private bool IsWisdomInvalid(WisdomBit bitOfWisdom)
        {
            return (bitOfWisdom == null || WisdomHasBeenSentRecently(bitOfWisdom));
        }

        private bool WisdomHasBeenSentRecently(WisdomBit wisdom)
        {
            return _wisdomHistory.HasBeenSentRecently(wisdom);
        }

        #region Dependency Factory Methods

        public WisdomService()
        {
            _wisdomGenerator = GetWisdomGenerator();
            _wisdomHistory = GetHistoryService();
            _mailService = GetMailService();
        }

        private static IWisdomGenerator GetWisdomGenerator()
        {
            string feedLocation = ConfigurationManager.AppSettings["SyndicatedFeedWisdomGenerator.FeedLocation"];
            string category = ConfigurationManager.AppSettings["SyndicatedFeedWisdomGenerator.Category"];
            return new SyndicatedFeedWisdomGenerator(feedLocation, category);
        }

        private static IWisdomHistory GetHistoryService()
        {
            return new XmlWisdomHistory();
        }

        private static IMailService GetMailService()
        {
            MailService mailService;
            if (ConfigurationManager.AppSettings["MailService.UseMock"] == "true")
            {
                mailService = new MockMailService();
            }
            else
            {
                string host = ConfigurationManager.AppSettings["MailService.Host"];
                string senderAddress = ConfigurationManager.AppSettings["MailService.SenderEmailAddress"];
                string recipientAddresses = ConfigurationManager.AppSettings["MailService.RecipientEmailAddresses"];

                mailService = new MailService(host, senderAddress, recipientAddresses);
            }
            return mailService;
        }

        #endregion
    }
}