package art.servers.transactionsserver.model.access;

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.user.User;
import art.library.model.devices.user.UserIdentification;
import art.library.model.devices.user.UserInformation;
import art.library.model.devices.user.UserPermission;
import art.library.net.ldap.LDAP;
import art.library.utils.licence.Licence;
import art.library.utils.password.PasswordGenerator;
import art.servers.transactionsserver.Shared;
import art.servers.transactionsserver.controller.ListenerImplementation;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.stream.Collectors;

public class ModelUsers
{     
    
    public ModelUsers() throws Exception
    {
    }

    //<editor-fold defaultstate="collapsed" desc="Users">    
     /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "lGroup" class: <code>String[]</code>
     * @return <code>InteropResponse</code> 
     * <code>UserIdentification[]</code>
     * @throws SerializationException 
     */
    @SuppressWarnings("unchecked")
    public InteropResponse getUsersIdentification(InteropParameters parameters) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        
        List<UserIdentification> result = new ArrayList<>();
        try
        {
            String[] lgroup = (String[])parameters.getParameterValue("lGroup");
            
            for (Device device : Shared.model.getDevices(lgroup))
            {
                try
                {
                    User user = (User)device;
                    UserIdentification userIdentification = new UserIdentification();
                    userIdentification.group = user.information.group;
                    try
                    {
                        userIdentification.username = Licence.decrypt(user.username);
                    }
                    catch (Exception e)
                    {
                        userIdentification.username = user.username;
                    }
                    userIdentification.role = user.getDeviceInformation().role;
                    result.add(userIdentification);
                }
                catch (Exception e)
                {
                    
                }
            }
            Collections.sort(result, 
                    (UserIdentification o1, UserIdentification o2) -> (o1.group+o1.username).compareTo((o2.group+o2.username)));
        } catch (Exception e)
        {
            e.printStackTrace();
            throw new SerializationException(e.getMessage());
        }

        return new InteropResponse(result.toArray(new UserIdentification[result.size()]));

    }
    
     /**
     * @param parameters <code>InteropParameters</code>
     * <p>name: "language" class: <code>String</code>
     * <p>name: "lGroup" class: <code>String[]</code>
     * @return <code>InteropResponse</code> 
     * <code>UserInformation[]</code>
     * @throws SerializationException 
     */
    @SuppressWarnings("unchecked")
    public InteropResponse getUsersInformation(InteropParameters parameters) throws SerializationException
    {
        String language = (String)parameters.getParameterValue("language");
        
        List<UserInformation> result = new ArrayList<>();
        try
        {
            String bodyContent = (String) parameters.getParameterValue("bodyContent");
            List<Device> ldevice = new ArrayList<>();
            if (bodyContent != null)
            {
                String[] lusername = (String[]) Serialization.deserialize(String[].class, bodyContent);
                ldevice.addAll(Shared.model.getDevicesFromIdentifier(lusername));
                
            }else{
                String[] lgroup = (String[])parameters.getParameterValue("lGroup");
                ldevice.addAll(Arrays.asList(Shared.model.getDevices(lgroup)));
            }
            
            result.addAll(ldevice.stream().map((w) ->
            {
                UserInformation information = Serialization.clone(w.getDeviceInformation());
                try
                {
                    information.setIdentifier(Licence.decrypt(information.getIdentifier()));
                } catch (Exception ex)
                {
                    Logger.getLogger(ModelUsers.class.getName()).log(Level.SEVERE, null, ex);
                }
                return information;
            }).collect(Collectors.toList()));

            Collections.sort(result, 
                    (UserInformation o1, UserInformation o2) -> (o1.group+o1.getIdentifier()).compareTo((o2.group+o2.getIdentifier())));
        } catch (Exception e)
        {
            throw new SerializationException(e.getMessage());
        }

        return new InteropResponse(result.toArray(new UserInformation[result.size()]));
    }
    //</editor-fold>
    
        
     /**
     * @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
    {        
        String language = (String)parameters.getParameterValue("language");
        
        try
        {
            Shared.println("ModelUsers", "1.GetUserLDAP: " + Shared.getConfiguration().lldapServer);
            if ((Shared.getConfiguration().lldapServer == null) || (Shared.getConfiguration().lldapServer.length <= 0))
            {
                return new InteropResponse(Shared.getMessage("Information:") + " " + Shared.getMessage("art.servers.transactionsserver.ldap.json not defined"));
            }
            
            String username = (String)parameters.getParameterValue("username");
            String usernameDecrypt;
            try
            {
                usernameDecrypt = Licence.decrypt(username);
            } catch (Exception e)
            {
                usernameDecrypt = username;
                username = Licence.encrypt(username);
            }
            
            Shared.println("ModelUsers", "2.GetUserLDAP username: " + usernameDecrypt + " - " + username);
            LDAP ldap = new LDAP(Arrays.asList(Shared.getConfiguration().lldapServer));
            Shared.println("ModelUsers", "GetUserLdap: LDAP: " + ldap);
            if (ldap.userExists(usernameDecrypt))
            {
                Shared.println("ModelUsers", "GetUserLdap: LDAP user exists: " + usernameDecrypt);
                art.library.net.ldap.User ldapUser = ldap.getUser(usernameDecrypt);

                //GET ARTIC USER
                User user = null;
                try
                {
                    user = (User) Shared.getModel().getDevice(username);
                }
                catch (Exception e)
                {
                    Shared.println("ModelUsers", "GetUserLdap: LDAP user exists, user ARTIC ex: " + e.toString());
                    UserInformation userInformation = new UserInformation();
                    userInformation.setIdentifier(username);
                    userInformation.group = ldapUser.department;
                    userInformation.name = ldapUser.displayName;
                    userInformation.company = ldapUser.company;
                    userInformation.phone = ldapUser.telephoneNumber;
                    userInformation.address = ldapUser.userPrincipalName;
                    userInformation.description = ldapUser.employeeID;    
                    userInformation.password = Licence.encrypt(PasswordGenerator.generatePassword(8));                    
                    List<String> lOrganizationUnit = new ArrayList<>();
                    if (ldapUser.getOrganizationalUnitsMembership().size() > 0)
                    {
                        lOrganizationUnit = ldapUser.getOrganizationalUnitsMembership().stream().distinct().collect(Collectors.toList());
                    }
                    lOrganizationUnit.add("default");
                    
                    StringBuilder sb = new StringBuilder();
                    lOrganizationUnit.stream().map(w -> (" "+ sb.append(w)));
                    
                    List<String> lorganizationUnitEncrypt = lOrganizationUnit.stream().map(w ->
                    {
                        try
                        {
                            return Licence.encrypt(w);
                        } catch (Exception ex)
                        {
                            Logger.getLogger(ModelUsers.class.getName()).log(Level.SEVERE, null, ex);
                        }
                        return w;
                    }).collect(Collectors.toList());
                    
                    //GET USER PERMISSIONS FROM ORGANIZATION USERS
                    InteropParameters parametersGetUserPermission = new InteropParameters();
                    parametersGetUserPermission.addBodycontent(lorganizationUnitEncrypt);
                    for (String organization : lOrganizationUnit)
                    {
                        Shared.println("ModelUSers", "GetUserLdap - Organization: " + organization);
                    }

                    Shared.getModel().addDevices(new UserInformation[]{userInformation});
                    user = (User) Shared.getModel().getDevice(username);

                    InteropResponse response = Shared.getModel().modelPermissions.getUserPermission(parametersGetUserPermission);
                    // Object[] object = response.getValue();
                    try
                    {
                        UserPermission userPermission = response.getResponse();
                        Shared.println("ModelUSers", "GetUserLdap - UserPermission: DeviceFeature: " + userPermission.lPermissionDeviceFeature.size() + " - Feature: " + userPermission.lPermissionFeature.size() + " - Read: " + userPermission.lPermissionDeviceRead.size() + " - Write: " + userPermission.lPermissionDeviceWrite.size());
                        user.getDeviceConfiguration().permissions = userPermission;
                        User[] luser = new User[1];
                        luser[0] = user;
                        InteropParameters parametersPermissions = new InteropParameters();
                        parametersPermissions.addParameter("language", Shared.getLanguage());
                        parametersPermissions.addBodycontent(luser);
                        ((ListenerImplementation)Shared.controllerListener.getListenerImplementation()).addDevices(parametersPermissions);
                    }
                    catch (Exception ex)
                    {
                        Shared.printstack("ModelUsers", ex);
                    }
                    
                }

                ldap.close();
                
                //we return String username that means user is correct.
                UserIdentification userIdentification = new UserIdentification();
                userIdentification.username = user.username;
                userIdentification.password = user.getDeviceInformation().password;
                return new InteropResponse(userIdentification);
            }

            Shared.println("ModelUsers", "GetUserLdap: LDAP user NOT exists: " + usernameDecrypt);
        } catch (Exception e)
        {
            Shared.printstack("ModelUsers", e);
        }
        //We return null, that means there is no ldap user for that username requested.
        return new InteropResponse((UserIdentification)null);
    }
}