Enum parent flow

package com.tamkeen.shared.model.enums;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import static com.tamkeen.shared.model.enums.PartnershipContractStatuses.Flow.EPRO_CANCEL_FLOW;
import static com.tamkeen.shared.model.enums.PartnershipContractStatuses.Flow.PRO_CANCEL_FLOW;
import static com.tamkeen.shared.model.enums.PartnershipContractStatuses.Flow.CANCEL_NEW_FLOW;
import static com.tamkeen.shared.model.enums.PartnershipContractStatuses.Flow.CANCEL_APPROVAL_PENDING_FLOW;

public enum PartnershipContractStatuses {
    PROLONGED(0),
    NEW(1),
    APPROVAL_PENDING(2),
    APPROVED(3),
    REJECTED(3, true),
    CANCELLATION_PENDING(4),
    CANCELED(5),
    CANCELLATION_REJECTED(5, true),

    EPRO_CANCELLATION_PENDING(CANCELLATION_PENDING, EPRO_CANCEL_FLOW, UserRoles.EPRO),
    PRO_CANCELED(CANCELED, EPRO_CANCEL_FLOW, UserRoles.PRO_OFFICE, UserRoles.PRO_COMPANY),
    PRO_CANCELLATION_REJECTED(CANCELLATION_REJECTED, EPRO_CANCEL_FLOW, UserRoles.PRO_OFFICE, UserRoles.PRO_COMPANY),

    PRO_CANCELLATION_PENDING(CANCELLATION_PENDING, PRO_CANCEL_FLOW, UserRoles.PRO_OFFICE, UserRoles.PRO_COMPANY),
    EPRO_CANCELED(CANCELED, PRO_CANCEL_FLOW, UserRoles.EPRO),
    EPRO_CANCELLATION_REJECTED(CANCELLATION_REJECTED, PRO_CANCEL_FLOW, UserRoles.EPRO),

    CANCEL_NEW(NEW, 2, CANCEL_NEW_FLOW, UserRoles.PRO_OFFICE, UserRoles.PRO_COMPANY),
    CANCEL_APPROVAL_PENDING(APPROVAL_PENDING, 3, CANCEL_APPROVAL_PENDING_FLOW, UserRoles.PRO_OFFICE, UserRoles.PRO_COMPANY);

    private Flow flow;
    private int order;
    private boolean terminal = false;
    private PartnershipContractStatuses parent;
    private List<UserRoles> supportedRoles = new ArrayList<>();

    private static List<PartnershipContractStatuses> values;

    PartnershipContractStatuses(int order) {
        this(order, false);
    }

    PartnershipContractStatuses(int order, boolean isTerminal) {
        this.order = order;
        this.terminal = isTerminal;
    }

    PartnershipContractStatuses(PartnershipContractStatuses parent, Flow flow, UserRoles... roles) {
        this(parent, null, flow, roles);
    }

    PartnershipContractStatuses(PartnershipContractStatuses parent, Integer order, Flow flow, UserRoles... roles) {
        this(order != null ? order.intValue() : parent.order, parent.terminal);
        this.parent = parent;
        this.flow = flow;
        this.supportedRoles = Arrays.asList(roles);
    }

    public PartnershipContractStatuses getParent() {
        return Optional.ofNullable(this.parent).orElse(this);
    }

    public boolean isNext(PartnershipContractStatuses newSt) {
        return !this.terminal && newSt.order - this.order == 1 && (Objects.isNull(this.flow) || this.flow == newSt.flow);
    }

    public PartnershipContractStatuses getNext() {
        return getValueByFilter(this.order + 1, false, this.flow).orElse(this);
    }

    private static Optional<PartnershipContractStatuses> getValueByFilter(int order, boolean rejected, Flow flow) {
        return Stream.of(PartnershipContractStatuses.values())
                .filter(x -> x.order == order && x.terminal == rejected && x.flow == flow)
                .findAny();
    }

    public static Optional<PartnershipContractStatuses> getValueByParentAndRole(PartnershipContractStatuses parent, UserRoles role) {
        return Stream.of(PartnershipContractStatuses.values())
                .filter(x -> x.order == parent.order && x.terminal == parent.terminal && x.supportedRoles.contains(role))
                .findAny();
    }

    public static Set<PartnershipContractStatuses> getChildStatusesIfExist(PartnershipContractStatuses statusCheck) {
        return Stream.of(PartnershipContractStatuses.values())
            .filter(x -> x.getParent().name().equals(statusCheck.name()))
            .collect(Collectors.toSet());
    }

    public static Set<PartnershipContractStatuses> getExtendedStatuses(Set<PartnershipContractStatuses> statusesSet) {
        Set<PartnershipContractStatuses> resultSet = new HashSet<>();
        statusesSet.forEach(x -> {
            if (Objects.isNull(x.parent)) {
                resultSet.addAll(getChildStatusesIfExist(x));
            } else {
                resultSet.add(x);
            }
        });

        return resultSet;
    }


    enum Flow {
        EPRO_CANCEL_FLOW,
        PRO_CANCEL_FLOW,
        CANCEL_NEW_FLOW,
        CANCEL_APPROVAL_PENDING_FLOW;
    }

}