package com.grs.api.config.security;

import com.grs.api.model.OISFUserType;
import com.grs.api.model.OfficeInformation;
import com.grs.api.model.UserInformation;
import com.grs.api.model.UserType;
import com.grs.core.dao.GrsRoleDAO;
import com.grs.core.dao.OfficesGroDAO;
import com.grs.core.dao.UserDAO;
import com.grs.core.domain.grs.GrsRole;
import com.grs.core.domain.grs.OfficesGRO;
import com.grs.core.domain.projapoti.*;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Created by Acer on 10/5/2017.
 */
@Slf4j
@Service
public class OISFUserDetailsServiceImpl implements UserDetailsService {
    @Autowired
    private UserDAO userDAO;
    @Autowired
    private OfficesGroDAO officesGroDAO;
    @Autowired
    private BCryptPasswordEncoder bCryptPasswordEncoder;
    @Autowired
    private OISFUserDetailsServiceImpl oisfUserDetailsService;
    @Autowired
    private GrsRoleDAO grsRoleDAO;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        User user = this.userDAO.findByUsername(username);
        if (user == null) {
            throw new UsernameNotFoundException("Invalid credentials");
        }

        UserInformation userInformation = this.oisfUserDetailsService.getUserInfo(user);
        GrsRole grsRole = this.grsRoleDAO.findByRole(userInformation.getOisfUserType().toString());
        List<GrantedAuthorityImpl> grantedAuthorities = grsRole.getPermissions().stream()
                .map(permission -> {
                    return GrantedAuthorityImpl.builder()
                            .role(permission.getName())
                            .build();
                }).collect(Collectors.toList());


        return UserDetailsImpl.builder()
                .username(user.getUsername())
                .password(user.getPassword())
                .isAccountAuthenticated(user.getAuthenticated())
                .grantedAuthorities(grantedAuthorities)
                .userInformation(this.getUserInfo(user))
                .build();
    }

    public UserInformation getUserInfo(User user) {
        OfficeInformation officeInformation = getOfficeInformationFromUser(user);

        List<OfficesGRO> officesGRO = new ArrayList<>();
        if (officeInformation != null && officeInformation.getOfficeUnitOrganogramId() != null) {
            officesGRO = this.officesGroDAO
                    .findByAppealOfficeUnitOrganogramId(officeInformation.getOfficeUnitOrganogramId());
        }
        Boolean isAppealOfficer = false;

        if (officesGRO != null) {
            if (officesGRO.size() > 0) {
                isAppealOfficer = true;
            }
        }

        return UserInformation
                .builder()
                .userId(user.getId())
                .username(user.getUsername())
                .userType(UserType.OISF_USER)
                .oisfUserType(getOISFUserTypeFromRole(user))
                .officeInformation(officeInformation)
                .isAppealOfficer(isAppealOfficer)
                .build();
    }

    public OfficeInformation getOfficeInformationFromUser(User user) {
        if (user.getEmployeeRecord() == null) {
            return null;
        }
        if (user.getEmployeeRecord().getEmployeeOffices() == null) {
            return null;
        }

        List<EmployeeOffice> userEmployeeOffices = user.getEmployeeRecord()
                .getEmployeeOffices()
                .stream()
                .filter(employeeOffice -> (employeeOffice.getStatus()))
                .collect(Collectors.toList());

        if (userEmployeeOffices.size() < 1) {
            return null;
        }
        Office office = userEmployeeOffices.get(0).getOffice();
        OfficeUnitOrganogram officeUnitOrganogram = userEmployeeOffices.get(0).getOfficeUnitOrganogram();

        OfficeInformation officeInformation = OfficeInformation.builder()
                .officeId(office.getId())
                .officeMinistryId(office.getOfficeMinistry().getId())
                .officeNameBangla(office.getNameBangla())
                .officeNameEnglish(office.getNameEnglish())
                .designation(userEmployeeOffices.get(0).getDesignation())
                .employeeRecordId(user.getEmployeeRecord().getId())
                .name(user.getEmployeeRecord().getNameBangla())
                .officeUnitOrganogramId(officeUnitOrganogram.getId())
                .layerLevel(Long.valueOf(office.getOfficeLayer().getLayerLevel()))
                .geoDivisionId(Long.valueOf(office.getDivisionId()))
                .geoDistrictId(Long.valueOf(office.getDistrictId()))
                .build();

        return officeInformation;
    }

    public OISFUserType getOISFUserTypeFromRole(User user) {
        if (user.getRole().getName().equals("Admin")) {
            return OISFUserType.SUPER_ADMIN;
        }
        if (user.getEmployeeRecord() == null) {
            return null;
        }
        List<EmployeeOffice> userEmployeeOffices = user.getEmployeeRecord()
                .getEmployeeOffices()
                .stream()
                .filter(employeeOffice -> (employeeOffice.getStatus()))
                .collect(Collectors.toList());

        if (userEmployeeOffices.size() < 1) {
            return null;
        }

        Office office = userEmployeeOffices.get(0).getOffice();
        OfficeUnitOrganogram officeUnitOrganogram = userEmployeeOffices.get(0).getOfficeUnitOrganogram();
        OfficesGRO officesGRO = officesGroDAO.findOfficesGROByOfficeId(office.getId());

        List<OfficesGRO> officesGROForOA = new ArrayList<>();
        if (officeUnitOrganogram != null) {
            officesGROForOA = this.officesGroDAO
                    .findOfficeAdminByOfficeUnitOrganogramId(officeUnitOrganogram.getId());
        }

        if (officesGRO != null && officesGRO.getGroOfficeUnitOrganogramId().equals(officeUnitOrganogram.getId())) {
            return OISFUserType.GRO;
        } else if (userEmployeeOffices.get(0).getIsOfficeHead()) {
            return OISFUserType.HEAD_OF_OFFICE;
        } else if (officesGROForOA.size() > 0) {
           return OISFUserType.OFFICE_ADMIN;
        } else {
            return OISFUserType.SERVICE_OFFICER;
        }
    }

}