package jnpf.dmsPermission;

import jnpf.dmsEntity.permission.enums.DmsPrincipalType;
import jnpf.dmsEntity.permission.form.PermissionGrantItemForm;
import jnpf.dmsMapper.DmsPermissionGroupMapper;
import jnpf.permission.OrganizeApi;
import jnpf.permission.PositionApi;
import jnpf.permission.RoleApi;
import jnpf.permission.UserApi;
import jnpf.permission.entity.OrganizeEntity;
import jnpf.permission.entity.PermissionGroupEntity;
import jnpf.permission.entity.PositionEntity;
import jnpf.permission.entity.RoleEntity;
import jnpf.permission.entity.UserEntity;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

@Component
@RequiredArgsConstructor
public class DmsPrincipalValidator {
    private final UserApi userApi;
    private final OrganizeApi organizeApi;
    private final PositionApi positionApi;
    private final RoleApi roleApi;
    private final DmsPermissionGroupMapper permissionGroupMapper;

    public void validate(List<PermissionGrantItemForm> items) {
        Map<DmsPrincipalType, Set<String>> expected = new EnumMap<>(DmsPrincipalType.class);
        for (PermissionGrantItemForm item : items) {
            expected.computeIfAbsent(item.getPrincipalType(), key -> new HashSet<>())
                    .add(item.getPrincipalId().trim());
        }
        if (expected.containsKey(DmsPrincipalType.USER)) {
            validateType(expected, DmsPrincipalType.USER, ids(userApi.getUserName(list(expected,
                    DmsPrincipalType.USER)), UserEntity::getId));
        }
        if (expected.containsKey(DmsPrincipalType.ORG)) {
            validateType(expected, DmsPrincipalType.ORG, ids(organizeApi.getListByIds(list(expected,
                    DmsPrincipalType.ORG)), OrganizeEntity::getId));
        }
        if (expected.containsKey(DmsPrincipalType.POSITION)) {
            validateType(expected, DmsPrincipalType.POSITION, ids(positionApi.getListByIds(list(expected,
                    DmsPrincipalType.POSITION)), PositionEntity::getId));
        }
        if (expected.containsKey(DmsPrincipalType.ROLE)) {
            validateType(expected, DmsPrincipalType.ROLE, ids(roleApi.getListByIds(list(expected,
                    DmsPrincipalType.ROLE)), RoleEntity::getId));
        }
        if (expected.containsKey(DmsPrincipalType.GROUP)) {
            validateType(expected, DmsPrincipalType.GROUP,
                    ids(permissionGroupMapper.selectEnabledByIds(expected.get(DmsPrincipalType.GROUP)),
                            PermissionGroupEntity::getId));
        }
    }

    public void validateUsers(Collection<String> userIds) {
        Set<String> expected = userIds.stream().map(String::trim).collect(Collectors.toSet());
        Set<String> actual = ids(userApi.getUserName(new ArrayList<>(expected)), UserEntity::getId);
        Set<String> missing = new HashSet<>(expected);
        missing.removeAll(actual);
        if (!missing.isEmpty()) {
            throw DmsPermissionException.of(DmsPermissionError.PRINCIPAL_NOT_FOUND,
                    DmsPrincipalType.USER.name() + " 主体不存在或主体服务不可用: " + missing);
        }
    }

    private List<String> list(Map<DmsPrincipalType, Set<String>> values, DmsPrincipalType type) {
        Set<String> ids = values.get(type);
        return ids == null ? Collections.<String>emptyList() : new ArrayList<>(ids);
    }

    private <T> Set<String> ids(List<T> values, Function<T, String> getter) {
        if (values == null) {
            return Collections.emptySet();
        }
        return values.stream().filter(value -> value != null && getter.apply(value) != null)
                .map(getter).collect(Collectors.toSet());
    }

    private void validateType(Map<DmsPrincipalType, Set<String>> expected, DmsPrincipalType type,
                              Set<String> actual) {
        Set<String> missing = new HashSet<>(expected.getOrDefault(type, Collections.<String>emptySet()));
        missing.removeAll(actual);
        if (!missing.isEmpty()) {
            throw DmsPermissionException.of(DmsPermissionError.PRINCIPAL_NOT_FOUND,
                    type.name() + " 主体不存在或主体服务不可用: " + missing);
        }
    }
}