/branches/0.14.x/src/MDownloader.WPF/Bootstrapper.cs

using System;

using System.Collections.Generic;

using System.IO;

using System.Linq;

using System.Net;

using System.Reflection;

using System.Text;

using Html.Downloader.Engine;

using Html.Downloader.Engine.Classifying;

using Html.Downloader.Engine.Configuring;

using Html.Downloader.Engine.Impl;

using MDownloader.Extensibility;

using MDownloader.Hostings;

using MDownloader.Hostings.Common;

using MDownloader.Hostings.Core;

using Melon.Commons.AutoUpdate;

using Melon.Commons.AutoUpdate.CodePlex;

using Melon.Commons.Configuration;

using Melon.Commons.Configuration.Impl;

using Melon.Commons.Configuration.Updates;

using Melon.Commons.Diagnostics;

using Melon.Commons.Diagnostics.Impl;

using Melon.Commons.Diagnostics.Mantis;

using Melon.Commons.Downloader;

using Melon.Commons.Downloader.Captchas;

using Melon.Commons.Downloader.Captchas.Ocr;

using Melon.Commons.Downloader.Captchas.User;

using Melon.Commons.Downloader.History;

using Melon.Commons.IoC;

using Melon.Commons.IoC.Impl;

using Melon.Commons.Logging;

using Melon.Commons.Logging.Impl;

using Melon.Commons.Repository;

using Melon.Commons.Repository.Impl;

using Melon.Commons.Resources;

using Melon.Commons.Resources.Embedded;



namespace MDownloader.WPF

{

    internal sealed class Bootstrapper : IServiceContainerBootstrapper

    {

        #region Constants

        private static string ApplicationDataFolder = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), @"adma\MDownloader");

        private static RepositoryPointcut ConfigurationPointcut = new RepositoryPointcut("Configuration.xml");

        private static RepositoryPointcut HistoryPointcut = new RepositoryPointcut("History.xml");



        private static RepositoryPointcut Configuration_V1_V2 = new RepositoryPointcut("Configuration.V1.V2.xslt");

        private static RepositoryPointcut Configuration_V2_V3 = new RepositoryPointcut("Configuration.V2.V3.xslt");

        private static RepositoryPointcut Configuration_V3_V4 = new RepositoryPointcut("Configuration.V3.V4.xslt");

        private static RepositoryPointcut Configuration_V4_V5 = new RepositoryPointcut("Configuration.V4.V5.xslt");

        private static RepositoryPointcut Configuration_V5_V6 = new RepositoryPointcut("Configuration.V5.V6.xslt");

        private static RepositoryPointcut Configuration_V6_V7 = new RepositoryPointcut("Configuration.V6.V7.xslt");

        private static RepositoryPointcut Configuration_V7_V8 = new RepositoryPointcut("Configuration.V7.V8.xslt");

        #endregion



        #region IServiceContainerBootstrapper Members

        public IServiceContainer InitializeServiceContainer()

        {

            var container = new ServiceContainer();



            container.RegisterService(x => Bootstrapper.CreateRepositoryService());

            container.RegisterService(x => Bootstrapper.CreateResourceService());

            container.RegisterService(x => Bootstrapper.CreateApplicationInfoService());

            container.RegisterService(x => Bootstrapper.CreateLoggingService());

            container.RegisterService(x => Bootstrapper.CreateConfigurationService(x));

            container.RegisterService(x => Bootstrapper.CreateRecognitionService(x));

            container.RegisterService(x => Bootstrapper.CreateFileHostingService(x));

            container.RegisterService(x => Bootstrapper.CreateHistoryService(x));

            container.RegisterService(x => Bootstrapper.CreateAutoUpdateService(x));

            container.RegisterService(x => Bootstrapper.CreateFeedbackService());

            container.RegisterService(x => Bootstrapper.CreateClassificationService());

            container.RegisterService(x => Bootstrapper.CreateProxyService(x));

            container.RegisterService(x => Bootstrapper.CreateModuleService(x));

            container.RegisterService(x => Bootstrapper.CreateEngineService(x));



            ServicePointManager.DefaultConnectionLimit = 4;



            return container;

        }

        #endregion

        #region Private Members

        private static IApplicationInfoService CreateApplicationInfoService()

        {

            return new AssemblyApplicationInfoService(typeof(Bootstrapper).Assembly);

        }



        private static ILoggingManager CreateLoggingService()

        {

            return new InMemoryLoggingManager();

        }



        private static IConfigurationService<Configuration> CreateConfigurationService(IServiceContainer container)

        {

            var repository = container.GetService<IRepositoryService>();

            var assembly = new AssemblyRepositoryService(typeof(Bootstrapper).Assembly);

            var service = new FileBasedConfigurationService<Configuration>(repository, Bootstrapper.ConfigurationPointcut);



            service.SetDefaultVersion(1);

            service.SetCurrentVersion(8);



            service.AddUpdater(1, 2, new XsltUpdater(assembly.GetReadStream(Bootstrapper.Configuration_V1_V2)));

            service.AddUpdater(2, 3, new XsltUpdater(assembly.GetReadStream(Bootstrapper.Configuration_V2_V3)));

            service.AddUpdater(3, 4, new XsltUpdater(assembly.GetReadStream(Bootstrapper.Configuration_V3_V4)));

            service.AddUpdater(4, 5, new XsltUpdater(assembly.GetReadStream(Bootstrapper.Configuration_V4_V5)));

            service.AddUpdater(5, 6, new XsltUpdater(assembly.GetReadStream(Bootstrapper.Configuration_V5_V6)));

            service.AddUpdater(6, 7, new XsltUpdater(assembly.GetReadStream(Bootstrapper.Configuration_V6_V7)));

            service.AddUpdater(7, 8, new XsltUpdater(assembly.GetReadStream(Bootstrapper.Configuration_V7_V8)));



            return service;

        }



        private static IHostingsService CreateFileHostingService(IServiceContainer container)

        {

            var history = container.GetService<IHistoryService>();

            var logger = container.GetService<ILoggingManager>();

            var recognizer = container.GetService<IRecognitionPerformer>();

            var service = new HostingsService

            {

                CaptchaCallback = new CaptchaCallbackAdapter(recognizer)

            };



            service.Initialize(container);

            service.Downloaded += (sender, args) => history.Register(Constants.DownloadHistoryLineId, args.Bytes.ToString(), new HistoryTag(args.Provider.Id.ToString()), new HistoryTag(args.Target.Id.ToString()));

            service.Uploaded += (sender, args) => history.Register(Constants.UploadHistoryLineId, args.Bytes.ToString(), new HistoryTag(args.Provider.Id.ToString()), new HistoryTag(args.Target.Id.ToString()));

            service.WaitingStarted += (sender, args) => Bootstrapper.OnProviderWaitingStarted(logger, args);

            service.WaitingCompleted += (sender, args) => Bootstrapper.OnProviderWaitingCompleted(logger, args);

            service.CaptchaArrived += (sender, args) => Bootstrapper.OnCaptchaArrived(logger, args);

            service.CaptchaRecognized += (sender, args) => Bootstrapper.OnCaptchaRecognized(logger, args);



            return service;

        }



        private static IHistoryService CreateHistoryService(IServiceContainer container)

        {

            var repository = container.GetService<IRepositoryService>();

            var pointcut = Bootstrapper.HistoryPointcut;

            var serializer = new HistoryXmlSerializer();

            var service = new HistoryService(repository, pointcut, serializer);



            service.Create(Constants.DownloadHistoryLineId, "Downloaded bytes");

            service.Create(Constants.UploadHistoryLineId, "Uploaded bytes");



            return service;

        }



        public static IRecognitionPerformer CreateRecognitionService(IServiceContainer container)

        {

            var service = new RecognitionService();

            var control = container.GetComponent<IMultiCaptchaControl>(Constants.UserCaptchaRecognitionControl);

            var tessnet = AppDomain.CurrentDomain.BaseDirectory + "tessnet2_32.dll";



            if (File.Exists(tessnet))

                service.AddRecognizer(new OcrRecognizer());



            if (control != null)

                service.AddRecognizer(new UserRecognizer(control));



            return service;

        }



        private static IAutoUpdateService CreateAutoUpdateService(IServiceContainer container)

        {

            var info = container.GetService<IApplicationInfoService>();

            var current = info.GetVersion();

            var project = "mdownloader";



            return new CodePlexRssAutoUpdateService(project, current);

        }



        private static IRepositoryService CreateRepositoryService()

        {

            if (!Directory.Exists(Bootstrapper.ApplicationDataFolder))

                Directory.CreateDirectory(Bootstrapper.ApplicationDataFolder);



            return new FolderRepositoryService(Bootstrapper.ApplicationDataFolder);

        }



        private static IResourceService CreateResourceService()

        {

            return new EmbeddedResourceService(typeof(Bootstrapper).Assembly);

        }



        private static IFeedbackService CreateFeedbackService()

        {

            var server = @"http://adma.uuuq.com/mantis/api/soap/mantisconnect.php";



            return new MantisFeedbackService(server, String.Empty, String.Empty, "MDownloader");

        }



        private static IClassificationService CreateClassificationService()

        {

            return new ClassificationService();

        }



        private static IHostingProxyProvider CreateProxyService(IServiceContainer container)

        {

            var configuration = container.GetService<IConfigurationService<Configuration>>();



            return new HostingProxyProvider(configuration);

        }



        private static IModuleService CreateModuleService(IServiceContainer container)

        {

            var assembly = Assembly.Load("MDownloader.Extensibility.Modules");



            return new MDownloader.Extensibility.Core.ModuleService(assembly, container);

        }



        private static IEngineService CreateEngineService(IServiceContainer container)

        {

            var factory = new DownloaderFactory();

            var service = factory.Create(container);



            return service;

        }



        private static void OnProviderWaitingStarted(ILogger logger, WaitingEventArgs e)

        {

            var targetTag = new LogTag(e.Target.Id.ToString(), e.Target.Name);

            var providerTag = new LogTag(e.Provider.Id.ToString(), e.Provider.Name.ToString());

            var source = Constants.Hostings.Tag(targetTag, providerTag);

            var level = LogLevel.Info;

            var message = String.Format("Waiting {0} seconds...", e.Period.TotalSeconds);



            logger.Log(source, level, message);

        }



        private static void OnProviderWaitingCompleted(ILogger logger, WaitingEventArgs e)

        {

            var targetTag = new LogTag(e.Target.Id.ToString(), e.Target.Name);

            var providerTag = new LogTag(e.Provider.Id.ToString(), e.Provider.Name.ToString());

            var source = Constants.Hostings.Tag(targetTag, providerTag);

            var level = LogLevel.Info;

            var message = String.Format("Waiting {0} seconds completed.", e.Period.TotalSeconds);



            logger.Log(source, level, message);

        }



        private static void OnCaptchaArrived(ILogger logger, CaptchaEventArgs e)

        {

            var targetTag = new LogTag(e.Target.Id.ToString(), e.Target.Name);

            var providerTag = new LogTag(e.Provider.Id.ToString(), e.Provider.Name.ToString());

            var source = Constants.Hostings.Tag(targetTag, providerTag);

            var level = LogLevel.Info;

            var message = String.Format("Recognizing captcha...");

            var imageAttachment = new LogAttachment("Captcha", e.Image, "jpg");



            logger.Log(source, level, message, imageAttachment);

        }



        private static void OnCaptchaRecognized(ILogger logger, CaptchaEventArgs e)

        {

            var targetTag = new LogTag(e.Target.Id.ToString(), e.Target.Name);

            var providerTag = new LogTag(e.Provider.Id.ToString(), e.Provider.Name.ToString());

            var source = Constants.Hostings.Tag(targetTag, providerTag);

            var level = LogLevel.Info;

            var message = String.Format("Recognizing captcha completed; captcha='{0}'.", e.Text);

            var imageAttachment = new LogAttachment("Captcha", e.Image, "jpg");

            var textAttachment = new LogAttachment("Text", Encoding.UTF8.GetBytes(e.Text), "txt");



            logger.Log(source, level, message, imageAttachment, textAttachment);

        }

        #endregion



        private sealed class CaptchaCallbackAdapter : ICaptchaCallback

        {

            private sealed class RecognizerCallbackAdapter : IRecognitionCallback

            {

                #region Private Fields

                private readonly ICaptchaDescriptor descriptor;

                #endregion

                #region Constructors

                public RecognizerCallbackAdapter(ICaptchaDescriptor descriptor)

                {

                    this.descriptor = descriptor;

                }

                #endregion



                #region IRecognitionCallback Members

                public char[] GetValidCharacters()

                {

                    return this.descriptor.GetAvailableChars();

                }



                public byte[] Sharpen(byte[] data)

                {

                    return this.descriptor.Sharpen(data);

                }



                public bool Verify(string text, double confidence)

                {

                    return this.descriptor.Verify(text, confidence);

                }

                #endregion

            }



            #region Private Fields

            private readonly IRecognitionPerformer recognizer;

            #endregion

            #region Constructors

            public CaptchaCallbackAdapter(IRecognitionPerformer recognizer)

            {

                this.recognizer = recognizer;

            }

            #endregion



            #region ICaptchaCallback Members

            public string Recognize(bool auto, byte[] image, ICaptchaDescriptor descriptor)

            {

                var mode = auto ? RecognizerType.Quick : RecognizerType.All;



                return this.recognizer.Recognize(mode, image, new RecognizerCallbackAdapter(descriptor)).Text;

            }

            #endregion

        }

    }

}