package com.iconplus.smartproc.service.authentication;

import com.iconplus.smartproc.configuration.JwtTokenUtil;
import com.iconplus.smartproc.exception.BusinessException;
import com.iconplus.smartproc.helper.service.BaseService;
import com.iconplus.smartproc.model.entity.Menus;
import com.iconplus.smartproc.model.entity.TokenManagement;
import com.iconplus.smartproc.model.projection.MenusPermissionView;
import com.iconplus.smartproc.model.request.LoginRequest;
import com.iconplus.smartproc.model.response.LoginResponse;
import com.iconplus.smartproc.model.response.MenusPermissionResponse;
import com.iconplus.smartproc.model.response.MenusResponse;
import com.iconplus.smartproc.model.response.ParentMenusResponse;
import com.iconplus.smartproc.model.token.TokenContent;
import com.iconplus.smartproc.repository.MenusRepository;
import com.iconplus.smartproc.repository.PermissionRepository;
import com.iconplus.smartproc.repository.UsersRepository;
import com.iconplus.smartproc.service.CommonService;
import com.iconplus.smartproc.util.Constants;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.BooleanUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

@Service
@Slf4j
public class LoginService implements BaseService<LoginRequest, LoginResponse> {

    @Value("${jwt.expired-time.access-token:15}")
    private Integer accessTokenExp;
    @Value("${jwt.expired-time.refresh-token:60}")
    private Integer refreshTokenExp;

    private final UsersRepository usersRepository;
    private final JwtTokenUtil jwtTokenUtil;
    private final CommonService commonService;
    private final MenusRepository menusRepository;
    private final PermissionRepository permissionRepository;

    public LoginService(UsersRepository userRepository,
                        JwtTokenUtil jwtTokenUtil,
                        CommonService commonService,
                        MenusRepository menusRepository,
                        PermissionRepository permissionRepository) {
        this.usersRepository = userRepository;
        this.jwtTokenUtil = jwtTokenUtil;
        this.commonService = commonService;
        this.menusRepository = menusRepository;
        this.permissionRepository = permissionRepository;

    }

    @Transactional
    @Override
    public LoginResponse execute(LoginRequest input) {

        var userRoleView= usersRepository.getByUsernameOrEmail(input.getEmail())
                .orElseThrow(() -> new BusinessException(HttpStatus.CONFLICT,
                        Constants.ERR_CODE_10003,
                        Constants.ERR_TTL_10003,
                        String.format(Constants.ERR_MSG_10003, input.getEmail())));

        String password = commonService.getPassword(input.getPassword());
        BCryptPasswordEncoder bCryptPasswordEncoder = new BCryptPasswordEncoder();
        boolean isValidPassword = bCryptPasswordEncoder.matches(password, userRoleView.getPassword());

        if (!isValidPassword) {
            throw new BusinessException(HttpStatus.CONFLICT,
                    Constants.ERR_CODE_10004,
                    Constants.ERR_TTL_10004,
                    Constants.ERR_MSG_10004);
        }
        Set<String> accessMenu = new HashSet<>();
        List<MenusPermissionResponse> menusPermissionResponseList = new ArrayList<>();


        List<ParentMenusResponse> parentMenusResponseList = new ArrayList<>();
        var parentMenu = menusRepository.findAllParentMenu(userRoleView.getRoleId());
        for (Menus menus : parentMenu) {
            ParentMenusResponse parentMenusResponse = ParentMenusResponse.builder()
                    .id(menus.getId())
                    .text(menus.getNama())
                    .icon(menus.getIcon())
                    .path(menus.getLink())
                    .items(new ArrayList<>())
                    .build();
            parentMenusResponseList.add(parentMenusResponse);
        }

        var listMenusPermission = permissionRepository.getListMenusPermission(userRoleView.getRoleId());
        for (MenusPermissionView menusPermissionView : listMenusPermission) {
            if (BooleanUtils.isTrue(menusPermissionView.getCanView()) ||
                    BooleanUtils.isTrue(menusPermissionView.getCanCreate()) ||
                    BooleanUtils.isTrue(menusPermissionView.getCanUpdate()) ||
                    BooleanUtils.isTrue(menusPermissionView.getCanDelete()) ||
                    BooleanUtils.isTrue(menusPermissionView.getCanRead())) {
                accessMenu.add(menusPermissionView.getNama());

                MenusPermissionResponse menusPermissionResponse = MenusPermissionResponse.builder()
                        .id(menusPermissionView.getId())
                        .nama(menusPermissionView.getNama())
                        .parentId(menusPermissionView.getParentId())
                        .urutan(menusPermissionView.getUrutan())
                        .icon(menusPermissionView.getIcon())
                        .link(menusPermissionView.getLink())
                        .canView(menusPermissionView.getCanView())
                        .canRead(menusPermissionView.getCanRead())
                        .canCreate(menusPermissionView.getCanCreate())
                        .canUpdate(menusPermissionView.getCanUpdate())
                        .canDelete(menusPermissionView.getCanDelete())
                        .build();

                menusPermissionResponseList.add(menusPermissionResponse);
            }
        }

        for (ParentMenusResponse parentMenusResponse : parentMenusResponseList) {
            for (MenusPermissionResponse menusPermissionResponse : menusPermissionResponseList) {
                if (parentMenusResponse.getId().equals(menusPermissionResponse.getParentId())) {
                    MenusResponse menusResponse = MenusResponse.builder()
                            .text(menusPermissionResponse.getNama())
                            .path(menusPermissionResponse.getLink())
                            .canView(menusPermissionResponse.getCanView())
                            .canRead(menusPermissionResponse.getCanRead())
                            .canCreate(menusPermissionResponse.getCanCreate())
                            .canUpdate(menusPermissionResponse.getCanUpdate())
                            .canDelete(menusPermissionResponse.getCanDelete())
                            .build();
                    parentMenusResponse.getItems().add(menusResponse);

                }
            }
        }

        var tokenContent = TokenContent.builder()
                .userId(userRoleView.getId())
                .username(userRoleView.getUsername())
                .nama(userRoleView.getNama())
                .roleId(userRoleView.getRoleId())
                .role(userRoleView.getRole())
                .instansiId(userRoleView.getInstansiId())
                .instansi(userRoleView.getInstansi())
                .bidangId(userRoleView.getBidangId())
                .bidang(userRoleView.getBidang())
                .jabatanId(userRoleView.getJabatanId())
                .jabatan(userRoleView.getJabatan())
                .accessMenu(accessMenu)
                .build();

        Map<String, Object> claims = new HashMap<>();
        claims.put("userId", userRoleView.getId());

        final String accessToken = jwtTokenUtil.generateToken(String.valueOf(userRoleView.getId()), tokenContent, accessTokenExp * 60000);
        String refreshToken = jwtTokenUtil.doGenerateToken(claims, String.valueOf(userRoleView.getId()), refreshTokenExp * 60000);

        if (StringUtils.isBlank(accessToken) || StringUtils.isBlank(refreshToken)) {
            log.error("token null");
            throw new BusinessException(Constants.ERR_CODE_10008,
                    Constants.ERR_TTL_10008,
                    Constants.ERR_MSG_10008);
        }

        commonService.saveUserToken(TokenManagement.builder()
                .userId(userRoleView.getId())
                .accessToken(accessToken)
                .refreshToken(refreshToken)
                .build(), accessTokenExp);

    return LoginResponse.builder()
            .accessToken(accessToken)
            .validity(accessTokenExp * 60)
            .refreshToken(refreshToken)
            .userId(userRoleView.getId())
            .username(userRoleView.getUsername())
            .nama(userRoleView.getNama())
            .telepon(userRoleView.getTelepon())
            .email(userRoleView.getEmail())
            .roleId(userRoleView.getRoleId())
            .role(userRoleView.getRole())
            .menus(parentMenusResponseList)
            .build();
    }
}