package art.servers.transactionsserver.controller;


import art.library.interop.InteropParameter;
import art.library.interop.InteropParameters;
import art.library.interop.InteropResponse;
import art.library.interop.serialization.Serialization;
import art.library.interop.serialization.SerializationException;
import art.library.model.devices.Device;
import art.library.model.devices.DeviceAction;
import art.library.model.devices.DeviceActionResult;
import art.library.model.devices.DeviceCommands;
import art.library.model.devices.application.Application;
import art.library.model.devices.application.ApplicationInformation;
import art.library.model.devices.user.User;
import art.library.model.devices.user.UserConfiguration;
import art.library.model.devices.user.UserInformation;
import art.library.model.devices.user.UserPermission;
import art.library.model.devices.user.configuration.UserConfigurationPermissionInterop;
import art.library.model.devices.user.configuration.UserConfigurationPermissionInteropParameter;
import art.library.model.general.ModelFile;
import art.library.model.transactions.alarms.DeviceAlarmCommands;
import art.library.model.transactions.commands.ScheduledTaskProcedureCommands;
import art.library.model.transactions.scheduler.ScheduledTask;
import art.library.model.transactions.scheduler.ScheduledTaskProcedure;
import art.library.model.transactions.scheduler.ScheduledTaskProcedureInterval;
import art.library.model.transactions.tutor.trafficalerts.TrafficAlertProcedure;
import art.library.utils.licence.Licence;
import art.library.utils.resources.Resources;
import art.servers.transactionsserver.Shared;
import eu.medsea.mimeutil.MimeUtil2;
import java.io.File;
import java.io.FileOutputStream;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;



public class ListenerImplementation extends art.servers.controller.ListenerImplementation
{
    
    public ListenerImplementation()
    {
    }


    // <editor-fold defaultstate="collapsed" desc="Java libraries">    

    public InteropResponse listJavaLibraries (InteropParameters parameters) throws SerializationException 
    {
        String language = (String)parameters.getParameterValue("language");        
           
        try
        {
            
//            String folderName = (String)parameters.getParameterValue("folder");            
//            String folder = "data/" + Shared.getApplicationName() + "/";
//            if (folderName != null) folder = folder + folderName + "/";
//
//            File directory = new File(folder);
//            List<File> lfiles = new ArrayList<File>();
//            listFiles(directory, lfiles);
//            List<ModelFile> lmodelfile = new ArrayList<ModelFile>();
//                
//            for (File file : lfiles)
//            {
//                try
//                {
//                    if (file.isFile() == true)
//                    {
//                        ModelFile modelFile = new ModelFile();
//                        modelFile.folder = file.getAbsolutePath().replace(directory.getAbsolutePath(), "").replace("\\", "/").replaceFirst("/", "").replaceAll(file.getName(), "");
//                        if (folderName != null) modelFile.folder = modelFile.folder + "/" + folderName;
//                        modelFile.name = file.getName().substring(0, file.getName().lastIndexOf('.'));
//                        modelFile.extension = file.getName().substring(file.getName().lastIndexOf('.') + 1, file.getName().length());
//                        
//                        if (modelFile.extension.equalsIgnoreCase("svg"))
//                        {
//                            modelFile.mime = "image/svg+xml";
//                        }
//                        else
//                        {
//                            MimeUtil2 mimeUtil = new MimeUtil2();
//                            mimeUtil.registerMimeDetector("eu.medsea.mimeutil.detector.MagicMimeMimeDetector");
//                            modelFile.mime = MimeUtil2.getMostSpecificMimeType(mimeUtil.getMimeTypes(file)).toString();
//                        }
//                        
//                        lmodelfile.add(modelFile);
//                    }
//                }
//                catch (Exception e)
//                {
//                }
//            }
//
//            InteropResponse response = new InteropResponse(lmodelfile.toArray(new ModelFile[lmodelfile.size()]));
//            return response;
            throw new Exception("Not implemented");
        }
        catch (Exception e)
        {
            throw getException(language, e);
        }
    }        



    
    
    public InteropResponse getJavaLibrary (InteropParameters parameters) throws SerializationException 
    {
        String language = (String)parameters.getParameterValue("language");        
           
        try
        {
            byte[] data = Resources.getExternalFileBytes(getFileName(parameters));
            if (data.length == 0) data = Resources.getResourceBytes(getFileName(parameters));
            InteropResponse response = new InteropResponse(data);
            return response;
        }
        catch (Exception e)
        {
            throw getException(language, e);
        }
    }        
    
    // </editor-fold>    
    

    //<editor-fold defaultstate="collapsed" desc="Alarms">   
        /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "set" class: <code>addAlarmAction</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "username" class: <code>String</code>
     * <p>name: "computer" class: <code>String</code>
     * <p>name: "device" class: <code>String</code> device identifier who alarms belongs
     * <p>name: "alarm" class: <code>String</code>  Identifier of the alarm that is being validated, confirmed or cancelled
     * <p>name: "type" class: <code>Int</code>  type of action with alarm (DeviceAlarmCommands.TYPE_ALARM_VALIDATE, DeviceAlarmCommands.TYPE_ALARM_CONFIRM or DeviceAlarmCommands.TYPE_ALARM_CANCEL)
     * @return <code>InteropResponse</code> 
     * @return <code>InteropResponse</code> with <code>true Boolean</code> if success
     * @throws SerializationException 
     */
    
    public InteropResponse addAlarmAction(InteropParameters parameters) throws SerializationException
    {
        String language = (String) parameters.getParameterValue("language");

        try
        {
            String username = (String) parameters.getParameterValue("username");
            String computer = (String) parameters.getParameterValue("computer");
//            String identifier = (String) parameters.getParameterValue("device");
//            String alarm = (String) parameters.getParameterValue("alarm");
//            int type = (parameters.hasParameter("type") == true) ? Integer.parseInt((String)parameters.getParameterValue("type")) : DeviceAlarmCommands.TYPE_ALARM_NOTHING;

            DeviceAlarmCommands deviceAlarmCommands = parameters.getBodyContentValue(DeviceAlarmCommands.class);

            Device device = null;

            try
            {
                device = Shared.model.getDeviceExternal(deviceAlarmCommands.deviceIdentifier);
            }
            catch (Exception exception)
            {
                throw new SerializationException(Shared.getMessage(language, "Device does not exist"), exception);
            }

            DeviceAction action = new DeviceAction(device, parameters, deviceAlarmCommands);
            
            action.actionName = deviceAlarmCommands.getActionName();
            
            DeviceActionResult result = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(result);

            Shared.model.addAction(action);

            return new InteropResponse(true);
        }
        catch (SerializationException exception)
        {
            throw exception;
        }
        catch (Exception e)
        {
            throw new SerializationException(Shared.getMessage(language, "Error inserting alarm action"), e.getMessage());
        }
    }

    //</editor-fold>
    
    //<editor-fold defaultstate="collapsed" desc="ExternalLayers">
    
    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "set" class: <code>createExternalLayer</code>
    * <p>name: "language" class: <code>String</code>
    * <p>name: "lExternalLayer" class: <code>ExternalLayer[]</code>
    * @return <code>InteropResponse</code>
    * <code>Boolean</code>
    * @throws SerializationException 
    */
    public InteropResponse createExternalLayer(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelExternalLayers.createExternalLayer(parameters);
    }

    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "set" class: <code>readExternalLayer</code>
    * <p>name: "language" class: <code>String</code>
    * <p>name: "externalLayerName" class: <code>String</code>
    * @return <code>InteropResponse</code>
    * <code>ExternalLayer</code>
    * @throws SerializationException 
    */
    public InteropResponse readExternalLayer(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelExternalLayers.readExternalLayer(parameters);
    }

    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "get" class: <code>getExternalLayers</code>
    * <p>name: "language" class: <code>String</code>
    * @return <code>InteropResponse</code>
    * <code>ExternalLayer[]</code>
    * @throws SerializationException 
    */
    public InteropResponse getExternalLayers(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelExternalLayers.getExternalLayers(parameters);
    }

    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "set" class: <code>updateExternalLayer</code>
    * <p>name: "language" class: <code>String</code>
    * <p>name: "lExternalLayer" class: <code>ExternalLayer[]</code>
    * @return <code>InteropResponse</code>
    * <code>Boolean</code>
    * @throws SerializationException 
    */
    public InteropResponse updateExternalLayer(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelExternalLayers.updateExternalLayer(parameters);
    }
    
    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "set" class: <code>deleteExternalLayer</code>
    * <p>name: "language" class: <code>String</code>
    * <p>name: "lName" class: <code>String[]</code>
    * @return <code>InteropResponse</code>
    * <code>Boolean</code>
    * @throws SerializationException 
    */
    public InteropResponse deleteExternalLayer(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelExternalLayers.deleteExternalLayer(parameters);
    }
    
    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "set" class: <code>existExternalLayer</code>
    * <p>name: "language" class: <code>String</code>
    * <p>name: "name" class: <code>String</code>
    * @return <code>InteropResponse</code>
    * <code>Boolean</code>
    * @throws SerializationException 
    */
    public InteropResponse existExternalLayer(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelExternalLayers.existExternalLayer(parameters);
    }
    //</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="GIS">
    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "set" class: <code>createConfigurationGeoline</code>
    * <p>name: "language" class: <code>String</code>
    * <p>name: "lGeoLine" class: <code>GeoLine[]</code>
    * @return <code>InteropResponse</code>
    * <code>Boolean</code>
    * @throws SerializationException 
    */
    public InteropResponse createConfigurationGeoline(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelConfigurationGeoline.createConfigurationGeoline(parameters);
    }

    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "set" class: <code>readConfigurationGeoline</code>
    * <p>name: "language" class: <code>String</code>
    * <p>name: "id" class: <code>Integer</code>
    * @return <code>InteropResponse</code>
    * <code>GeoLine</code>
    * @throws SerializationException 
    */
    public InteropResponse readConfigurationGeoline(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelConfigurationGeoline.readConfigurationGeoline(parameters);
    }

    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "set" class: <code>updateConfigurationGeoline</code>
    * <p>name: "language" class: <code>String</code>
    * <p>name: "lGeoLine" class: <code>GeoLine[]</code>
    * @return <code>InteropResponse</code>
    * <code>Boolean</code>
    * @throws SerializationException 
    */
    public InteropResponse updateConfigurationGeoline(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelConfigurationGeoline.updateConfigurationGeoline(parameters);
    }
    
    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "set" class: <code>deleteConfigurationGeoline</code>
    * <p>name: "language" class: <code>String</code>
    * <p>name: "lId" class: <code>Integer[]</code>
    * @return <code>InteropResponse</code>
    * <code>Boolean</code>
    * @throws SerializationException 
    */
    public InteropResponse deleteConfigurationGeoline(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelConfigurationGeoline.deleteConfigurationGeoline(parameters);
    }
    
    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "set" class: <code>existConfigurationGeoline</code>
    * <p>name: "language" class: <code>String</code>
    * <p>name: "id" class: <code>Integer</code>
    * @return <code>InteropResponse</code>
    * <code>Boolean</code>
    * @throws SerializationException 
    */
    public InteropResponse existConfigurationGeoline(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelConfigurationGeoline.existConfigurationGeoline(parameters);
    }
    
    /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>getLayerConfigurationByLayerAndZoom</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "geoline" class: <code>GeoLine</code>
     * @return <code>InteropResponse</code>
     * <code>GeoLine[]</code>
     * @throws SerializationException 
     */
    public InteropResponse getLayerConfigurationByLayerAndZoom(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelConfigurationGeoline.getLayerConfigurationByLayerAndZoom(parameters);
    }
    

    /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>getLayerConfigurationByLayerName</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "layerName" class: <code>String</code>
     * @return <code>InteropResponse</code>
     * <code>GeoLine[]</code>
     * @throws SerializationException 
     */
    public InteropResponse getLayerConfigurationByLayerName(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelConfigurationGeoline.getLayerConfigurationByLayerName(parameters);
    }
    //</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="Users">   
    /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "set" class: <code>addDevices</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "body-content" class: <code>String[]</code>
     * @return <code>InteropResponse</code> 
     * @return <code>InteropResponse</code> with <code>true Boolean</code> if success
     * @throws SerializationException 
     */
    
    public InteropResponse addUsers(InteropParameters parameters) throws SerializationException
    {
        return addDevices(parameters);
    }
    
    public InteropResponse addDevices(InteropParameters parameters) throws SerializationException
    {
        InteropResponse response;
        String language = (String) parameters.getParameterValue("language");
        boolean updateRole = false;
        String username = "";

        try
        {
            User[] luser = parameters.getBodyContentValue(User[].class);

            for (User user : luser)
            {
                User currentuser = null;

                username = user.getIdentifier();
                createPermissions(user);

                try
                {
                    currentuser = (User)Shared.getModel().getDevice(user.getIdentifier());
                }
                catch (Exception e)
                {
                    try
                    {
                        currentuser = (User)Shared.getModel().getDevice(Licence.encrypt(user.getIdentifier()));
                    }
                    catch (Exception ex)
                    {
                        currentuser = null;
                    }
                }

                if (currentuser != null) {
                    try
                    {
                        if (currentuser.getDeviceInformation().role.equals(user.getDeviceInformation().role) == false)
                        {
                            updateRole = true;
                        }
                    } catch (Exception ex) {
                    }
                }
            }

            Shared.model.updateDevice(luser);

            if (updateRole == true)
            {
                String resource = Shared.getMessage(language, "Username") + " : " + username;
                Shared.traceInformation(Shared.getApplicationName(), Shared.getMessage(language, "Profile update"), resource, null, language);
            }

            return new InteropResponse(true);
        }
        catch (Exception e)
        {
            String resource = Shared.getMessage(language, "Username") + " : " + username;
            Shared.traceError(Shared.getApplicationName(), Shared.getMessage(language, "Profile update"), resource, e, null, language);
            throw new SerializationException("error inserting some users", e.getMessage());
        }
    }


    private void createPermissions (User user) throws Exception
    {
        User userRole = null;

        try
        {
            userRole = (User)Shared.getModel().getDevice(Licence.encrypt(user.getDeviceInformation().role));
        }
        catch (Exception exception)
        {
            try
            {
                userRole = (User)Shared.getModel().getDevice(user.getDeviceInformation().role);
            }
            catch (Exception e)
            {
                
            }
        }

        if (userRole != null)
        {
            user.configuration = userRole.configuration;
        }
        else
        {
            if (user.getDeviceConfiguration() == null)
            {
                user.configuration = new UserConfiguration();
                if (user.getDeviceConfiguration().permissions == null)
                {
                    user.getDeviceConfiguration().permissions = new UserPermission();
                }
            }

            if ("IMH".equalsIgnoreCase(user.getDeviceInformation().role))
            {
                user.getDeviceConfiguration().permissions.linterop.clear();

                String regex = "[\\s\\S]*";
                UserConfigurationPermissionInterop interopGetGeoJson = new UserConfigurationPermissionInterop();
                interopGetGeoJson.operation = "^getGeoJson.*";
                interopGetGeoJson.application = "art.servers.zbe.ermserver";
                interopGetGeoJson.devicesAllow.add(regex);
                UserConfigurationPermissionInteropParameter permissionParameter = new UserConfigurationPermissionInteropParameter();
                permissionParameter.name = regex;
                permissionParameter.values.add(regex);
                interopGetGeoJson.parametersAllow.add(permissionParameter);
                user.getDeviceConfiguration().permissions.linterop.add(interopGetGeoJson);

                UserConfigurationPermissionInterop interopGetVehicle = new UserConfigurationPermissionInterop();
                interopGetVehicle.operation = "^getVehicle";
                interopGetVehicle.application = "art.servers.zbe.listserver";
                interopGetVehicle.devicesAllow.add(regex);
                UserConfigurationPermissionInteropParameter permissionParameterVehicle = new UserConfigurationPermissionInteropParameter();
                permissionParameterVehicle.name = regex;
                permissionParameterVehicle.values.add(regex);
                interopGetVehicle.parametersAllow.add(permissionParameterVehicle);
                user.getDeviceConfiguration().permissions.linterop.add(interopGetVehicle);
            }
            else
            {
                user.getDeviceConfiguration().permissions.linterop.clear();

                String regex = "[\\s\\S]*";
                UserConfigurationPermissionInterop interop = new UserConfigurationPermissionInterop();
                interop.actionsAllow.add(regex);
                interop.devicesAllow.add(regex);
                interop.application = regex;
                interop.operation = regex;
                UserConfigurationPermissionInteropParameter permissionParameter = new UserConfigurationPermissionInteropParameter();
                permissionParameter.name = regex;
                permissionParameter.values.add(regex);
                interop.parametersAllow.add(permissionParameter);
                user.getDeviceConfiguration().permissions.linterop.add(interop);
            }
        }
    }


    /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>getUsers</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "body-content" class: <code>String[]</code>
     * <p>name: "timestamp" class: <code>Long</code>* 
     * @return <code>InteropResponse</code> 
     * <code>User[]</code>
     * @throws SerializationException 
     */
    public InteropResponse getUsers(InteropParameters parameters) throws SerializationException
    {
        try
        {
            String language = parameters.hasParameter("language") ? parameters.getParameterValue("language") : Shared.getLanguage();
            String[] lusername = parameters.getBodyContentValue(String[].class);
            long timestamp = parameters.hasParameter("timestamp") ? getTimestamp(parameters.getParameterValue("timestamp")) : 0L;
            return new InteropResponse(Shared.getModel().getDevices(lusername, timestamp));
        } catch (Exception e)
        {
            throw new SerializationException(Shared.getMessage("error getting users"), e);
        }
    }
    
    /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>getUsersIdentification</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "lGroup" class: <code>String[]</code>
     * @return <code>InteropResponse</code> 
     * <code>UserIdentification[]</code>
     * @throws SerializationException 
     */
    public InteropResponse getUsersIdentification(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelUsers.getUsersIdentification(parameters);
    }
    
    /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>getUsersIdentification</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "lGroup" class: <code>String[]</code>
     * @return <code>InteropResponse</code> 
     * <code>UserIdentification[]</code>
     * @throws SerializationException 
     */
    public InteropResponse getUsersInformation(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelUsers.getUsersInformation(parameters);
    }
    
     /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>getUserLdap</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "username" class: <code>String</code>
     * @return <code>InteropResponse</code> 
     * <code>UserInformation</code>
     * @throws SerializationException 
     */
    public InteropResponse getUserLdap(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelUsers.getUserLdap(parameters);
    }
    

    /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "art" class: <code>updatePasswordUser</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "username" class: <code>String</code>
     * <p>name: "oldpassword" class: <code>String</code>
     * <p>name: "newpassword" class: <code>String</code>
     * @return <code>InteropResponse</code> 
     * @return <code>InteropResponse</code> with <code>true Boolean</code> if success
     * @throws SerializationException 
     */
    
    public InteropResponse updatePasswordUser(InteropParameters parameters) throws SerializationException
    {
        try
        {
            String language = parameters.hasParameter("language") ? parameters.getParameterValue("language") : Shared.getLanguage();
            String username = parameters.hasParameter("username") ? parameters.getParameterValue("username") : null;
            String oldpassword = parameters.hasParameter("oldpassword") ? parameters.getParameterValue("oldpassword") : null;
            String newpassword = parameters.hasParameter("newpassword") ? parameters.getParameterValue("newpassword") : null;

            if (username == null)
            {
                throw new SerializationException(Shared.getMessage(language, "Username cannot be null"));
            }
            else if (oldpassword == null)
            {
                throw new SerializationException(Shared.getMessage(language, "Old password cannot be null"));
            }
            else if (newpassword == null)
            {
                throw new SerializationException(Shared.getMessage(language, "New password cannot be null"));
            }

            User user = (User)Shared.getModel().getDevice(Licence.encrypt(username));
            String currentpassword = Licence.decrypt(user.getDeviceInformation().password);
            if (currentpassword.equals(oldpassword) == false)
            {
                throw new SerializationException(Shared.getMessage(language, "Old password is not correct"));
            }

            User newuser = Serialization.clone(user);
            newuser.getDeviceInformation().password = Licence.encrypt(newpassword);
            Shared.model.updateDevice(user, newuser);

            return new InteropResponse(new Boolean(true));
        }
        catch (SerializationException e)
        {
            throw e;
        }
        catch (Exception e)
        {
            throw new SerializationException(Shared.getMessage("Error updating user password"), e);
        }
    }

    //</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="Sessions">
    public InteropResponse login(InteropParameters parameters) throws SerializationException
    {
        InteropResponse response = startSession(parameters);
        return response;
    }
    
     /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>startSession</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "identification" class: <code>SessionIdentification</code>
     * <p>name: "lUserIdentification" class: <code>UserIdentification[]</code>
     * @return <code>InteropResponse</code> 
     * <code>Session</code>
     * @throws SerializationException 
     */
    public InteropResponse startSession(InteropParameters parameters) throws SerializationException
    {
        InteropResponse response = Shared.getModel().modelSessions.startSession(parameters);
        return response;
    }

     /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>addUsersSession</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "session" class: <code>Session</code>
     * <p>name: "lUserIdentification" class: <code>UserIdentification[]</code>
     * @return <code>InteropResponse</code> 
     * <code>Session</code>
     * @throws SerializationException 
     */
    public InteropResponse addUsersSession(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelSessions.addUsersSession(parameters);
    }

     /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>removeUsersSession</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "session" class: <code>Session</code>
     * <p>name: "lusername" class: <code>String[]</code>
     * @return <code>InteropResponse</code> 
     * <code>Session</code>
     * @throws SerializationException 
     */
    public InteropResponse removeUsersSession(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelSessions.removeUsersSession(parameters);
    }

     /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "set" class: <code>endSession</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "identification" class: <code>SessionIdentification</code>
     * @return <code>InteropResponse</code> 
     * <code>Boolean</code>
     * @throws SerializationException 
     */
    public InteropResponse endSession(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelSessions.endSession(parameters);
    }
    //</editor-fold>
    
       
    //<editor-fold defaultstate="collapsed" desc="Permissions">
    public InteropResponse checkToken(InteropParameters parameters) throws SerializationException
    {
        return new InteropResponse(new Boolean(true));
    }
    
     /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>getPermissions</code>
     * <p>name: "language" class: <code>String</code>
     * @return <code>InteropResponse</code> 
     * <code>ListPermission</code>
     * @throws SerializationException 
     */
    public InteropResponse getPermissions(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelPermissions.getPermissions(parameters);
    }
    
     /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>getUserPermission</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "lusername" class: <code>String[]</code>
     * <p>name: "timestamp" class: <code>Long</code>
     * @return <code>InteropResponse</code> 
     * <code>UserPermission</code>
     * @throws SerializationException 
     */
    public InteropResponse getUserPermission(InteropParameters parameters) throws SerializationException
    {
        try
        {
            return Shared.getModel().modelPermissions.getUserPermission(parameters);
        } catch (Exception ex)
        {
            throw new SerializationException(Shared.getMessage("Error getting user permissions"), ex);
        }
    }
    //</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="Alarms">
    /**
    * @param parameters <code>InteropParameters</code>
    * <p>name: "get" class: <code>getAlarmsInformation</code>
    * <p>name: "language" class: <code>String</code>
    * @return <code>InteropResponse</code> 
    * <code>AlarmInformation[]</code>
    * @throws SerializationException 
    */
    public InteropResponse getAlarmsInformation(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelAlarms.getAlarmsInformation(parameters);
    }

     /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>getAlarmsUserConfiguration</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "lusername" class: <code>String[]</code>
     * <p>name: "timestamp" class: <code>Long</code> *OPTIONAL
     * @return <code>InteropResponse</code> 
     * <code>UserAlarmConfiguration[]</code>
     * @throws SerializationException 
     */
    public InteropResponse getAlarmsUserConfiguration(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelAlarms.getAlarmsUserConfiguration(parameters);
    }
//</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="Messages">
    /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "get" class: <code>getConfigurationLanguage</code>
     * <p>name: "language" class: <code>String</code>
     * @return <code>InteropResponse</code> 
     * <code>ConfigurationLanguage</code>
     * @throws SerializationException 
    */
    public InteropResponse getConfigurationLanguage(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelMessages.getConfigurationLanguage(parameters);
    }

    /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "set" class: <code>setConfigurationLanguage</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "configurationLanguage" class: <code>String[]</code>
     * @return <code>InteropResponse</code> 
     * <code>Boolean</code>
     * @throws SerializationException 
    */
    public InteropResponse setConfigurationLanguage(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelMessages.setConfigurationLanguage(parameters);
    }
//</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="Applications">
    public InteropResponse getApplications(InteropParameters parameters) throws SerializationException
    {
        String language = (String) parameters.getParameterValue("language");
        long timestamp = 0;

        try
        {
            if (parameters.hasParameter("timestamp"))
            {
                timestamp = Long.parseLong((String) parameters.getParameterValue("timestamp"));
            }

            Application[] result = Shared.getModel().getApplications(timestamp);

            return new InteropResponse(result);
        } catch (Exception e)
        {
            String msg = "error getting applications";
            throw new SerializationException(e.getMessage());
        }
    }

    public InteropResponse getApplicationsInformation(InteropParameters parameters) throws SerializationException
    {
        String language = (String) parameters.getParameterValue("language");
        long timestamp = 0;
        try
        {
            if (parameters.hasParameter("timestamp"))
            {
                timestamp = Long.parseLong((String) parameters.getParameterValue("timestamp"));
            }

            Application[] lapplication = Shared.getModel().getApplications(timestamp);
            ApplicationInformation[] result = new ApplicationInformation[lapplication.length];

            for (int i = 0; i < lapplication.length; i++)
            {
                result[i] = lapplication[i].getDeviceInformation();
            }

            return new InteropResponse(result);
        } 
        catch (Exception e)
        {
            String msg = "error getting applications Information";
            throw new SerializationException(e.getMessage());
        }
    }
//</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="Login blocked Manager">
    /**
     * @param parameters <code>InteropParameters</code>
     * <p>
     * name: "language" class: <code>String</code>
     * @return <code>InteropResponse</code> <code>AddressLogin[0]</code>
     * @throws SerializationException
     */
    public InteropResponse getBlockedUsers(InteropParameters parameters) throws SerializationException {
        return Shared.getModel().loginBlockedManager.getBlockedUsers(parameters);
    }

    /**
     * @param parameters <code>InteropParameters</code>
     * <p>
     * name: "language" class: <code>String</code>
     * <p>
     * name: "body-content" class: <code>String[]</code>
     * @return <code>InteropResponse</code> <code>Boolean</code>
     * @throws SerializationException
     */
    public InteropResponse unlockUsers(InteropParameters parameters) throws SerializationException {
        try
        {
            return Shared.getModel().loginBlockedManager.unlockUsers(
                    parameters.getBodyContentValue(String[].class));
        } catch (Exception exception)
        {
            throw new SerializationException(Shared.getMessage(exception.getMessage()), exception);
        }
    }
    
        /**
     * @param parameters <code>InteropParameters</code>
     * <p>
     * name: "language" class: <code>String</code>
     * @return <code>InteropResponse</code> <code>AddressLogin[0]</code>
     * @throws SerializationException
     */
    public InteropResponse getBlockedIPAddresses(InteropParameters parameters) throws SerializationException {

        return Shared.getModel().loginBlockedManager.getBlockedIPAddresses(parameters);
    }

    /**
     * @param parameters <code>InteropParameters</code>
     * <p>
     * name: "language" class: <code>String</code>
     * <p>
     * name: "body-content" class: <code>String[]</code>
     * @return <code>InteropResponse</code> <code>Boolean</code>
     * @throws SerializationException
     */
    public InteropResponse unlockIPAddresses(InteropParameters parameters) throws SerializationException {
        try
        {
            return Shared.getModel().loginBlockedManager.unlockIPAddress(
                    parameters.getBodyContentValue(String[].class));
        } catch (Exception exception)
        {
            throw new SerializationException(Shared.getMessage(exception.getMessage()), exception);
        }
    }
//</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="Vms messages">
    public InteropResponse addVmsGeneralCommandsMessages(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsMessagesLibrary.addVmsGeneralCommandsMessages(parameters);
    }

    public InteropResponse removeVmsGeneralCommandsMessages(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsMessagesLibrary.removeVmsGeneralCommandsMessages(parameters);
    }
    
    public InteropResponse getVmsGeneralCommandsMessages(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsMessagesLibrary.getVmsGeneralCommandsMessages(parameters);
    }
    
    public InteropResponse getVmsGeneralCommandsMessagesFolders(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsMessagesLibrary.getVmsGeneralCommandsMessagesFolders(parameters);
    }
    
    public InteropResponse renameVmsGeneralCommandsMessagesFolder(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsMessagesLibrary.renameVmsGeneralCommandsMessagesFolder(parameters);
    }
    
    public InteropResponse getVmsGeneralCommandsMessageTypes(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsMessagesLibrary.getVmsGeneralCommandsMessageTypes(parameters);
    }
    
    public InteropResponse getVmsGeneralCommandsMessagesFoldersDevice(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsMessagesLibrary.getVmsGeneralCommandsMessagesFoldersDevice(parameters);
    }
    
    public InteropResponse getVmsGeneralCommandsMessagesDeviceFolder(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsMessagesLibrary.getVmsGeneralCommandsMessagesDeviceFolder(parameters);
    }
    //</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="Vms pictograms">
    public InteropResponse addVmsGeneralCommandsPictogram(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsPictogramsLibrary.addVmsGeneralCommandsPictogram(parameters);
    }

    public InteropResponse removeVmsGeneralCommandsPictogram(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsPictogramsLibrary.removeVmsGeneralCommandsPictogram(parameters);
    }
    
    public InteropResponse getVmsGeneralCommandsPictogram(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsPictogramsLibrary.getVmsGeneralCommandsPictogram(parameters);
    }
    
    public InteropResponse getVmsGeneralCommandsPictogramFolders(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsPictogramsLibrary.getVmsGeneralCommandsPictogramFolders(parameters);
    }
    
    public InteropResponse renameVmsGeneralCommandsPictogramFolder(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsPictogramsLibrary.renameVmsGeneralCommandsPictogramFolder(parameters);
    }
    
    public InteropResponse getVmsGeneralCommandsPictogramTypes(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVmsPictogramsLibrary.getVmsGeneralCommandsPictogramTypes(parameters);
    }
    //</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="User Configuration Video">
    public InteropResponse setUserConfigurationVideo(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVideo.setUserConfigurationVideo(parameters);
    }
    
    public InteropResponse addCameraInformationPresetOfLoggedUsers(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVideo.addCameraInformationPresetOfLoggedUsers(parameters);
    }

    public InteropResponse deleteCameraInformationPresetOfLoggedUsers(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelVideo.deleteCameraInformationPresetOfLoggedUsers(parameters);
    }
//</editor-fold>
    
    
    //<editor-fold defaultstate="collapsed" desc="Generic objects folders">

    public InteropResponse getObjectsFolders(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelCrudObject.getObjectsFolders(parameters);
    }
    
    public InteropResponse getObjectsSummary(InteropParameters parameters) throws SerializationException
    {
        parameters.addParameter("summary", null);
        return Shared.getModel().modelCrudObject.getObjects(parameters);
    }
    
    public InteropResponse getObjects(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelCrudObject.getObjects(parameters);
    }
        
    public InteropResponse addObject(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelCrudObject.addObject(parameters);
    }
        
    public InteropResponse addHistoricalObject(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelCrudObject.addHistoricalObject(parameters);
    }
    
    public InteropResponse removeObject(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelCrudObject.removeObject(parameters);
    }
    
    public InteropResponse renameObjectFolder(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelCrudObject.renameObjectFolder(parameters);
    }
    //</editor-fold>
    
    
    // <editor-fold defaultstate="collapsed" desc="File server">    

    
    
    public InteropResponse listFiles (InteropParameters parameters) throws SerializationException 
    {
        String language = (String)parameters.getParameterValue("language");        
           
        try
        {
            String folderName = (String)parameters.getParameterValue("folder");            
            String folder = "data/" + Shared.getApplicationName() + "/";
            if (folderName != null) folder = folder + folderName + "/";

            File directory = new File(folder);
            List<File> lfiles = new ArrayList<File>();
            listFiles(directory, lfiles);
            List<ModelFile> lmodelfile = new ArrayList<ModelFile>();
                
            for (File file : lfiles)
            {
                try
                {
                    if (file.isFile() == true)
                    {
                        ModelFile modelFile = new ModelFile();
                        modelFile.folder = file.getAbsolutePath().replace(directory.getAbsolutePath(), "").replace("\\", "/").replaceFirst("/", "").replaceAll(file.getName(), "");
                        if (folderName != null) modelFile.folder = modelFile.folder + "/" + folderName;
                        modelFile.name = file.getName().substring(0, file.getName().lastIndexOf('.'));
                        modelFile.extension = file.getName().substring(file.getName().lastIndexOf('.') + 1, file.getName().length());
                        
                        if (modelFile.extension.equalsIgnoreCase("svg"))
                        {
                            modelFile.mime = "image/svg+xml";
                        }
                        else
                        {
                            MimeUtil2 mimeUtil = new MimeUtil2();
                            mimeUtil.registerMimeDetector("eu.medsea.mimeutil.detector.MagicMimeMimeDetector");
                            modelFile.mime = MimeUtil2.getMostSpecificMimeType(mimeUtil.getMimeTypes(file)).toString();
                        }
                        
                        lmodelfile.add(modelFile);
                    }
                }
                catch (Exception e)
                {
                }
            }

            InteropResponse response = new InteropResponse(lmodelfile.toArray(new ModelFile[lmodelfile.size()]));
            return response;
        }
        catch (Exception e)
        {
            throw getException(language, e);
        }
    }        



    
    
    public InteropResponse getFile (InteropParameters parameters) throws SerializationException 
    {
        String language = (String)parameters.getParameterValue("language");        
           
        try
        {
            byte[] data = Resources.getExternalFileBytes(getFileName(parameters));
            if (data.length == 0) data = Resources.getResourceBytes(getFileName(parameters));
            InteropResponse response = new InteropResponse(data);
            response.mime = "image/svg+xml";
            return response;
        }
        catch (Exception e)
        {
            throw getException(language, e);
        }
    }        

    

  
    public InteropResponse addFile (InteropParameters parameters) throws SerializationException 
    {
        String language = (String)parameters.getParameterValue("language");        
           
        try
        {
            byte[] data = parameters.getParameterValue("body-content");
            File file = new File(getFileName(parameters));
            file.getParentFile().mkdirs();
            FileOutputStream fos = new FileOutputStream(file);
            fos.write(data);
            fos.close();
            return new InteropResponse(new Boolean(true));
        }
        catch (Exception e)
        {
            throw getException(language, e);
        }
    }        
    
    

  
    public InteropResponse removeFile (InteropParameters parameters) throws SerializationException 
    {
        String language = (String)parameters.getParameterValue("language");        
           
        try
        {
            File file = new File(getFileName(parameters));
            return new InteropResponse(new Boolean(file.delete()));
        }
        catch (Exception e)
        {
            throw getException(language, e);
        }
    }            
    
    
    
    private void listFiles (File directory, List<File> lfile) throws SerializationException 
    {
        for (File file : directory.listFiles())
        {
            if (file.isDirectory() == true)
            {
                listFiles(file, lfile);
            }
            else
            {
                lfile.add(file);
            }
        }
    }
    
    
    
    private String getFileName(InteropParameters parameters) throws Exception
    {
        String folderName = (String)parameters.getParameterValue("folder");            
        String fileName = (String)parameters.getParameterValue("name");
        String fileExtension = (String)parameters.getParameterValue("extension");
        
        String result = "data/" + Shared.getApplicationName() + "/";
        
        if (folderName != null) result = result + "/" + folderName;
        if (fileName != null) result = result + "/" + fileName;
        if (fileExtension != null) result = result + "." + fileExtension;
        
        return result.replace("\\","/").replace("//", "/");
    }

    
    // </editor-fold>    
        
    
    
    public InteropResponse getDefaultRecordingPath(InteropParameters parameters) throws SerializationException 
    {
        try 
        {
            return new InteropResponse(Shared.getConfiguration().videoViewer.defaultRecordingPath);
        } 
        catch (Exception e) 
        {
            throw new SerializationException(Shared.getMessage("the default route could not be obtained"), e);
        }
    }


    
    //<editor-fold defaultstate="collapsed" desc="Procedure/Schedule Tasks">

    public InteropResponse getScheduledTasks(InteropParameters parameters) throws SerializationException
    {
        return Shared.getModel().modelCrudObject.getScheduledTasks(parameters);
    }


    public InteropResponse getScheduledProceduresManual(InteropParameters parameters) throws SerializationException
    {
        String language = parameters.hasParameter("language") ? (String) parameters.getParameterValue("language") : art.servers.Shared.getLanguage();
        String computer = parameters.hasParameter("computer") ? (String) parameters.getParameterValue("computer") : "?";
        long millis = System.currentTimeMillis();

        try
        {
            // Search SceduledTask that must be executed at this moment and
            // that contain a manual procedure (with decisions and not automatic actions)

//            Shared.println("Listener " + computer, "Getting ScheduledTasks");
            List<Object> lobject = Shared.controllerDatabase.getTimelessPersistance().get(0).getObject(ScheduledTask.class.getName());
//            Shared.println("Listener " + computer, "Get ScheduledTasks: " + lobject.size());
            List<ScheduledTask> lresult = new ArrayList<ScheduledTask>();

            long timestamp = System.currentTimeMillis();

            for (Object object : lobject)
            {
                ScheduledTask task = (ScheduledTask)object;
//                Shared.println("Listener " + computer, "Checking ScheduledTask: " + task.folder + " - " + task.name);
                if (task.scheduledTask != null)
                {
                    if ((task.scheduledTask.enabled == true) && (task.scheduledTask.procedure != null))
                    {
                        if (task.scheduledTask.procedure.isManual() == true)
                        {
                            if (task.scheduledTask.specificTimestamp > 0)
                            {
                                // TODO Es correcto esto?
                                if ((timestamp <= task.scheduledTask.specificTimestamp) && (task.scheduledTask.specificTimestamp <= (timestamp + 30000L)))
                                {
                                    if (task.scheduledTask.procedure.isManual() == true) lresult.add(task);
                                }
                            }
                            else
                            {
                                timestamp = toScheduledTaskTimestamp(timestamp);
                                if ((task.scheduledTask.weekly != null) && (task.scheduledTask.weekly.size() > 0))
                                {
                                    /**
                                     * Specific time interval every day of week
                                     * Timestamp 0 : Monday, 00:00:00
                                     * Timestamp 86.400.000‬ : Tuesday, 00:00:00
                                     * Null if not used
                                     */

                                    for (ScheduledTaskProcedureInterval weekly : task.scheduledTask.weekly)
                                    {
                                        if ((weekly.from<=timestamp) && (timestamp<=weekly.to))
                                        {
                                            lresult.add(task);
                                            break;
                                        }
                                    }
                                }
                                else
                                {
                                    ScheduledTaskProcedureInterval interval = null;
                                    if (task.scheduledTask.interval != null) interval = task.scheduledTask.interval;
                                    if (task.scheduledTask.monthly != null) interval = task.scheduledTask.monthly;

                                    if (interval != null)
                                    {
                                        if ((interval.from<=timestamp) && (timestamp<=interval.to))
                                        {
                                            lresult.add(task);
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }

//                Shared.println("Listener " + computer, "Checked ScheduledTask: " + task.folder + " - " + task.name);
            }


            // Search the procedures of Segments that have an active traffic alert
//            Shared.println("Listener " + computer, "Getting active traffic alerts");
            List<ScheduledTask> ltrafficAlertScheduledTask = getActiveTrafficAlert();
            lresult.addAll(ltrafficAlertScheduledTask);
//            Shared.println("Listener " + computer, "Get active traffic alerts: " + ltrafficAlertScheduledTask.size() + " - " + (System.currentTimeMillis()-millis));

            return new InteropResponse(lresult.toArray(new ScheduledTask[0]));
        }
        catch (SerializationException exception)
        {
            throw exception;
        }
        catch (Exception exception)
        {
            throw new SerializationException(Shared.getMessage(language, exception.getMessage()), exception);
        }
    }


    public InteropResponse getScheduledProceduresAuto(InteropParameters parameters) throws SerializationException
    {
        String language = parameters.hasParameter("language") ? (String) parameters.getParameterValue("language") : art.servers.Shared.getLanguage();

        try
        {
            List<Object> lobject = Shared.controllerDatabase.getTimelessPersistance().get(0).getObject(ScheduledTask.class.getName());

            List<ScheduledTask> lresult = new ArrayList<ScheduledTask>();

            long timestampCurrent = System.currentTimeMillis();
            long timestampWeekly = toScheduledTaskTimestamp(timestampCurrent);

            for (Object object : lobject)
            {
                ScheduledTask task = (ScheduledTask)object;
                if (task.scheduledTask != null)
                {
                    Shared.println("Listener", "1.TaskAuto: " + task.folder + "/" + task.name + " - Enabled: " + task.scheduledTask.enabled);
                    if ((task.scheduledTask.enabled == true) && (task.scheduledTask.procedure != null))
                    {
                        Shared.println("Listener", "2.TaskAuto Procedure: " + task.scheduledTask.procedure.folder + "/" + task.scheduledTask.procedure.name);
                        if (task.scheduledTask.procedure.isManual() == false)
                        {
                            Shared.println("Listener", "3.TaskAuto Automatic Procedure: " + task.scheduledTask.procedure.folder + "/" + task.scheduledTask.procedure.name);
                            if (task.scheduledTask.specificTimestamp > 0)
                            {
                                if ((timestampCurrent <= task.scheduledTask.specificTimestamp) && (task.scheduledTask.specificTimestamp <= (timestampCurrent + 30000L)))
                                {
                                    lresult.add(task);
                                }
                            }
                            else
                            {
                                Shared.println("Listener", "4.TaskAuto Automatic Procedure weekly: " + Device.getDate(timestampCurrent));
                                Shared.println("Listener", "5.TaskAuto Automatic Procedure weekly: " + Device.getDate(timestampWeekly));
                                if ((task.scheduledTask.weekly != null) && (task.scheduledTask.weekly.size() > 0))
                                {
                                    /**
                                     * Specific time interval every day of week
                                     * Timestamp 0 : Monday, 00:00:00
                                     * Timestamp 86.400.000‬ : Tuesday, 00:00:00
                                     * Null if not used
                                     */

                                    for (ScheduledTaskProcedureInterval weekly : task.scheduledTask.weekly)
                                    {
                                        Shared.println("Listener", "6.TaskAuto Automatic Procedure weekly: " + "From: " + Device.getDate(weekly.from) + " - Timestamp: " + Device.getDate(timestampWeekly) + " - To: " + Device.getDate(weekly.to));
                                        if ((weekly.from<=timestampWeekly) && (timestampWeekly<=weekly.to))
                                        {
                                            lresult.add(task);
                                            break;
                                        }
                                    }
                                }
                                else
                                {
                                    ScheduledTaskProcedureInterval interval = null;
                                    if (task.scheduledTask.interval != null) interval = task.scheduledTask.interval;
                                    if (task.scheduledTask.monthly != null) interval = task.scheduledTask.monthly;

                                    if (interval != null)
                                    {
                                        if ((interval.from<=timestampWeekly) && (timestampWeekly<=interval.to))
                                        {
                                            lresult.add(task);
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            return new InteropResponse(lresult.toArray(new ScheduledTask[0]));
        }
        catch (SerializationException exception)
        {
            exception.printStackTrace();
            throw exception;
        }
        catch (Exception exception)
        {
            exception.printStackTrace();
            throw new SerializationException(Shared.getMessage(language, exception.getMessage()), exception);
        }
    }


    public InteropResponse isScheduledProcedureValid(InteropParameters parameters) throws SerializationException
    {
        String language = parameters.hasParameter("language") ? (String) parameters.getParameterValue("language") : art.servers.Shared.getLanguage();

        try
        {
            Shared.println("Listener", "isScheduledProcedureValid Getting ScheduledTask");
            ScheduledTask task = (ScheduledTask)parameters.getBodyContentValue(ScheduledTask.class);
            Shared.println("Listener", "isScheduledProcedureValid Get ScheduledTask: " + task);

            long timestamp = getTimestampScheduledTask(task, System.currentTimeMillis());

            // Check if has been accepted by anyone ==> return(false)
            // Check if has been rejected by this username from this computer ==> return(false)
            String username = parameters.hasParameter("username") ? (String) parameters.getParameterValue("username") : null;
            String computer = parameters.hasParameter("computer") ? (String) parameters.getParameterValue("computer") : null;

            String where = "type='" + User.class.getName() + "' AND timestamp>=" + timestamp + " AND timestamp<" + System.currentTimeMillis();
            List<DeviceAction> laction = Shared.model.getActions(where);
            Shared.println("Listener", "isScheduledProcedureValid actions: " + laction.size() + " - " + Device.getDate(timestamp));

            for (DeviceAction action : laction)
            {
                try
                {
                    if (action.actionClassType.equalsIgnoreCase(ScheduledTaskProcedureCommands.class.getCanonicalName()) == true)
                    {
                        ScheduledTaskProcedureCommands commands = action.getAction();
                        Shared.println("Listener", "isScheduledProcedureValid Confirmation: " + commands.confirmation);
                        if (commands.confirmation == DeviceCommands.CONDITION_YES)
                        {
                            if (Serialization.equals(task.scheduledTask, commands.taskProcedure))
                            {
                                Shared.println("Listener", "isScheduledProcedureValid Confirmed Procedure");
                                return new InteropResponse(new Boolean(false));
                            }
                        }
                        else if (commands.confirmation == DeviceCommands.CONDITION_NO)
                        {
                            Shared.println("Listener", "isScheduledProcedureValid Confirmation NO: " + action.username + " - " + username + " - " + action.computer + " - " + computer);
                            if ((action.username.equalsIgnoreCase(username) == true) && 
                                (action.computer.equalsIgnoreCase(computer) == true) &&
                                (Serialization.equals(task.scheduledTask, commands.taskProcedure)))
                            {
                                Shared.println("Listener", "isScheduledProcedureValid Rejected Procedure");
                                return new InteropResponse(new Boolean(false));
                            }
                        }
                    }
                }
                catch (Exception e)
                {
                    Shared.printstack("Listener", e);
                }
            }
        }
        catch (Exception exception)
        {
            Shared.printstack("Listener", exception);
        }

        return new InteropResponse(new Boolean(true));
    }


    public InteropResponse setScheduledProcedureState(InteropParameters parameters) throws SerializationException
    {
        String language = parameters.hasParameter("language") ? (String) parameters.getParameterValue("language") : art.servers.Shared.getLanguage();

        try
        {
            String username = parameters.hasParameter("username") ? (String) parameters.getParameterValue("username") : null;

            if (username == null)
            {
                throw new SerializationException(Shared.getMessage(language, "Not received username"));
            }

            boolean accepted = (parameters.hasParameter("accept") == true) ? ((String)parameters.getParameterValue("accept")).equalsIgnoreCase("yes") : false;

            // TODO
            // Check that not exist an action of the same type, for the same SheduledTask/Procedure accepted in scheduled task period
            // If exist throw an exception indicating it
            // Save action in database
            Shared.println("Listener", "Accepting task: " + accepted);
            ScheduledTask task = (ScheduledTask)parameters.getBodyContentValue(ScheduledTask.class);
            Shared.println("Listener", "Accepting task: " + accepted + " - " + task);
            ScheduledTaskProcedureCommands commands = new ScheduledTaskProcedureCommands();
            commands.confirmation = DeviceCommands.CONDITION_YES;
            if (accepted == false) commands.confirmation = DeviceCommands.CONDITION_NO;
            commands.taskProcedure = task.scheduledTask;

            User userAction = new User();
            userAction.information = new UserInformation();
            try
            {
                userAction.information.setIdentifier(Licence.decrypt(username));
            }
            catch (Exception e)
            {
                userAction.information.setIdentifier(username);
            }

            DeviceAction action = new DeviceAction(userAction, parameters, commands);
            DeviceActionResult actionResult = new DeviceActionResult(DeviceActionResult.RESULT_CORRECT);
            action.setResult(actionResult);
            Shared.model.addAction(action);

            return new InteropResponse(new Boolean(true));
        }
        catch (Exception exception)
        {
            Shared.printstack("Listener", exception);
        }

        return new InteropResponse(new Boolean(false));
    }

    //</editor-fold>


    public InteropResponse getScheduledProceduresManualTest(InteropParameters parameters) throws SerializationException
    {
        String language = parameters.hasParameter("language") ? (String) parameters.getParameterValue("language") : art.servers.Shared.getLanguage();

        try
        {
            // TODO David
            // Buscar los ScheduledTask que han de ejecutarse en este momento y 
            // que contienen un procedure manual (con ifs o acciones no automaticas)
            List<Object> lobject = Shared.controllerDatabase.getTimelessPersistance().get(0).getObject(ScheduledTask.class.getName());

            List<ScheduledTask> lresult = new ArrayList<ScheduledTask>();

            long timestamp = System.currentTimeMillis();

            for (Object object : lobject)
            {
                ScheduledTask task = (ScheduledTask)object;
                if (task.scheduledTask != null)
                {
                    if ((task.scheduledTask.enabled == true) && (task.scheduledTask.procedure != null))
                    {
                        if (task.scheduledTask.procedure.isManual() == true)
                        {
                            lresult.add(task);
//                            if (task.scheduledTask.specificTimestamp > 0)
//                            {
//                                if ((timestamp <= task.scheduledTask.specificTimestamp) && (task.scheduledTask.specificTimestamp <= (timestamp + 30000L)))
//                                {
//                                    if (task.scheduledTask.procedure.isManual() == true) lresult.add(task);
//                                }
//                            }
//                            else
//                            {
//                                timestamp = toScheduledTaskTimestamp(timestamp);
//                                if ((task.scheduledTask.weekly != null) && (task.scheduledTask.weekly.size() > 0))
//                                {
//                                    /**
//                                     * Specific time interval every day of week
//                                     * Timestamp 0 : Monday, 00:00:00
//                                     * Timestamp 86.400.000‬ : Tuesday, 00:00:00
//                                     * Null if not used
//                                     */
//
//                                    for (ScheduledTaskProcedureInterval weekly : task.scheduledTask.weekly)
//                                    {
//                                        if ((weekly.from<=timestamp) && (timestamp<=weekly.to))
//                                        {
//                                            lresult.add(task);
//                                            break;
//                                        }
//                                    }
//                                }
//                                else
//                                {
//                                    ScheduledTaskProcedureInterval interval = null;
//                                    if (task.scheduledTask.interval != null) interval = task.scheduledTask.interval;
//                                    if (task.scheduledTask.monthly != null) interval = task.scheduledTask.monthly;
//
//                                    if (interval != null)
//                                    {
//                                        if ((interval.from<=timestamp) && (timestamp<=interval.to))
//                                        {
//                                            lresult.add(task);
//                                            break;
//                                        }
//                                    }
//                                }
//                            }
                        }
                    }
                }
            }

            return new InteropResponse(lresult.toArray(new ScheduledTask[0]));
        }
        catch (SerializationException exception)
        {
            exception.printStackTrace();
            throw exception;
        }
        catch (Exception exception)
        {
            exception.printStackTrace();
            throw new SerializationException(Shared.getMessage(language, exception.getMessage()), exception);
        }
    }




    private long toScheduledTaskTimestamp(long timestamp)
    {
        try
        {
            long sumvalue = 86400000;

            Calendar calendar = Calendar.getInstance();
            calendar.setTimeInMillis(timestamp);
            int weekday = calendar.get(Calendar.DAY_OF_WEEK);
            int hour = calendar.get(Calendar.HOUR_OF_DAY);
            int minutes = calendar.get(Calendar.MINUTE);
            int seconds = calendar.get(Calendar.SECOND);
            int milliseconds = calendar.get(Calendar.MILLISECOND);
            long day = 0;
            if (weekday == Calendar.MONDAY)
                day = 0;
            if (weekday == Calendar.TUESDAY)
                day = 1;
            if (weekday == Calendar.WEDNESDAY)
                day = 2;
            if (weekday == Calendar.THURSDAY)
                day = 3;
            if (weekday == Calendar.FRIDAY)
                day = 4;
            if (weekday == Calendar.SATURDAY)
                day = 5;
            if (weekday == Calendar.SUNDAY)
                day = 6;

            long result = day * sumvalue;
            result = result + (hour*60L*60000L) + (minutes*60000L) + (seconds*1000L) + milliseconds;
            return(result);
        }
        catch (Exception e)
        {
            
        }

        return(timestamp);
    }




    private long scheduledTaskTimestampToTimestamp(long from)
    {
        try
        {
            long sumvalue = 86400000;

            Calendar calendar = Calendar.getInstance();
            calendar.setTimeInMillis(System.currentTimeMillis());
            int weekday = calendar.get(Calendar.DAY_OF_WEEK);
            int hour = calendar.get(Calendar.HOUR_OF_DAY);
            int minutes = calendar.get(Calendar.MINUTE);
            int seconds = calendar.get(Calendar.SECOND);
            int milliseconds = calendar.get(Calendar.MILLISECOND);
            long day = 0;
            if (weekday == Calendar.MONDAY)
                day = 0;
            if (weekday == Calendar.TUESDAY)
                day = 1;
            if (weekday == Calendar.WEDNESDAY)
                day = 2;
            if (weekday == Calendar.THURSDAY)
                day = 3;
            if (weekday == Calendar.FRIDAY)
                day = 4;
            if (weekday == Calendar.SATURDAY)
                day = 5;
            if (weekday == Calendar.SUNDAY)
                day = 6;

            int taskday = (int)(from / sumvalue);

            if (taskday == day)
            {
                Calendar calendar2 = Calendar.getInstance();
                calendar2.setTimeInMillis(System.currentTimeMillis());
                calendar2.set(Calendar.HOUR_OF_DAY, 0);
                calendar2.set(Calendar.MINUTE, 0);
                calendar2.set(Calendar.SECOND, 0);
                calendar2.set(Calendar.MILLISECOND, 0);
                calendar2.add(Calendar.MILLISECOND, (int)(from % sumvalue));
                return(calendar2.getTimeInMillis());
            }
        }
        catch (Exception e)
        {
            
        }

        return(-1);
    }


    private List<ScheduledTask> getActiveTrafficAlert() throws SerializationException
    {
        List<ScheduledTask> lresult = new ArrayList<ScheduledTask>();

        try
        {
            // Shared.println("Listener", "Sending request active traffic alerts");
            // Buscar los procedures de Segments que tienen la traffic alert activa
            Application applicationSegment = Shared.getModel().getApplicationService("traveltime");
            // Shared.println("Listener", "Sending request active traffic alerts: " + applicationSegment.getDeviceInformation().serverAddress + ":" + applicationSegment.getDeviceInformation().serverPort + ", " + applicationSegment.getDeviceInformation().serverServiceName);
            InteropParameters parameters = new InteropParameters();
            parameters.addParameter(new InteropParameter("service", applicationSegment.getDeviceInformation().serverServiceName));
            parameters.addParameter(new InteropParameter("operation", "getTrafficAlertProcedures"));
            parameters.addParameter(new InteropParameter("language", Shared.configuration.general.language));
            // Shared.println("Listener", "Sending socket request active traffic alerts: " + applicationSegment.getDeviceInformation().serverAddress + ":" + applicationSegment.getDeviceInformation().serverPort + ", " + applicationSegment.getDeviceInformation().serverServiceName);
            InteropResponse response = (InteropResponse)Serialization.invoke("get", parameters, applicationSegment.getDeviceInformation().serverAddress, applicationSegment.getDeviceInformation().serverPort, 30000);
            TrafficAlertProcedure[] ltrafficAlertProcedures = Arrays.copyOf(response.getValue(), response.getValue().length, TrafficAlertProcedure[].class);
            // Shared.println("Listener", "Received response active traffic alerts: " + applicationSegment.getDeviceInformation().serverAddress + ":" + applicationSegment.getDeviceInformation().serverPort + ", " + applicationSegment.getDeviceInformation().serverServiceName + " - " + ltrafficAlertProcedures.length);

            for (TrafficAlertProcedure trafficAlertProcedure : ltrafficAlertProcedures)
            {
                try
                {
                    ScheduledTask scheduledTask = new ScheduledTask();
                    scheduledTask.folder = "";
                    scheduledTask.name = "";
                    scheduledTask.description = "";
                    scheduledTask.scheduledTask = new ScheduledTaskProcedure();
                    scheduledTask.scheduledTask.procedure = trafficAlertProcedure.procedure;
                    scheduledTask.scheduledTask.specificTimestamp = trafficAlertProcedure.tsTrafficAlert;

                    lresult.add(scheduledTask);
                }
                catch (Exception e)
                {
                    
                }
            }

            // Shared.println("Listener", "Returning active traffic alerts: " + applicationSegment.getDeviceInformation().serverAddress + ":" + applicationSegment.getDeviceInformation().serverPort + ", " + applicationSegment.getDeviceInformation().serverServiceName + " - " + lresult.size());
        }
        catch (Exception exception)
        {
            
        }

        return (lresult);
    }


    private long getTimestampScheduledTask (ScheduledTask task, long currenttime) throws SerializationException
    {
        try
        {
            if (task.scheduledTask != null)
            {
                if ((task.scheduledTask.enabled == true) && (task.scheduledTask.procedure != null))
                {
                    if (task.scheduledTask.specificTimestamp > 0)
                    {
                        return(task.scheduledTask.specificTimestamp);
                    }
                    else
                    {
                        if ((task.scheduledTask.weekly != null) && (task.scheduledTask.weekly.size() > 0))
                        {
                            long tsWeekly = -1;
                            for (ScheduledTaskProcedureInterval weekly : task.scheduledTask.weekly)
                            {
                                long ts = scheduledTaskTimestampToTimestamp(weekly.from);
                                if ((ts > 0) && (ts <= currenttime))
                                {
                                    if (tsWeekly < 0)
                                    {
                                        tsWeekly = ts;
                                    }
                                    else if ((tsWeekly > 0) && (ts > tsWeekly))
                                    {
                                        // Coger el que se aproxime mas a la fecha actual (anterior)
                                        tsWeekly = ts;
                                    }
                                }
                            }

                            if (tsWeekly > 0) return(tsWeekly);
                        }
                        else if (task.scheduledTask.interval != null)
                        {
                        }
                        else if (task.scheduledTask.monthly != null)
                        {
                        }
                    }
                }
            }
        }
        catch (Exception exception)
        {
        }

        return (System.currentTimeMillis());
    }

}