/*
 * JBoss, Home of Professional Open Source
 * Copyright 2010, Red Hat Middleware LLC, and individual contributors
 * by the @authors tag. See the copyright.txt in the distribution for a
 * full listing of individual contributors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.jboss.solder.servlet.test.weld.http;

import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.Vector;

import javax.enterprise.inject.Typed;
import javax.enterprise.inject.Instance;
import javax.enterprise.inject.Produces;
import javax.inject.Inject;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;

import junit.framework.Assert;

import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.solder.servlet.http.CookieParam;
import org.jboss.solder.servlet.http.DefaultValue;
import org.jboss.solder.servlet.http.HeaderParam;
import org.jboss.solder.servlet.http.ImplicitHttpServletObjectsProducer;
import org.jboss.solder.servlet.http.RedirectBuilder;
import org.jboss.solder.servlet.http.RedirectBuilderImpl;
import org.jboss.solder.servlet.http.RequestParam;
import org.jboss.solder.servlet.test.weld.util.Deployments;
import org.jboss.shrinkwrap.api.Archive;
import org.junit.Test;
import org.junit.runner.RunWith;

import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

/**
 * @author <a href="http://community.jboss.org/people/dan.j.allen">Dan Allen</a>
 */
@RunWith(Arquillian.class)
// TODO split up into individual tests for each param type
public class RequestParamProducerTest {
    private static final String IMPLICIT_PARAM = "implicit";
    private static final String EXPLICIT_PARAM = "explicit";
    private static final String MISSING_PARAM = "missing";
    private static final String IMPLICIT_VALUE = IMPLICIT_PARAM + "Value";
    private static final String EXPLICIT_VALUE = EXPLICIT_PARAM + "Value";
    private static final String DEFAULT_VALUE = "defaultValue";

    @Deployment
    public static Archive<?> createDeployment() {
        return Deployments
                .createMockableBeanWebArchive(Deployments.exclude(ImplicitHttpServletObjectsProducer.class, RedirectBuilder.class, RedirectBuilderImpl.class))
                .addClasses(RequestParamProducerTest.class, Suit.class);
    }

    @Inject
    @RequestParam(EXPLICIT_PARAM)
    Instance<String> explicit;

    @Inject
    @RequestParam
    Instance<String> implicit;

    @Inject
    @RequestParam(MISSING_PARAM)
    @DefaultValue(DEFAULT_VALUE)
    Instance<String> missing;

    @Inject
    @RequestParam(MISSING_PARAM)
    Instance<String> missingNoDefault;

    @Inject
    @RequestParam("pageSize")
    Instance<Integer> pageSize;

    @Inject
    @RequestParam("suit")
    Instance<Suit> suit;

    @Inject
    @RequestParam("airDate")
    Instance<Date> airDate;

    @Inject
    @HeaderParam("Cache-Control")
    Instance<String> cacheControl;

    @Inject
    @CookieParam
    Instance<String> chocolate;

    @Inject
    @CookieParam("chocolate")
    Instance<Cookie> chocolateCookie;

    @Test
    public void should_inject_value_for_explicit_http_param() {
        Assert.assertEquals(EXPLICIT_VALUE, explicit.get());
    }

    @Test
    public void should_inject_value_for_implicit_http_param() {
        Assert.assertEquals(IMPLICIT_VALUE, implicit.get());
    }

    @Test
    public void should_inject_default_value_for_missing_http_param() {
        Assert.assertEquals(DEFAULT_VALUE, missing.get());
    }

    @Test
    public void should_inject_null_value_for_missing_http_param() {
        Assert.assertNull(missingNoDefault.get());
    }

    @Test
    public void should_inject_value_for_typed_http_param(@RequestParam("page") int page) {
        Assert.assertEquals((Integer) 25, pageSize.get());
        Assert.assertEquals((Integer) 1, (Integer) page);
    }

    @Test
    public void should_inject_value_for_enum_http_param() {
        Assert.assertEquals(Suit.DIAMONDS, suit.get());
    }

    @Test
    public void should_inject_value_for_date_http_param() {
        Calendar cal = Calendar.getInstance();
        cal.set(2010, 7, 1, 20, 0, 0);
        cal.set(Calendar.MILLISECOND, 0);
        Date value = airDate.get();
        Assert.assertNotNull(value);
        Assert.assertEquals(cal.getTime().getTime(), value.getTime());
    }

    @Test
    public void should_inject_value_for_header_param() {
        Assert.assertEquals("no-cache", cacheControl.get());
    }

    @Test
    public void should_inject_value_for_cookie_param() {
        Assert.assertEquals("chip", chocolate.get());
    }

    @Test
    public void should_inject_cookie_for_cookie_param() {
        Cookie c = chocolateCookie.get();
        Assert.assertNotNull(c);
        Assert.assertEquals("chip", c.getValue());
    }

    @Produces
    @Typed(HttpServletRequest.class)
    protected HttpServletRequest getHttpServletRequest() {
        HttpServletRequest req = mock(HttpServletRequest.class);

        Map<String, String[]> parameters = new HashMap<String, String[]>();
        parameters.put(IMPLICIT_PARAM, new String[]{IMPLICIT_VALUE});
        parameters.put(EXPLICIT_PARAM, new String[]{EXPLICIT_VALUE});
        parameters.put("page", new String[]{"1"});
        parameters.put("pageSize", new String[]{"25"});
        parameters.put("suit", new String[]{Suit.DIAMONDS.name()});
        parameters.put("airDate", new String[]{"2010-08-01 20:00"});
        when(req.getParameterMap()).thenReturn(parameters);
        when(req.getParameter(IMPLICIT_PARAM)).thenReturn(IMPLICIT_VALUE);
        when(req.getParameter(EXPLICIT_PARAM)).thenReturn(EXPLICIT_VALUE);
        when(req.getParameter("page")).thenReturn("1");
        when(req.getParameter("pageSize")).thenReturn("25");
        when(req.getParameter("suit")).thenReturn(Suit.DIAMONDS.name());
        when(req.getParameter("airDate")).thenReturn("2010-08-01 20:00");

        Vector<String> headerNames = new Vector<String>();
        headerNames.add("Cache-Control");
        when(req.getHeaderNames()).thenReturn(headerNames.elements());
        when(req.getHeader("Cache-Control")).thenReturn("no-cache");

        Cookie[] cookies = new Cookie[]{new Cookie("chocolate", "chip")};
        when(req.getCookies()).thenReturn(cookies);

        return req;
    }
}