package jnpf.flowable.service.dev;

import jnpf.base.UserInfo;
import jnpf.config.ConfigValueUtil;
import jnpf.exception.WorkFlowException;
import jnpf.util.UserProvider;
import jnpf.database.util.TenantDataSourceUtil;
import org.junit.*;
import org.mockito.MockedStatic;
import java.util.*;
import java.util.concurrent.Executor;
import static org.junit.Assert.*;
import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.*;

public class DevApprovalRunsTest {
    private final DevApprovalService service = mock(DevApprovalService.class);
    private final DevApprovalSignatures signatures = mock(DevApprovalSignatures.class);
    private final DevApprovalRuns runs = new DevApprovalRuns(service, signatures, mock(ConfigValueUtil.class));
    private final List<Runnable> jobs = new ArrayList<>();
    private MockedStatic<UserProvider> users;
    private MockedStatic<TenantDataSourceUtil> tenants;
    private UserInfo user;

    @Before public void setup() throws Exception {
        jnpf.util.context.SpringContext.setApplicationContext(mock(org.springframework.context.ApplicationContext.class));
        users = mockStatic(UserProvider.class); tenants = mockStatic(TenantDataSourceUtil.class);
        user = new UserInfo(); user.setUserId("admin"); user.setTenantId("tenant"); user.setToken("session"); user.setIsAdministrator(true);
        users.when(UserProvider::getUser).thenReturn(user);
        users.when(() -> UserProvider.isValidToken("session")).thenReturn(true);
        when(service.allowed()).thenReturn(true);
        when(service.inspect("task", null)).thenReturn(state("READY", null));
        var field = DevApprovalRuns.class.getDeclaredField("executor"); field.setAccessible(true);
        field.set(runs, (Executor) jobs::add);
    }
    private interface Checked { void run() throws Exception; }
    private void rejected(Checked action) throws Exception {
        try { action.run(); fail("Must reject"); } catch (WorkFlowException expected) { }
    }
    @After public void cleanup() { users.close(); tenants.close(); }
    private DevApprovalService.State state(String status, String operator) {
        var s = new DevApprovalService.State(); s.setEnabled(true); s.setStatus(status); s.setOperatorId(operator); return s;
    }
    @Test public void startReturnsBeforeExecutionAndRepeatedStartIsIdempotent() throws Exception {
        var first = runs.start("task", "sign");
        assertEquals("RUNNING", first.status()); assertEquals(1, jobs.size());
        assertEquals(first.runId(), runs.start("task", "sign").runId());
        verify(service, never()).approve(anyString(), any(), anyString());
        when(service.approve("task", null, "sign")).thenReturn(state("ADVANCED", "op1"), state("PASSED", "op2"));
        jobs.getFirst().run();
        assertEquals("PASSED", runs.status("task").status()); assertEquals(2, runs.status("task").completed());
        assertEquals(first.runId(), runs.start("task", "sign").runId()); assertEquals(1, jobs.size());
        verify(service, times(2)).approve("task", null, "sign");
        users.verify(UserProvider::clearLocalUser);
    }
    @Test public void disabledOrNonAdminCannotStartReadOrStop() throws Exception {
        when(service.allowed()).thenReturn(false);
        rejected(() -> runs.start("task", "sign"));
        rejected(() -> runs.status("task"));
        rejected(() -> runs.stop("task", "id"));
        assertTrue(jobs.isEmpty()); verifyNoInteractions(signatures);
    }
    @Test public void invalidSignatureNeverSchedules() throws Exception {
        when(signatures.require("task", "bad")).thenThrow(new WorkFlowException("签名无效"));
        rejected(() -> runs.start("task", "bad")); assertTrue(jobs.isEmpty());
    }
    @Test public void ownerAndTenantIsolationAndStaleStop() throws Exception {
        var first = runs.start("task", "sign");
        user.setUserId("other");
        rejected(() -> runs.status("task"));
        rejected(() -> runs.start("task", "sign"));
        rejected(() -> runs.stop("task", first.runId()));
        user.setTenantId("another"); assertEquals("IDLE", runs.status("task").status());
        user.setTenantId("tenant"); user.setUserId("admin");
        rejected(() -> runs.stop("task", "stale"));
    }
    @Test public void stopCompletesCurrentStepAndNeverAdvancesNext() throws Exception {
        var first = runs.start("task", "sign");
        when(service.approve("task", null, "sign")).thenAnswer(call -> {
            runs.stop("task", first.runId()); return state("ADVANCED", "op1");
        });
        jobs.getFirst().run();
        assertEquals("STOPPED", runs.status("task").status()); assertEquals(1, runs.status("task").completed());
        verify(service, times(1)).approve("task", null, "sign");
    }
    @Test public void expiryAndBusinessFailureStopWithoutRetry() throws Exception {
        runs.start("task", "sign"); users.when(() -> UserProvider.isValidToken("session")).thenReturn(false);
        jobs.getFirst().run(); assertEquals("FAILED", runs.status("task").status());
        verify(service, never()).approve(anyString(), any(), anyString());
        users.when(() -> UserProvider.isValidToken("session")).thenReturn(true);
        when(service.approve("task", null, "new-sign")).thenThrow(new WorkFlowException("必填数据不完整"));
        runs.start("task", "new-sign"); jobs.get(1).run();
        assertEquals("FAILED", runs.status("task").status());
        assertEquals("必填数据不完整", runs.status("task").message());
        verify(service, times(1)).approve("task", null, "new-sign");
    }
    @Test public void longFlowsStopAtTheServerLimitAndReleaseCapacity() throws Exception {
        var sequence = new java.util.concurrent.atomic.AtomicInteger();
        when(service.approve("task", null, "sign")).thenAnswer(call -> state("ADVANCED", "op" + sequence.incrementAndGet()));
        runs.start("task", "sign");
        jobs.getFirst().run();
        assertEquals("STOPPED", runs.status("task").status());
        assertEquals(100, runs.status("task").completed());
        verify(service, times(100)).approve("task", null, "sign");
        assertEquals("RUNNING", runs.start("task", "new-sign").status());
        assertEquals(2, jobs.size());
    }

}