package com.megatim.fdxconsultation.service.impl.authentication;

import com.megatim.fdxcommons.tools.context.AppContext;
import com.megatim.fdxconsultation.core.ifaces.administration.ActionManager;
import com.megatim.fdxconsultation.core.ifaces.administration.RoleManager;
import com.megatim.fdxconsultation.core.ifaces.administration.UserManager;
import com.megatim.fdxconsultation.core.ifaces.helper.RequestHandler;
import com.megatim.fdxconsultation.core.ifaces.log.UserActionLogManager;
import com.megatim.fdxconsultation.model.administration.Action;
import com.megatim.fdxconsultation.model.administration.Role;
import com.megatim.fdxconsultation.model.administration.User;
import com.megatim.fdxconsultation.model.authentification.LoginRequest;
import com.megatim.fdxconsultation.model.mappers.MapStructMapper;
import com.megatim.fdxconsultation.service.ifaces.authentication.AuthenticationRS;
import com.megatim.retrocedor.commons.tools.CommonsTools;
import com.mgt.rs.security.core.common.AuthenticatedUser;
import com.mgt.rs.security.core.exception.AuthenticationException;
import com.mgt.rs.security.core.model.AuthenticationToken;
import com.mgt.rs.security.core.service.AuthenticationTokenService;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import javax.enterprise.event.Observes;
import javax.inject.Inject;
import javax.ws.rs.Path;
import javax.ws.rs.core.HttpHeaders;
import javax.ws.rs.core.Response;

/**
 *
 * @author lenovo
 */
@Path("auth")
public class AuthenticationRSImpl implements AuthenticationRS {

    @Inject
    private AuthenticationTokenService authenticationTokenService;

    @Inject
    protected UserManager userManager;
    
    @Inject
    UserActionLogManager userActionLogManager;

    @Inject
    protected RoleManager roleManager;

    @Inject
    private MapStructMapper mapstructMapper;

    @AuthenticatedUser
    private User utilisateurConnecte;

    @Inject
    protected ActionManager actionManager;

    @Inject
    private RequestHandler requestHandler;

    /**
     * Methode permettant de recupere l'utilisateur connecté
     *
     * @param username
     */
    public void handleAuthenticationEvent(@Observes @AuthenticatedUser String username) {
        utilisateurConnecte = userManager.recuperUtilisateur(username);
    }

    /**
     * Validate user credentials and issue a token for the user.
     *
     * @param loginRequest
     * @return
     */
    @Override
    public Response authenticate(LoginRequest loginRequest) {
        User user = validateCredentials(loginRequest.getUserName(), loginRequest.getPwd());
        String token = authenticationTokenService.issueToken(user.getUserName());
        String refreshToken = authenticationTokenService.issueRefreshToken(user.getUserName());
        AuthenticationToken authenticationToken = new AuthenticationToken();
        authenticationToken.setToken(token);
        authenticationToken.setRefreshToken(refreshToken);
        user.setLastConnexionDateTime(new Date());
        user.setCleSession(CommonsTools.formaterDate(AppContext.FORMAT_DATE_DDMMYYYYHHMMSS, new Date()));
        user.setConnected(true);
        userManager.update(user.getId(), user);
        return Response.ok(authenticationToken).build();
    }

    /**
     * Validate username and password.
     *
     * @param username
     * @param password
     * @return
     */
    public User validateCredentials(String username, String password) {
        
        //Variables
        List<String> errors = new ArrayList<>();
        User user = null;
        
        //On recupère les erreurs
        errors = userManager.validerParametresConnexion(username, password);
        
        //Si non vide
        if(!errors.isEmpty()){
            
            //On lève l'execption
            throw new AuthenticationException(errors.get(0));
            
        }
        
        //On recupère l'utilisateur connecté
        user = userManager.recuperUtilisateur(username, password);
        
        return user;
    }
    
    @Override
    public Response getInfoUser(HttpHeaders headers) {
        return Response.ok(mapstructMapper.userToUserDto(utilisateurConnecte)).build();
    }

    @Override
    public Response ifUserNameExist(HttpHeaders headers, String username) {
        User user = userManager.recuperUtilisateur(username);
        return Response.ok(mapstructMapper.userToUserDto(user)).build();
    }

    @Override
    public Response logout(HttpHeaders headers, User user) {
        User userBd = userManager.findById(user.getId());
        userBd.setConnected(false);
        userManager.update(userBd.getId(), userBd);
        return Response.ok().build();
    }

    @Override
    public Response generateDataTotTest(HttpHeaders headers) {

        String userName = "test";
        User testUser = userManager.recuperUtilisateur(userName);

        boolean isUpdate = testUser != null;
        if (testUser == null) {
            testUser = new User();
        }
        testUser.setUserName(userName);
        testUser.setPwd(CommonsTools.encryptPassword(userName));

        Role role = new Role();
        role.setLibelle("test");
        role.setDescription("test");

        List<Action> actions = actionManager.findAll();
        if (actions != null && !actions.isEmpty()) {

            List<Role> roles = roleManager.findByUniqueProperty("libelle", role.getLibelle(), null);
            if (roles != null && !roles.isEmpty()) {
                role = roles.get(0);
                role.setActions(actions);
                roleManager.update(role.getId(), role);
            } else {
                role.setActions(actions);
                role = roleManager.save(role);
            }
            testUser.setRole(role);
        }

        //On recupère le user
        User updatedTestUser = (!isUpdate) ? userManager.save(testUser) : userManager.update(testUser.getId(), testUser);

        return Response.ok(mapstructMapper.userToUserDto(updatedTestUser)).build();
    }

}