/**
 * Copyright 2011-2013 The Kuali Foundation Licensed under the
 * Educational Community 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.osedu.org/licenses/ECL-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.kuali.mobility.push.controller;

import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.when;

import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.TimeZone;

import net.sf.json.JSONSerializer;

import org.apache.log4j.Logger;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.kuali.mobility.push.controllers.PreferencesController;
import org.kuali.mobility.push.entity.Preference;
import org.kuali.mobility.push.entity.Sender;
import org.kuali.mobility.push.service.PreferenceService;
import org.kuali.mobility.push.service.SenderService;
import org.kuali.mobility.security.authn.util.AuthenticationConstants;
import org.kuali.mobility.security.user.api.User;
import org.kuali.mobility.security.user.api.UserDao;
import org.kuali.mobility.security.user.entity.UserImpl;
import org.mockito.Mock;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.mock.web.MockHttpServletRequest;
import org.springframework.mock.web.MockHttpServletResponse;
import org.springframework.mock.web.MockHttpSession;
import org.springframework.mock.web.MockServletContext;
import org.springframework.ui.ExtendedModelMap;
import org.springframework.ui.Model;

/**
 * @author Kuali Mobility Team (mobility.collab@kuali.org)
 */
/**
 * @author mtwagner
 *
 */
@RunWith(org.mockito.runners.MockitoJUnitRunner.class)
public class PreferencesControllerTest {

        /** A reference to a logger */
        private static final Logger LOG = Logger.getLogger(PreferencesControllerTest.class);
        
        private static MockServletContext servletContext;
        private PreferencesController controller;
        @Mock
    private PreferenceService prefService;

        @Mock
    private SenderService senderService;
        
        private MockHttpServletRequest request;
        private MockHttpServletResponse response;
        private Model uiModel;

        @Mock
        private Preference preference;
        @Mock
        private User user;
        @Mock
        private UserDao userDao;
        
        
        @BeforeClass
        public static void setUpClass() throws Exception {
                servletContext = new MockServletContext();
        }
        
        @Before
        public void preTest() {
                this.setController(new PreferencesController());
                this.getController().setPreferenceService(prefService);
                this.getController().setSenderService(senderService);
                this.setRequest(new MockHttpServletRequest(servletContext));
                this.setResponse(new MockHttpServletResponse());
                this.setUiModel(new ExtendedModelMap());
                this.getRequest().setSession(new MockHttpSession(servletContext));
                this.getRequest().getSession().setAttribute(AuthenticationConstants.KME_USER_KEY, getUser());
        }

        @Test
        public void testPing() {
                ResponseEntity <String> responseEntity = getController().ping();
                ResponseEntity<String> expectedEntity = new ResponseEntity<String>(HttpStatus.OK);
                assertTrue("Expected response of OK was not found.",(expectedEntity.getStatusCode()).equals(responseEntity.getStatusCode()));
        }
        
        @Test
        public void testLogin() {
                String viewName = getController().login(getRequest(), getUiModel(), "key");
                List<Sender> senders = new ArrayList<Sender>();
                when(getSenderService().findAllSenders()).thenReturn(senders);
                assertTrue("View name does not match expected value.","redirect:/pushprefs".equals(viewName));
        }
        
        @Test
        public void testGetPreferencesWithNullUsername(){
                String expected = "{\"preferences\":[]}";
                User user = new UserImpl();
                List<Preference> preferences = new ArrayList<Preference>();
                when(getPrefService().findPreferencesByUsername("")).thenReturn(preferences);
                
                String output = getController().getPreferences(getUiModel(), getRequest(), "");         
                LOG.info("expected: [" + expected + "]");
                LOG.info("output:   [" + output + "]");
                assertTrue("Output does not match expected value.", expected.equals(output));
        }

        @Test
        public void testGetPreferencesWithUsername(){
                Timestamp ts = new Timestamp(123456789L);
                String timestampJson = new JSONSerializer().toJSON(ts).toString();
                String expected = "{\"preferences\":[{\"enabled\":false,\"id\":1,\"postedTimestamp\":"+timestampJson+",\"pushSenderID\":1,\"senderBlocked\":true,\"username\":\"userA\",\"versionNumber\":0}]}";
                Preference preference = new Preference();
                preference.setId(1L);
                preference.setPushSenderID(1L);
                preference.setUsername("userA");
                
                preference.setPostedTimestamp(ts);
                List<Preference> preferences = new ArrayList<Preference>();
                preferences.add(preference);
                
                when(getPrefService().findPreferencesByUsername("userA")).thenReturn(preferences);              
                String output = getController().getPreferences(getUiModel(), getRequest(), "userA");
                LOG.info("expected: [" + expected + "]");
                LOG.info("output:   [" + output + "]");

                assertTrue("Output does not match expected value.", expected.equals(output));
        }
        
        @Test
        public void testRegisterNewPreferences() {
                String data = "{\"enabled\":true,\"username\":\"bob\",\"senderId\":1}";
                when(getPrefService().findPreference(any(String.class), any(Sender.class))).thenReturn(null);
                ResponseEntity<String> responseEntity = getController().register(data);
                ResponseEntity<String> expectedEntity = new ResponseEntity<String>(HttpStatus.OK);
                assertTrue("Expected response of OK was not found.", (expectedEntity.getStatusCode()).equals(responseEntity.getStatusCode()));
        }

        @Test
        public void testRegisterPreferencesWithInvalidData() {
                String data = "{\"enabled:true,\"username\":\"bob\",\"senderId\":1}";
                when(getPrefService().findPreference(any(String.class), any(Sender.class))).thenReturn(null);
                ResponseEntity<String> responseEntity = getController().register(data);
                ResponseEntity<String> expectedEntity = new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
                assertTrue("Expected response of BAD_REQUEST was not found.", (expectedEntity.getStatusCode()).equals(responseEntity.getStatusCode()));
        }

        @Test
        public void testRegisterPreferencesWithNullData() {
                when(getPrefService().findPreference(any(String.class), any(Sender.class))).thenReturn(null);
                ResponseEntity<String> responseEntity = getController().register(null);
                ResponseEntity<String> expectedEntity = new ResponseEntity<String>(HttpStatus.NO_CONTENT);
                assertTrue("Expected response of NO_CONTENT was not found.", (expectedEntity.getStatusCode()).equals(responseEntity.getStatusCode()));
        }
        
        /**
         * @return the servletContext
         */
        public static MockServletContext getServletContext() {
                return servletContext;
        }
        /**
         * @param servletContext the servletContext to set
         */
        public static void setServletContext(MockServletContext servletContext) {
                PreferencesControllerTest.servletContext = servletContext;
        }
        /**
         * @return the controller
         */
        public PreferencesController getController() {
                return controller;
        }
        /**
         * @param controller the controller to set
         */
        public void setController(PreferencesController controller) {
                this.controller = controller;
        }

        
        
        /**
         * @return the prefService
         */
        public PreferenceService getPrefService() {
                return prefService;
        }

        /**
         * @param prefService the prefService to set
         */
        public void setPrefService(PreferenceService prefService) {
                this.prefService = prefService;
        }

        /**
         * @return the senderService
         */
        public SenderService getSenderService() {
                return senderService;
        }

        /**
         * @param senderService the senderService to set
         */
        public void setSenderService(SenderService senderService) {
                this.senderService = senderService;
        }

        /**
         * @return the request
         */
        public MockHttpServletRequest getRequest() {
                return request;
        }
        /**
         * @param request the request to set
         */
        public void setRequest(MockHttpServletRequest request) {
                this.request = request;
        }
        /**
         * @return the response
         */
        public MockHttpServletResponse getResponse() {
                return response;
        }
        /**
         * @param response the response to set
         */
        public void setResponse(MockHttpServletResponse response) {
                this.response = response;
        }
        /**
         * @return the uiModel
         */
        public Model getUiModel() {
                return uiModel;
        }
        /**
         * @param uiModel the uiModel to set
         */
        public void setUiModel(Model uiModel) {
                this.uiModel = uiModel;
        }
        /**
         * @return the preference
         */
        public Preference getPreference() {
                return preference;
        }

        /**
         * @param preference the preference to set
         */
        public void setPreference(Preference preference) {
                this.preference = preference;
        }

        /**
         * @return the user
         */
        public User getUser() {
                return user;
        }
        /**
         * @param user the user to set
         */
        public void setUser(User user) {
                this.user = user;
        }
        /**
         * @return the userDao
         */
        public UserDao getUserDao() {
                return userDao;
        }
        /**
         * @param userDao the userDao to set
         */
        public void setUserDao(UserDao userDao) {
                this.userDao = userDao;
        }
        
        
}