/**
 * Copyright 2011 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.controllers;

import java.sql.Timestamp;
import java.text.DecimalFormat;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import net.sf.json.JSONException;
import net.sf.json.JSONObject;
import net.sf.json.JSONSerializer;

import org.apache.commons.collections.map.HashedMap;
import org.apache.log4j.Logger;
import org.kuali.mobility.push.entity.Device;
import org.kuali.mobility.push.service.DeviceService;
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.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;


/**
 * Controller for managing devices
 * 
 * @author Kuali Mobility Team (mobility.dev@kuali.org)
 * @since 2.0.0
 */
@Controller 
@RequestMapping("/device")
public class DeviceController {

        /** A reference to a logger */
        private static final Logger LOG = Logger.getLogger(DeviceController.class);
        
        /**
         * A reference to the Controllers <code>DeviceService</code> object.
         */
        @Autowired
        private DeviceService deviceService;

        /**
         *  A reference to the Controllers <code>UserDao</code> object. 
         */
        @Autowired
        @Qualifier("kmeUserDao")
        private UserDao userDao;
        
        /**
         * A controller method for loading the main index.jsp for the Device tool.
         * 
         * @param uiModel
         * @return
         */
        @RequestMapping(method = RequestMethod.GET)
        public String index(Model uiModel, HttpServletRequest request) {
        Cookie cks[] = request.getCookies();
        String deviceIdentifier = "";
        if (cks != null) {
                for(Cookie c : cks){
                    if(c.getName().equals("device.identifier")){
                        deviceIdentifier = c.getValue();
                    }
                }
        }
        
        Device thisDevice = null;
        if(!deviceIdentifier.equals("")){
                thisDevice = deviceService.findDeviceByDeviceId(deviceIdentifier);
        }
        
        DecimalFormat df = new DecimalFormat("###,###,###,###.###");
        uiModel.addAttribute("totalDeviceCount", df.format(deviceService.countDevices()));      
        uiModel.addAttribute("thisDevice", thisDevice);
                return "device/index";
        }

        /**
         * A controller method for loading the keyword device search page. 
         * 
         * @param uiModel
         * @param request
         * @return
         */
        @RequestMapping(value="search", method = RequestMethod.GET)
    public String search(Model uiModel, HttpServletRequest request) {
                return "device/search";
    }  
        
        /**
         * A Controller method for accessing the details of a given device and displaying it in the association jsp file. 
         * 
         * @param uiModel
         * @param request
         * @param deviceHash Id of the device to show. 
         * @return
         */
        @SuppressWarnings("unchecked")
        @RequestMapping(value = "/detail/{deviceHash}", method = RequestMethod.GET)
        public String getUserDetails(Model uiModel, HttpServletRequest request, @PathVariable("deviceHash") String deviceHash) {
                if (deviceHash != null) {
                        LOG.debug("DeviceID is :" + deviceHash);
                }else{
                        return "push";
                }
                Device device = getDeviceService().findDeviceByDeviceId(deviceHash);
                uiModel.addAttribute("device", device);
                uiModel.addAttribute("deviceHash", deviceHash);
                return "device/devicedetail";
        }

        /**
         * A controller method for accessing a deleting a specified device. 
         * 
         * @param uiModel
         * @param request
         * @param deviceHash Id of the device to delete. 
         * @return
         */
        @SuppressWarnings("unchecked")
        @RequestMapping(value = "/remove/{deviceHash}", method = RequestMethod.GET)
        public String removeDevice(Model uiModel, HttpServletRequest request, @PathVariable("deviceHash") String deviceHash) {
                Device deviceToDelete = getDeviceService().findDeviceByDeviceId(deviceHash);
                if(deviceToDelete != null){
                        LOG.debug("Will delete device with Id: " + deviceToDelete.getId());
                        if(getDeviceService().removeDevice(deviceToDelete)){
                                LOG.debug("Did delete device.");
                        }
                }
//              return "redirect:../list";
                return "redirect:/device";
        }       
        
        /**
         * A controller method for accessing all devices registered with push notifications. 
         * 
         * @param request
         * @param uiModel
         * @param key
         * @return
         */
        @RequestMapping(value = "/list", method = RequestMethod.GET)
        public String devices(HttpServletRequest request, Model uiModel, @RequestParam(value="key", required=false) String key) { 
                
                Long deviceCount = getDeviceService().countDevices();
                int deviceNoUserCount = getDeviceService().countDevicesWithoutUsername();
                List<String> deviceTypes = getDeviceService().getSupportedDeviceTypes();
                Map<String, List<Device>> devicesMap = getDeviceService().findDevicesMap();
                Map<String, Long> deviceCountMap = new HashedMap();
                for(String deviceType : deviceTypes){
                        Long count = new Long(getDeviceService().countDevices(deviceType));
                        deviceCountMap.put(deviceType, count);
                }

                uiModel.addAttribute("deviceNoUserCount", deviceNoUserCount);
                uiModel.addAttribute("deviceCount", deviceCount);
                uiModel.addAttribute("deviceTypes", deviceTypes);
                uiModel.addAttribute("devicesMap", devicesMap);
                uiModel.addAttribute("deviceCountMap", deviceCountMap);

                return "device/devices";
        }
                
        /**
         * A controller method for registering a device for push notifications as defined by a JSON formatted string. 
         * 
         * @param request
         * @param data JSON formatted string describing a device to be register for push notifications. 
         * @return
         */
        @RequestMapping(value = "/register", method = RequestMethod.GET)
        public ResponseEntity<String> register(HttpServletRequest request, @RequestParam(value="data", required=true) String data) {
                LOG.info("-----Register-----");
                if(data == null){
                        return new ResponseEntity<String>(HttpStatus.NO_CONTENT);
                } 

                JSONObject queryParams;
                try{
                        queryParams = (JSONObject) JSONSerializer.toJSON(data);
                        LOG.info(queryParams.toString());
                }catch(JSONException je){
                        LOG.error("JSONException in :" + data + " : " + je.getMessage());
                        return new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
                }
                        
                Device device = new Device();
                device.setDeviceName(queryParams.getString("name"));
                device.setDeviceId(queryParams.getString("deviceId"));
                device.setRegId(queryParams.getString("regId"));
                device.setType(queryParams.getString("type"));
                
                // We might not have a username yet
                if (queryParams.containsKey("username")){
                        device.setUsername(queryParams.getString("username"));
                }
                device.setPostedTimestamp(new Timestamp(System.currentTimeMillis()));
                LOG.info("\n-----New Device-----" + device.toString());

                Device temp = getDeviceService().findDeviceByDeviceId(device.getDeviceId());

                User user = (User)request.getSession().getAttribute(AuthenticationConstants.KME_USER_KEY);
                if( user == null ) {
                        LOG.error("No user found in request. This should never happen!");
                } else if( user.isPublicUser() ) {
                        LOG.debug("Public user found, no user profile updates necessary.");
                } else if( !user.getLoginName().equals(device.getUsername()) ) {
                        LOG.debug("User on device does not match user in session! This should never happen either.");
                } else if( user.attributeExists(AuthenticationConstants.DEVICE_ID,device.getDeviceId())) {
                        LOG.debug("Device id already exists on user and no action needs to be taken.");
                } else {
                        user.addAttribute(AuthenticationConstants.DEVICE_ID,device.getDeviceId());
                        getUserDao().saveUser(user);
                }

                // If the device already exists, update. 
                try {
                        if(temp != null){
                                LOG.info("-----Device already exists." + temp.toString());
                                temp.setDeviceName(queryParams.getString("name"));
                                temp.setRegId(queryParams.getString("regId"));
                                temp.setType(queryParams.getString("type"));
                                // We might not have a username yet
                                if (queryParams.containsKey("username")){
                                        temp.setUsername(queryParams.getString("username"));
                                }
                                temp.setPostedTimestamp(new Timestamp(System.currentTimeMillis()));
                                getDeviceService().saveDevice(temp);
                        }else{
                                LOG.info("-----Device Doesn't already exist." + device.toString());
                                getDeviceService().saveDevice(device);
                        }
                } catch (Exception e) {
                        LOG.error("Exception while trying to update device", e);
                        return new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
                }               
                
                return new ResponseEntity<String>(HttpStatus.OK);
        }
        
        /**
         * A controller method for updating a pre-existing registered device. 
         * 
         * @param request
         * @param data A JSON formatted string describing details of a device to update. 
         * @return
         */
        @RequestMapping(value = "/update", method = RequestMethod.GET)
        public ResponseEntity<String> update(HttpServletRequest request,@RequestParam(value="data", required=true) String data) {
                LOG.info("-----Register-----");
                if(data == null){
                        return new ResponseEntity<String>(HttpStatus.NO_CONTENT);
                } 

                JSONObject queryParams;
                try{
                        queryParams = (JSONObject) JSONSerializer.toJSON(data);
                        LOG.info(queryParams.toString());
                }catch(JSONException je){
                        LOG.error("JSONException in :" + data + " : " + je.getMessage());
                        return new ResponseEntity<String>(HttpStatus.BAD_REQUEST);
                }

                Device temp = getDeviceService().findDeviceByDeviceId(queryParams.getString("deviceId"));

                // If the device already exists, update.
                if(temp != null){
                        LOG.info("-----Device already exists." + temp.toString());
                        // Remove this device from the logged user's profile if it exists.
                        User user = getUserDao().loadUserByLoginName(temp.getUsername());
                        if( user != null ) {
                                user.removeAttribute(AuthenticationConstants.DEVICE_ID,temp.getDeviceId());
                                getUserDao().saveUser(user);
                        }
                        temp.setDeviceName(queryParams.getString("name"));
                        temp.setUsername(queryParams.getString("username"));
                        temp.setPostedTimestamp(new Timestamp(System.currentTimeMillis()));
                        getDeviceService().saveDevice(temp);

                        // Find the real user and set the new device.
                        User user2 = (User)request.getSession().getAttribute(AuthenticationConstants.KME_USER_KEY);
                        if( user2 == null ) {
                                LOG.error("No user found in request. This should never happen!");
                        } else if( user2.isPublicUser() ) {
                                LOG.debug("Public user found, no user profile updates necessary.");
                        } else if( !user2.getLoginName().equals(temp.getUsername()) ) {
                                LOG.debug("User on device does not match user in session! This should never happen either.");
                        } else if( user2.attributeExists(AuthenticationConstants.DEVICE_ID,temp.getDeviceId())) {
                                LOG.debug("Device id already exists on user and no action needs to be taken.");
                        } else {
                                user2.addAttribute(AuthenticationConstants.DEVICE_ID,temp.getDeviceId());
                                getUserDao().saveUser(user2);
                        }

                }

                return new ResponseEntity<String>(HttpStatus.OK);
        }
        
        /**
         * A controller method for checking the existance of a device, and accessing basic details of said device. 
         * 
         * @param uiModel
         * @param request
         * @param deviceId Id of device to check. 
         * @return String - A JSON formatted string giving basic details of the specified device. 
         */
        @RequestMapping(value = "/deviceid", method = RequestMethod.POST)
        @ResponseBody
        public String getUsernameFromDeviceID(Model uiModel, HttpServletRequest request, @RequestParam(value="deviceid", required=false) String deviceId) {
                Device device = getDeviceService().findDeviceByDeviceId(deviceId);
                if(device == null){
                        return "{\"deviceExists\":false}";                      
                }
                if(device.getUsername() == null || device.getUsername().length() == 0){
                        return "{\"deviceExists\":true,\"hasUsername\":false}";
                }else{
                        return "{\"deviceExists\":true,\"hasUsername\":true,\"username\":\"" + device.getUsername() + "\"}";
                }
        }  

        /**
         * A controller method for accessing all devices registered the correspond to a specified user. 
         * 
         * @param uiModel
         * @param request
         * @param username Username associated with devices to access. 
         * @return String - A JSON formatted string listing devices associated with a username. 
         */
        @RequestMapping(value = "/username", method = RequestMethod.POST)
        @ResponseBody
        public String getDevicesFromUsername(Model uiModel, HttpServletRequest request, @RequestParam(value="username", required=false) String username) {
                // TODO use JSONObject to build json here??
                List<Device> devices = getDeviceService().findDevicesByUsername(username);
                String result = "{\"username\":\"" + username + "\",\"devices\":[";
                String sDevices = "";
                Iterator<Device> i = devices.iterator();
                
                while(i.hasNext()){
                        Device d = (Device)i.next();
                        sDevices += "\"" + d.getDeviceId() + "\"," ;
                }
                
                if(sDevices.length() > 0){
                        sDevices = sDevices.substring(0, sDevices.length() - 1);
                }
                
                result += sDevices + "]}";
                return result;
        }
        
        /**
         * A controller method that provides an interface for search devices via keyword and returns a JSON list to the requesting JSP/HMLT page. 
         * 
         * @param request
         * @param response
         * @param uiModel
         * @param keyword
         * @return
         */
    @RequestMapping(value = "keyword/{keyword}", method = RequestMethod.GET, headers = "Accept=application/json")
    @ResponseBody
    public String devicesByKeyword(HttpServletRequest request, HttpServletResponse response, Model uiModel, @PathVariable("keyword") String keyword) {  
                List<Device> devices = deviceService.findDevicesByKeyword(keyword);
                LOG.info(devices.size() + " elements returned.");

                String json = "";
                if(devices.size() > 0){
                        Iterator<Device> i = devices.iterator();  
                        if(devices.size() > 1){
                                json = "{\"total\":\"" + devices.size() + " Devices Found.\" , \"devices\":[";
                        }else{
                                json = "{\"total\":\"" + devices.size() + " Device Found.\" , \"devices\":[";
                        }                       
                        while(i.hasNext()){
                                json += ((Device)i.next()).toJson();
                                json += ",";
                        }
                        json = json.substring(0, json.length()-1);
                        json += "]}";           
                }else{
                        json = "{\"total\":\"No Devices Found\"}";
                }
                
                return json;
    }
        
        
        /**
         * Simple controller which responds with 200.
         * This controller can be used by devices to check if the server is online
         * @return
         */
        @RequestMapping(value = "/ping", method = RequestMethod.GET)
        public ResponseEntity<String> ping() {
                return new ResponseEntity<String>(HttpStatus.OK);
        }       

        /**
         * Sets the reference to the <code>DeviceService</code>
         * @param deviceService
         */
        public void setDeviceService(DeviceService deviceService){
                this.deviceService = deviceService;
        }

        /**
         * A reference to the <code>DeviceService</code>.
         */
        public DeviceService getDeviceService() {
                return deviceService;
        }

        /**
         * Get the controllers <code>UserDao</code> object.
         * @return
         */
        public UserDao getUserDao() {
                return userDao;
        }

        /**
         * A method for setting the <code>UserDao</code> of the controller. 
         * 
         * @param userDao
         */
        public void setUserDao(UserDao userDao) {
                this.userDao = userDao;
        }
}