1using System;
 2using Autofac;
 3using Autofac.Builder;
 4using Autofac.Modules;
 5using Gorilla.Commons.Infrastructure.Container;
 6using gorilla.commons.infrastructure.thirdparty.autofac;
 7using gorilla.commons.infrastructure.thirdparty.Castle.DynamicProxy;
 8using gorilla.commons.utility;
 9
10namespace gorilla.commons.infrastructure.thirdparty.Autofac
11{
12    public class AutofacDependencyRegistryBuilder : DependencyRegistration
13    {
14        readonly ContainerBuilder builder;
15        readonly Func<IContainer> container;
16
17        public AutofacDependencyRegistryBuilder(ContainerBuilder builder)
18        {
19            this.builder = builder;
20            builder.RegisterModule(new ImplicitCollectionSupportModule());
21            builder.SetDefaultScope(InstanceScope.Factory);
22            container = () => builder.Build();
23            container = container.memorize();
24        }
25
26        public void singleton<Contract, Implementation>() where Implementation : Contract
27        {
28            builder.Register<Implementation>().As<Contract>().SingletonScoped();
29        }
30
31        public void singleton(Type contract, Type implementation)
32        {
33            builder.Register(implementation).As(contract).SingletonScoped();
34        }
35
36        public void singleton<Contract>(Func<Contract> instance_of_the_contract)
37        {
38            builder
39                .Register(x => instance_of_the_contract())
40                .As<Contract>()
41                .SingletonScoped();
42        }
43
44        public void transient<Contract, Implementation>() where Implementation : Contract
45        {
46            transient(typeof (Contract), typeof (Implementation));
47        }
48
49        public void transient(Type contract, Type implementation)
50        {
51            if (contract.is_a_generic_type())
52                builder.RegisterGeneric(implementation).As(contract).FactoryScoped();
53            else
54                builder.Register(implementation).As(contract).FactoryScoped();
55        }
56
57        public void transient<Contract>(Func<Contract> factory_method)
58        {
59            builder.Register(x => factory_method()).As<Contract>().FactoryScoped();
60        }
61
62        public void proxy<T>(Configuration<ProxyBuilder<T>> configuration, Func<T> target)
63        {
64            var proxy_builder = new CastleDynamicProxyBuilder<T>();
65            configuration.configure(proxy_builder);
66            builder.Register(x => proxy_builder.create_proxy_for(target)).As<T>().FactoryScoped();
67        }
68
69        public void proxy<T, Configuration>(Func<T> target)
70            where Configuration : Configuration<ProxyBuilder<T>>, new()
71        {
72            proxy(new Configuration(), target);
73        }
74
75        public DependencyRegistry build()
76        {
77            return new AutofacDependencyRegistry(container);
78        }
79    }
80}