package jnpf.elnController;

import cn.dev33.satoken.annotation.SaCheckPermission;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import jnpf.base.ActionResult;
import jnpf.base.vo.PageListVO;
import jnpf.elnEntity.template.ElnTemplateForms;
import jnpf.elnEntity.template.ElnTemplateVos;
import jnpf.elnService.template.ElnTemplateBindingService;
import jnpf.elnService.template.ElnTemplateCatalogService;
import jnpf.elnService.template.ElnTemplateHealthService;
import jnpf.elnService.template.ElnTemplateStepService;
import jnpf.util.NoDataSourceBind;
import jnpf.util.context.SpringContext;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.context.support.StaticApplicationContext;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import java.lang.reflect.Method;
import java.util.Collections;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;

public class ElnTemplateCatalogControllerTest {

    @BeforeClass
    public static void setUpSpringContext() {
        SpringContext.setApplicationContext(new StaticApplicationContext());
    }

    @Test
    public void exposesLoginRoutesWithoutDisablingDataSourceBinding() throws Exception {
        assertEquals("/templateCatalog",
                ElnTemplateCatalogController.class.getAnnotation(RequestMapping.class).value()[0]);
        assertFalse(ElnTemplateCatalogController.class.isAnnotationPresent(NoDataSourceBind.class));
        assertGet("list", "", ElnTemplateForms.Query.class);
        assertGet("directory", "/directory", ElnTemplateForms.Query.class);
        assertGet("detail", "/{templateId}", String.class);
        assertPost("createVersion", "/{sourceTemplateId}/versions", String.class,
                ElnTemplateForms.CreateVersion.class);
        assertGet("health", "/{templateId}/health", String.class);
        assertGet("steps", "/{templateId}/steps", String.class);
        assertPut("saveSteps", "/{templateId}/steps", String.class,
                ElnTemplateForms.SaveStepConfiguration.class);
        assertPost("publish", "/{templateId}/publish", String.class, ElnTemplateForms.Reason.class);
        assertPost("enable", "/{templateId}/enable", String.class, ElnTemplateForms.Reason.class);
        assertPost("disable", "/{templateId}/disable", String.class, ElnTemplateForms.Reason.class);
        assertPost("switchCurrent", "/currentVersion", ElnTemplateForms.SwitchCurrent.class);
        assertPost("confirmRemoveMissing", "/bindings/{bindingId}/confirmRemoveMissing",
                String.class, ElnTemplateForms.RemoveMissingConfirm.class);
    }

    @Test
    public void requiresTemplateMenuPermissionForAllLoginRoutes() {
        SaCheckPermission permission =
                ElnTemplateCatalogController.class.getAnnotation(SaCheckPermission.class);

        assertNotNull(permission);
        assertEquals(1, permission.value().length);
        assertEquals("dianziJiluMubanGuanli", permission.value()[0]);
    }

    @Test
    public void reliesOnClassLevelMenuPermissionForEveryWriteRoute() throws Exception {
        assertNoMethodPermission("createVersion", String.class, ElnTemplateForms.CreateVersion.class);
        assertNoMethodPermission("publish", String.class, ElnTemplateForms.Reason.class);
        assertNoMethodPermission("enable", String.class, ElnTemplateForms.Reason.class);
        assertNoMethodPermission("disable", String.class, ElnTemplateForms.Reason.class);
        assertNoMethodPermission("switchCurrent", ElnTemplateForms.SwitchCurrent.class);
        assertNoMethodPermission("confirmRemoveMissing", String.class,
                ElnTemplateForms.RemoveMissingConfirm.class);
    }

    @Test
    public void wrapsCatalogResultsAndForwardsOriginalForms() {
        StubCatalog catalog = new StubCatalog();
        ElnTemplateVos.ListItem item = new ElnTemplateVos.ListItem();
        item.setId("template-1");
        catalog.page = new Page<ElnTemplateVos.ListItem>(2, 10, 21)
                .setRecords(Collections.singletonList(item));
        ElnTemplateVos.CatalogItem directoryItem = new ElnTemplateVos.CatalogItem();
        directoryItem.setMubanBianhao("TPL-001");
        catalog.directory = new Page<ElnTemplateVos.CatalogItem>(2, 10, 11)
                .setRecords(Collections.singletonList(directoryItem));
        StubHealth health = new StubHealth();
        StubBindings bindings = new StubBindings();
        StubSteps steps = new StubSteps();
        ElnTemplateCatalogController controller = new ElnTemplateCatalogController(
                catalog, health, bindings, steps);
        ElnTemplateForms.Query query = new ElnTemplateForms.Query();
        query.setCurrentPage(2);
        query.setPageSize(10);
        ElnTemplateForms.CreateVersion create = new ElnTemplateForms.CreateVersion();
        ElnTemplateForms.RemoveMissingConfirm remove = new ElnTemplateForms.RemoveMissingConfirm();

        ActionResult<PageListVO<ElnTemplateVos.ListItem>> result = controller.list(query);
        ActionResult<PageListVO<ElnTemplateVos.CatalogItem>> directory = controller.directory(query);
        controller.detail("template-1");
        controller.createVersion("source-1", create);
        controller.health("template-1");
        controller.steps("template-1");
        ElnTemplateForms.SaveStepConfiguration stepForm =
                new ElnTemplateForms.SaveStepConfiguration();
        controller.saveSteps("template-1", stepForm);
        controller.confirmRemoveMissing("binding-1", remove);

        assertEquals(Integer.valueOf(200), result.getCode());
        assertEquals("template-1", result.getData().getList().get(0).getId());
        assertEquals(Long.valueOf(2), result.getData().getPagination().getCurrentPage());
        assertEquals(Integer.valueOf(21), result.getData().getPagination().getTotal());
        assertEquals("TPL-001", directory.getData().getList().get(0).getMubanBianhao());
        assertEquals(Long.valueOf(2), directory.getData().getPagination().getCurrentPage());
        assertEquals(Integer.valueOf(11), directory.getData().getPagination().getTotal());
        assertSame(query, catalog.query);
        assertSame(query, catalog.directoryQuery);
        assertSame(create, catalog.createVersion);
        assertSame(remove, bindings.removeMissing);
        assertEquals("binding-1", bindings.bindingId);
        assertEquals("template-1", steps.templateId);
        assertSame(stepForm, steps.form);
    }

    @Test
    public void forwardsReasonsAndCurrentVersionWithoutOwningTransactions() {
        StubCatalog catalog = new StubCatalog();
        ElnTemplateCatalogController controller = new ElnTemplateCatalogController(
                catalog, new StubHealth(), new StubBindings(), new StubSteps());
        ElnTemplateForms.Reason reason = new ElnTemplateForms.Reason();
        reason.setReason(" change ");
        ElnTemplateForms.SwitchCurrent current = new ElnTemplateForms.SwitchCurrent();
        current.setTemplateCode("T-1");
        current.setTemplateId("template-2");
        current.setReason("switch");

        controller.publish("template-1", reason);
        controller.enable("template-1", reason);
        controller.disable("template-1", reason);
        controller.switchCurrent(current);

        assertEquals("template-1:change", catalog.publish);
        assertEquals("template-1:change", catalog.enable);
        assertEquals("template-1:change", catalog.disable);
        assertEquals("T-1:template-2:switch", catalog.current);
    }

    private static void assertGet(String name, String path, Class<?>... types) throws Exception {
        Method method = ElnTemplateCatalogController.class.getMethod(name, types);
        assertEquals(path, first(method.getAnnotation(GetMapping.class).value()));
    }

    private static void assertPost(String name, String path, Class<?>... types) throws Exception {
        Method method = ElnTemplateCatalogController.class.getMethod(name, types);
        assertEquals(path, first(method.getAnnotation(PostMapping.class).value()));
    }

    private static void assertPut(String name, String path, Class<?>... types) throws Exception {
        Method method = ElnTemplateCatalogController.class.getMethod(name, types);
        assertEquals(path, first(method.getAnnotation(PutMapping.class).value()));
    }

    private static void assertNoMethodPermission(String name, Class<?>... types) throws Exception {
        SaCheckPermission permission = ElnTemplateCatalogController.class
                .getMethod(name, types).getAnnotation(SaCheckPermission.class);
        assertNull(name + " 不应再声明按钮权限", permission);
    }

    private static String first(String[] paths) {
        return paths.length == 0 ? "" : paths[0];
    }

    private static final class StubCatalog implements ElnTemplateCatalogService {
        private IPage<ElnTemplateVos.ListItem> page = new Page<>();
        private IPage<ElnTemplateVos.CatalogItem> directory = new Page<>();
        private ElnTemplateForms.Query query;
        private ElnTemplateForms.Query directoryQuery;
        private ElnTemplateForms.CreateVersion createVersion;
        private String publish;
        private String enable;
        private String disable;
        private String current;

        @Override public IPage<ElnTemplateVos.ListItem> page(ElnTemplateForms.Query query) {
            this.query = query; return page;
        }
        @Override public IPage<ElnTemplateVos.CatalogItem> directory(ElnTemplateForms.Query query) {
            this.directoryQuery = query; return directory;
        }
        @Override public ElnTemplateVos.Detail detail(String templateId) { return new ElnTemplateVos.Detail(); }
        @Override public ElnTemplateVos.Detail createVersion(String sourceTemplateId,
                ElnTemplateForms.CreateVersion form) { this.createVersion = form; return new ElnTemplateVos.Detail(); }
        @Override public void publish(String templateId, String reason) { publish = templateId + ":" + reason; }
        @Override public void enable(String templateId, String reason) { enable = templateId + ":" + reason; }
        @Override public void disable(String templateId, String reason) { disable = templateId + ":" + reason; }
        @Override public void switchCurrent(String templateCode, String templateId, String reason) {
            current = templateCode + ":" + templateId + ":" + reason;
        }
    }

    private static final class StubHealth implements ElnTemplateHealthService {
        @Override public HealthReport inspect(String templateId) { return new HealthReport(); }
    }

    private static final class StubSteps implements ElnTemplateStepService {
        @Override public ElnTemplateVos.StepFillStructure fillStructure(
                String tenantId, String templateId) { return null; }
        private String templateId;
        private ElnTemplateForms.SaveStepConfiguration form;
        @Override public ElnTemplateVos.StepConfiguration configuration(String templateId) {
            this.templateId = templateId;
            return new ElnTemplateVos.StepConfiguration();
        }
        @Override public ElnTemplateVos.StepConfiguration save(String templateId,
                ElnTemplateForms.SaveStepConfiguration form) {
            this.templateId = templateId;
            this.form = form;
            return new ElnTemplateVos.StepConfiguration();
        }
        @Override public void copyForVersion(String tenantId, String sourceTemplateId,
                String targetTemplateId) { }
        @Override public String resolveAssignment(String tenantId, String templateId,
                String requestedStepId) { return requestedStepId; }
        @Override public java.util.List<ElnTemplateVos.Diagnostic> validate(
                String tenantId, String templateId) { return Collections.emptyList(); }
    }

    private static final class StubBindings implements ElnTemplateBindingService {
        private String bindingId;
        private ElnTemplateForms.RemoveMissingConfirm removeMissing;
        @Override public void confirmRemoveMissing(String bindingId, ElnTemplateForms.RemoveMissingConfirm form) {
            this.bindingId = bindingId; this.removeMissing = form;
        }
        @Override public ElnTemplateVos.AnnotationContext context(jnpf.elnService.template.TemplateAnnotationAuthorization a) { return null; }
        @Override public ElnTemplateVos.Binding reservePrimary(jnpf.elnService.template.TemplateAnnotationAuthorization a, ElnTemplateForms.ReserveBinding f) { return null; }
        @Override public ElnTemplateVos.Binding reserveReference(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id, String op) { return null; }
        @Override public ElnTemplateVos.Binding changeCheckboxGroup(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id, ElnTemplateForms.ChangeCheckboxGroup f) { return null; }
        @Override public ElnTemplateVos.Binding createPrivateFieldAndReserve(jnpf.elnService.template.TemplateAnnotationAuthorization a, ElnTemplateForms.PrivateField f) { return null; }
        @Override public void activate(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id, String op) { }
        @Override public void cancel(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id, String op, String reason) { }
        @Override public ElnTemplateVos.RepairContext repairContext(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id) { return null; }
        @Override public void confirmRepair(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id, ElnTemplateForms.RepairConfirm f) { }
        @Override public ElnTemplateVos.ChangeCheck checkUpgrade(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id, String target) { return null; }
        @Override public void confirmUpgrade(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id, ElnTemplateForms.UpgradeConfirm f) { }
        @Override public ElnTemplateVos.ChangeCheck checkRemove(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id) { return null; }
        @Override public void confirmRemove(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id, ElnTemplateForms.RemoveConfirm f) { }
        @Override public ElnTemplateVos.ChangeCheck checkPromoteReference(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id) { return null; }
        @Override public void confirmPromoteReference(jnpf.elnService.template.TemplateAnnotationAuthorization a, String id, ElnTemplateForms.PromoteConfirm f) { }
        @Override public void confirmVersionCopy(jnpf.elnService.template.TemplateAnnotationAuthorization a, ElnTemplateForms.VersionCopyConfirm f) { }
    }
}