package jnpf.flowable.util;

import jnpf.exception.WorkFlowException;
import jnpf.base.ActionResult;
import jnpf.flowable.entity.OperatorEntity;
import jnpf.flowable.entity.TemplateNodeEntity;
import jnpf.flowable.enums.EventEnum;
import jnpf.flowable.enums.NodeEnum;
import jnpf.flowable.enums.OperatorStateEnum;
import jnpf.flowable.model.flowable.FlowAbleUrl;
import jnpf.flowable.model.flowable.NextOrPrevFo;
import jnpf.flowable.model.task.FlowModel;
import jnpf.flowable.model.templatenode.nodejson.NodeModel;
import jnpf.flowable.model.util.FlowContextHolder;
import jnpf.flowable.model.util.FlowEventHolder;
import jnpf.util.JsonUtil;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;

@RunWith(MockitoJUnitRunner.class)
public class BackEventsTest {

    @Mock private FlowAbleUrl engine;
    @Mock private FlowUtil flowUtil;
    @InjectMocks private OperatorUtil operatorUtil;

    private FlowModel model;
    private List<OperatorEntity> operators;

    @Before
    public void setUp() {
        FlowEventHolder.clear();
        FlowContextHolder.clearAll();
        model = new FlowModel();
        model.setDeploymentId("deployment");
        model.getTaskEntity().setId("task");
        operators = new ArrayList<>();
        for (String code : Arrays.asList("A", "B", "C", "D")) {
            addNode(code, NodeEnum.APPROVER, OperatorStateEnum.RUNING);
        }
        model.setNodeEntity(model.getNodeEntityList().get(3));
    }

    @After
    public void cleanUp() {
        FlowEventHolder.clear();
        FlowContextHolder.clearAll();
    }

    @Test
    public void sendsBackInReverseOrderExcludingTarget() throws Exception {
        graph(Map.of("D", List.of("C"), "C", List.of("B"), "B", List.of("A")));
        assertEquals(List.of("D", "C", "B"), resolve(List.of("A"), List.of("B", "C", "D")));
    }

    @Test
    public void disabledNodeDoesNotPreventEarlierConfiguredEvent() throws Exception {
        model.getNodes().get("C").getBackFuncConfig().setOn(false);
        graph(Map.of("D", List.of("C"), "C", List.of("B"), "B", List.of("A")));
        assertEquals(List.of("D", "B"), resolve(List.of("A"), List.of("B", "C", "D")));
    }

    @Test
    public void excludesInvalidUnvisitedFutureAndUnrelatedBranchNodes() throws Exception {
        operators.get(1).setStatus(OperatorStateEnum.FUTILITY.getCode());
        addNode("X", NodeEnum.APPROVER, OperatorStateEnum.RUNING);
        addNode("future", NodeEnum.APPROVER, OperatorStateEnum.RUNING);
        addNode("unvisited", NodeEnum.APPROVER, OperatorStateEnum.WAITING);
        graph(Map.of("D", List.of("C", "unvisited"), "C", List.of("B"), "B", List.of("A"),
                "unvisited", List.of("A")));
        assertEquals(List.of("D", "C"), resolve(List.of("A"), List.of("B", "C", "D", "X", "future", "unvisited")));
    }

    @Test
    public void processingNodesParticipateAndDuplicateOperatorsRunOnce() throws Exception {
        model.getNodes().get("C").setType(NodeEnum.PROCESSING.getType());
        operators.add(operators.get(2));
        graph(Map.of("D", List.of("C"), "C", List.of("B"), "B", List.of("A")));
        assertEquals(List.of("D", "C", "B"), resolve(List.of("A"), List.of("B", "C", "D")));
    }

    @Test
    public void mergeWaitsForBothBranchesBeforeSharedPredecessor() throws Exception {
        addNode("X", NodeEnum.PROCESSING, OperatorStateEnum.RUNING);
        graph(Map.of("D", List.of("C", "X"), "C", List.of("B"), "X", List.of("B"), "B", List.of("A")));
        List<String> events = resolve(List.of("A"), List.of("B", "C", "X", "D"));
        assertEquals("D", events.get(0));
        assertEquals(4, events.size());
        assertTrue(events.indexOf("C") < events.indexOf("B"));
        assertTrue(events.indexOf("X") < events.indexOf("B"));
    }

    @Test
    public void stopsAtEverySelectedTarget() throws Exception {
        graph(Map.of("D", List.of("C", "B"), "C", List.of("A")));
        assertEquals(List.of("D", "C"), resolve(List.of("A", "B"), List.of("B", "C", "D")));
    }

    @Test
    public void noConfiguredIntermediateEventPreservesCurrentOnlyWithoutEngineCalls() throws Exception {
        model.getNodes().get("B").getBackFuncConfig().setInterfaceId("");
        model.getNodes().get("C").getBackFuncConfig().setOn(false);
        assertEquals(List.of("D"), resolve(List.of("A"), List.of("B", "C", "D")));
        verifyNoInteractions(engine);
    }

    @Test
    public void cycleTerminatesAndEachNodeRunsOnce() throws Exception {
        graph(Map.of("D", List.of("C"), "C", List.of("B", "D"), "B", List.of("A")));
        assertEquals(List.of("D", "C", "B"), resolve(List.of("A"), List.of("B", "C", "D")));
    }

    @Test
    public void queueDispatchesEachNodesOwnConfigurationAndFormInOrder() throws Exception {
        ServiceUtil service = org.mockito.Mockito.mock(ServiceUtil.class);
        FlowUtil eventUtil = new FlowUtil(null, null, service, null, null, null, null, null, null,
                null, null, null, null, null, null, null, null);
        List<String> calls = new ArrayList<>();
        doAnswer(invocation -> {
            FlowModel event = invocation.getArgument(0);
            eventUtil.event(event, invocation.getArgument(1), invocation.getArgument(2));
            return null;
        }).when(flowUtil).event(any(FlowModel.class), any(Integer.class), any(Map.class));
        doAnswer(invocation -> {
            calls.add(invocation.getArgument(0));
            ActionResult<Object> result = new ActionResult<>();
            result.setCode(200);
            return result;
        }).when(service).infoToId(any(), any());
        // 校验真实事件处理器按各节点表单取数，而不是复用 D 的表单。
        List<String> forms = new ArrayList<>();
        when(service.infoData(any(), any())).thenAnswer(invocation -> {
            forms.add(invocation.getArgument(0));
            assertEquals("task", invocation.getArgument(1));
            return Map.of("node", invocation.getArgument(0));
        });
        TemplateNodeEntity original = model.getNodeEntity();
        operatorUtil.addBackEvents(model, List.of("D", "C", "B"));
        assertEquals(List.of("D", "C", "B"), FlowEventHolder.getAllEvent().stream()
                .map(e -> e.getFlowModel().getNodeEntity().getNodeCode()).collect(Collectors.toList()));
        assertTrue(FlowEventHolder.getAllEvent().stream().allMatch(e -> EventEnum.BACK.getStatus().equals(e.getStatus())));
        assertSame(original, model.getNodeEntity());
        assertEquals(Collections.emptyList(), calls);
        operatorUtil.handleEvent();
        assertEquals(List.of("back-D", "back-C", "back-B"), calls);
        assertEquals(List.of("form-D", "form-C", "form-B"), forms);
        assertTrue(FlowEventHolder.getAllEvent().isEmpty());
    }

    private void graph(Map<String, List<String>> previous) throws WorkFlowException {
        when(engine.getPrev(any(NextOrPrevFo.class))).thenAnswer(invocation -> {
            NextOrPrevFo fo = invocation.getArgument(0);
            assertEquals("deployment", fo.getDeploymentId());
            return previous.getOrDefault(fo.getTaskKey(), Collections.emptyList());
        });
    }

    private List<String> resolve(List<String> targets, List<String> after) throws WorkFlowException {
        return operatorUtil.getBackEventNodeCodes(model, "D", targets, after, operators);
    }

    private void addNode(String code, NodeEnum type, OperatorStateEnum state) {
        NodeModel node = new NodeModel();
        node.setNodeId(code);
        node.setType(type.getType());
        node.getBackFuncConfig().setOn(true);
        node.getBackFuncConfig().setInterfaceId("back-" + code);
        model.getNodes().put(code, node);
        TemplateNodeEntity entity = new TemplateNodeEntity();
        entity.setNodeCode(code);
        entity.setNodeType(type.getType());
        entity.setFormId("form-" + code);
        entity.setNodeJson(JsonUtil.getObjectToString(node));
        model.getNodeEntityList().add(entity);
        OperatorEntity operator = new OperatorEntity();
        operator.setNodeCode(code);
        operator.setStatus(state.getCode());
        operators.add(operator);
    }
}