package jnpf.dmsPermission;

import jnpf.dmsEntity.permission.entity.DmsDocumentEntity;
import jnpf.dmsEntity.permission.entity.DmsFileVersionEntity;
import jnpf.dmsEntity.permission.entity.DmsPermissionResourceEntity;
import jnpf.dmsEntity.permission.enums.DmsResourceType;
import jnpf.dmsEntity.permission.form.PermissionDecisionForm;
import jnpf.dmsEntity.permission.model.DmsFolderAncestorRow;
import jnpf.dmsEntity.permission.model.DmsResourcePath;
import jnpf.dmsMapper.DmsDocumentMapper;
import jnpf.dmsMapper.DmsFileVersionMapper;
import jnpf.dmsMapper.DmsFolderMapper;
import jnpf.dmsMapper.DmsPermissionResourceMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.function.Function;
import java.util.stream.Collectors;

@Component
@RequiredArgsConstructor
public class DmsResourceResolver {
    private final DmsPermissionResourceMapper resourceMapper;
    private final DmsFolderMapper folderMapper;
    private final DmsDocumentMapper documentMapper;
    private final DmsFileVersionMapper fileVersionMapper;

    public DmsResourcePath resolve(String tenantId, DmsResourceType type, UUID id) {
        PermissionDecisionForm request = new PermissionDecisionForm();
        request.setResourceType(type);
        request.setResourceId(id);
        return resolveAll(tenantId, Collections.singletonList(request)).get(id);
    }

    public Map<UUID, DmsResourcePath> resolveAll(String tenantId, List<PermissionDecisionForm> requests) {
        Set<UUID> allIds = requests.stream().map(PermissionDecisionForm::getResourceId)
                .collect(Collectors.toCollection(LinkedHashSet::new));
        Map<UUID, DmsPermissionResourceEntity> registry = byId(
                resourceMapper.selectByTenantAndIds(tenantId, new ArrayList<>(allIds)),
                DmsPermissionResourceEntity::getId);

        Map<DmsResourceType, List<UUID>> idsByType = new EnumMap<>(DmsResourceType.class);
        for (PermissionDecisionForm request : requests) {
            DmsPermissionResourceEntity registered = registry.get(request.getResourceId());
            if (registered == null || !request.getResourceType().name().equals(registered.getResourceType())) {
                throw DmsPermissionException.of(DmsPermissionError.RESOURCE_NOT_FOUND,
                        "权限资源不存在或类型不一致: " + request.getResourceId());
            }
            idsByType.computeIfAbsent(request.getResourceType(), key -> new ArrayList<>())
                    .add(request.getResourceId());
        }

        Map<UUID, DmsFileVersionEntity> versions = byId(loadVersions(tenantId,
                idsByType.get(DmsResourceType.FILE_VERSION)), DmsFileVersionEntity::getId);
        Set<UUID> documentIds = new LinkedHashSet<>();
        documentIds.addAll(orEmpty(idsByType.get(DmsResourceType.DOCUMENT)));
        for (DmsFileVersionEntity version : versions.values()) {
            documentIds.add(version.getDocumentId());
        }
        Map<UUID, DmsDocumentEntity> documents = byId(loadDocuments(tenantId, documentIds),
                DmsDocumentEntity::getId);

        Set<UUID> startFolderIds = new LinkedHashSet<>();
        startFolderIds.addAll(orEmpty(idsByType.get(DmsResourceType.FOLDER)));
        for (DmsDocumentEntity document : documents.values()) {
            startFolderIds.add(document.getFolderId());
        }
        Map<UUID, List<UUID>> folderPaths = loadFolderPaths(tenantId, startFolderIds);

        Map<UUID, DmsResourcePath> result = new LinkedHashMap<>();
        for (PermissionDecisionForm request : requests) {
            DmsResourcePath path = new DmsResourcePath();
            path.setActualResourceId(request.getResourceId());
            path.setActualResourceType(request.getResourceType().name());
            if (request.getResourceType() == DmsResourceType.FOLDER) {
                path.setDirectFolderId(request.getResourceId());
                path.setFolderPath(requiredFolderPath(folderPaths, request.getResourceId()));
            } else if (request.getResourceType() == DmsResourceType.DOCUMENT) {
                DmsDocumentEntity document = requireDocument(documents, request.getResourceId());
                path.setDocumentId(document.getId());
                path.setDirectFolderId(document.getFolderId());
                path.setFolderPath(requiredFolderPath(folderPaths, document.getFolderId()));
            } else {
                DmsFileVersionEntity version = versions.get(request.getResourceId());
                if (version == null) {
                    throw missingBusinessObject(request.getResourceId());
                }
                DmsDocumentEntity document = requireDocument(documents, version.getDocumentId());
                path.setDocumentId(document.getId());
                path.setDirectFolderId(document.getFolderId());
                path.setFolderPath(requiredFolderPath(folderPaths, document.getFolderId()));
            }
            result.put(request.getResourceId(), path);
        }
        return result;
    }

    public List<UUID> candidateResourceIds(DmsResourcePath path) {
        LinkedHashSet<UUID> ids = new LinkedHashSet<>();
        ids.add(path.getActualResourceId());
        if (path.getDocumentId() != null) {
            ids.add(path.getDocumentId());
        }
        ids.addAll(path.getFolderPath());
        return new ArrayList<>(ids);
    }

    private List<DmsFileVersionEntity> loadVersions(String tenantId, List<UUID> ids) {
        return ids == null || ids.isEmpty()
                ? Collections.<DmsFileVersionEntity>emptyList()
                : fileVersionMapper.selectByTenantAndIds(tenantId, distinct(ids));
    }

    private List<DmsDocumentEntity> loadDocuments(String tenantId, Set<UUID> ids) {
        return ids.isEmpty()
                ? Collections.<DmsDocumentEntity>emptyList()
                : documentMapper.selectByTenantAndIds(tenantId, new ArrayList<>(ids));
    }

    private Map<UUID, List<UUID>> loadFolderPaths(String tenantId, Set<UUID> folderIds) {
        Map<UUID, List<UUID>> result = new LinkedHashMap<>();
        if (folderIds.isEmpty()) {
            return result;
        }
        List<DmsFolderAncestorRow> rows = folderMapper.selectAncestorRows(tenantId, new ArrayList<>(folderIds));
        for (DmsFolderAncestorRow row : rows) {
            result.computeIfAbsent(row.getStartFolderId(), key -> new ArrayList<>())
                    .add(row.getAncestorFolderId());
        }
        return result;
    }

    private DmsDocumentEntity requireDocument(Map<UUID, DmsDocumentEntity> documents, UUID id) {
        DmsDocumentEntity document = documents.get(id);
        if (document == null) {
            throw missingBusinessObject(id);
        }
        return document;
    }

    private List<UUID> requiredFolderPath(Map<UUID, List<UUID>> paths, UUID folderId) {
        List<UUID> path = paths.get(folderId);
        if (path == null || path.isEmpty()) {
            throw missingBusinessObject(folderId);
        }
        return path;
    }

    private DmsPermissionException missingBusinessObject(UUID id) {
        return DmsPermissionException.of(DmsPermissionError.RESOURCE_NOT_FOUND,
                "权限登记对应的业务资源不存在: " + id);
    }

    private List<UUID> distinct(List<UUID> ids) {
        return new ArrayList<>(new LinkedHashSet<>(ids));
    }

    private List<UUID> orEmpty(List<UUID> ids) {
        return ids == null ? Collections.<UUID>emptyList() : ids;
    }

    private <T> Map<UUID, T> byId(List<T> values, Function<T, UUID> idGetter) {
        return values.stream().collect(Collectors.toMap(idGetter, Function.identity(), (left, right) -> left,
                LinkedHashMap::new));
    }
}