import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Type;

import javax.ws.rs.core.Context;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Request;
import javax.ws.rs.core.SecurityContext;
import javax.ws.rs.core.UriBuilder;
import javax.ws.rs.core.UriInfo;
import javax.ws.rs.ext.ContextResolver;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.MessageBodyReader;
import javax.ws.rs.ext.MessageBodyWriter;
import javax.ws.rs.ext.Providers;

import com.google.inject.AbstractModule;
import com.google.inject.MembersInjector;
import com.google.inject.Provider;
import com.google.inject.Provides;
import com.google.inject.ProvisionException;
import com.google.inject.Scopes;
import com.google.inject.TypeLiteral;
import com.google.inject.matcher.Matchers;
import com.google.inject.spi.TypeEncounter;
import com.google.inject.spi.TypeListener;
import com.sun.jersey.api.core.HttpContext;
import com.sun.jersey.api.core.HttpRequestContext;
import com.sun.jersey.server.impl.application.WebApplicationImpl;
import com.sun.jersey.spi.container.WebApplication;

public class JerseyModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(WebApplication.class).to(WebApplicationImpl.class).in(Scopes.SINGLETON);

        bindListener(Matchers.any(), new Jsr311TypeListener());
    }

    @Provides public HttpContext httpContext(WebApplication webApplication) {
        return webApplication.getThreadLocalHttpContext();
    }

    @Provides public UriInfo uriInfo(HttpContext httpContext) {
        return httpContext.getUriInfo();
    }

    @Provides public HttpRequestContext requestContext(HttpContext httpContext) {
        return httpContext.getRequest();
    }

    @Provides public HttpHeaders httpHeaders(HttpContext httpContext) {
        return httpContext.getRequest();
    }

    @Provides public Request request(HttpContext httpContext) {
        return httpContext.getRequest();
    }

    @Provides public SecurityContext securityContext(HttpContext httpContext) {
        return httpContext.getRequest();
    }

    @Provides public Providers providers(final WebApplication webApplication) {
        return new Providers() {

            public <T> ContextResolver<T> getContextResolver(Class<T> contextType, MediaType mediaType) {
                return null;
            }

            public <T extends Throwable> ExceptionMapper<T> getExceptionMapper(Class<T> type) {
                return null;
            }

            public <T> MessageBodyReader<T> getMessageBodyReader(Class<T> type, Type genericType,
                    Annotation[] annotations, MediaType mediaType) {
                return webApplication.getMessageBodyWorkers().getMessageBodyReader(type, genericType, annotations, mediaType);
            }

            public <T> MessageBodyWriter<T> getMessageBodyWriter(Class<T> type, Type genericType,
                    Annotation[] annotations, MediaType mediaType) {
                return webApplication.getMessageBodyWorkers().getMessageBodyWriter(type, genericType, annotations, mediaType);
            }
        };
    }

    @Provides public UriBuilder uriBuilder(UriInfo uriInfo) {
        return uriInfo.getRequestUriBuilder();
    }

    private static class Jsr311TypeListener implements TypeListener {
        public <I> void hear(TypeLiteral<I> type, TypeEncounter<I> encounter) {
            for (Field field : type.getRawType().getDeclaredFields()) {
                if (field.isAnnotationPresent(Context.class)) {
                    encounter.register(new ContextMembersInjector<I>(field, encounter.getProvider(field.getType())));
                }
            }
        }
    }

    private static class ContextMembersInjector<I> implements MembersInjector<I> {
        private final Field field;
        private final Provider<?> provider;

        public ContextMembersInjector(Field field, Provider<?> provider) {
            this.field = field;
            this.provider = provider;
        }

        public void injectMembers(I instance) {
            try {
                field.set(instance, provider.get());
            } catch (IllegalAccessException e) {
                throw new ProvisionException("Failed to inject " + instance.getClass().getName() + "." + field.getName(), e);
            }
        }
    }
}