package jnpf.elnController;

import jnpf.base.ActionResult;
import jnpf.database.util.NotTenantPluginHolder;
import jnpf.elnEntity.template.ElnTemplateForms;
import jnpf.elnEntity.template.ElnTemplateVos;
import jnpf.elnService.template.ElnTemplateBindingService;
import jnpf.elnService.template.TemplateAnnotationAuthorization;
import jnpf.model.tenant.TenantVO;
import jnpf.util.TenantHolder;
import jnpf.util.context.SpringContext;
import org.junit.After;
import org.junit.BeforeClass;
import org.junit.Test;
import org.springframework.aop.aspectj.annotation.AspectJProxyFactory;
import org.springframework.context.support.StaticApplicationContext;
import org.springframework.http.ResponseEntity;

import java.lang.reflect.Constructor;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

public class ElnNoDataSourceBindAspectTest {

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

    @After
    public void clearThreadLocals() {
        TenantHolder.clearLocalTenantCache();
        NotTenantPluginHolder.clearNotSwitchAlwaysFlag();
    }

    @Test
    public void clearsTenantAtEntryAndMarksWholeTicketRequest() {
        setTenant("filter-tenant");
        TrackingBindings bindings = new TrackingBindings();
        ElnTemplateAnnotationController target = new ElnTemplateAnnotationController(ticket -> {
            assertNull(TenantHolder.getLocalTenantCache());
            assertTrue(NotTenantPluginHolder.isNotSwitchAlways());
            setTenant("ticket-tenant");
            return authorization();
        }, bindings);

        ElnTemplateAnnotationController proxy = proxy(target);
        proxy.context("Ticket opaque");

        assertTrue(bindings.calledWithMarker);
        assertNull(TenantHolder.getLocalTenantCache());
        assertFalse(NotTenantPluginHolder.isNotSwitchAlways());
    }

    @Test
    public void clearsMarkerWhenTicketControllerThrows() {
        setTenant("filter-tenant");
        ElnTemplateAnnotationController target = new ElnTemplateAnnotationController(
                ticket -> {
                    setTenant("ticket-tenant");
                    return authorization();
                }, new TrackingBindings()) {
            @Override
            protected <T> ResponseEntity<ActionResult<T>> success(T data) {
                throw new IllegalStateException("response failure");
            }
        };

        try {
            proxy(target).context("Ticket opaque");
            fail("response wrapping should fail");
        } catch (IllegalStateException expected) {
            assertTrue("response failure".equals(expected.getMessage()));
        }

        assertNull(TenantHolder.getLocalTenantCache());
        assertFalse(NotTenantPluginHolder.isNotSwitchAlways());
    }

    private static ElnTemplateAnnotationController proxy(ElnTemplateAnnotationController target) {
        AspectJProxyFactory factory = new AspectJProxyFactory(target);
        factory.setProxyTargetClass(true);
        factory.addAspect(ElnNoDataSourceBindAspect.class);
        return factory.getProxy();
    }

    private static void setTenant(String tenantId) {
        TenantVO tenant = new TenantVO();
        tenant.setEnCode(tenantId);
        TenantHolder.setLocalTenantCache(tenant);
    }

    private static TemplateAnnotationAuthorization authorization() {
        try {
            Constructor<TemplateAnnotationAuthorization> constructor =
                    TemplateAnnotationAuthorization.class.getDeclaredConstructor(
                            String.class, String.class, String.class, String.class);
            constructor.setAccessible(true);
            return constructor.newInstance(
                    "ticket-tenant", "user-1", "template-1", "file-1");
        } catch (ReflectiveOperationException e) {
            throw new AssertionError(e);
        }
    }

    private static class TrackingBindings implements ElnTemplateBindingService {
        private boolean calledWithMarker;

        @Override
        public ElnTemplateVos.AnnotationContext context(TemplateAnnotationAuthorization authorization) {
            calledWithMarker = NotTenantPluginHolder.isNotSwitchAlways()
                    && "ticket-tenant".equals(TenantHolder.getLocalTenantCache().getEnCode());
            return new ElnTemplateVos.AnnotationContext();
        }

        @Override public ElnTemplateVos.Binding reservePrimary(TemplateAnnotationAuthorization a, ElnTemplateForms.ReserveBinding f) { return null; }
        @Override public ElnTemplateVos.Binding reserveReference(TemplateAnnotationAuthorization a, String id, String op) { return null; }
        @Override public ElnTemplateVos.Binding changeCheckboxGroup(TemplateAnnotationAuthorization a, String id, ElnTemplateForms.ChangeCheckboxGroup f) { return null; }
        @Override public ElnTemplateVos.Binding createPrivateFieldAndReserve(TemplateAnnotationAuthorization a, ElnTemplateForms.PrivateField f) { return null; }
        @Override public void activate(TemplateAnnotationAuthorization a, String id, String op) { }
        @Override public void cancel(TemplateAnnotationAuthorization a, String id, String op, String reason) { }
        @Override public ElnTemplateVos.RepairContext repairContext(TemplateAnnotationAuthorization a, String id) { return null; }
        @Override public void confirmRepair(TemplateAnnotationAuthorization a, String id, ElnTemplateForms.RepairConfirm f) { }
        @Override public ElnTemplateVos.ChangeCheck checkUpgrade(TemplateAnnotationAuthorization a, String id, String target) { return null; }
        @Override public void confirmUpgrade(TemplateAnnotationAuthorization a, String id, ElnTemplateForms.UpgradeConfirm f) { }
        @Override public ElnTemplateVos.ChangeCheck checkRemove(TemplateAnnotationAuthorization a, String id) { return null; }
        @Override public void confirmRemove(TemplateAnnotationAuthorization a, String id, ElnTemplateForms.RemoveConfirm f) { }
        @Override public void confirmRemoveMissing(String id, ElnTemplateForms.RemoveMissingConfirm f) { }
        @Override public ElnTemplateVos.ChangeCheck checkPromoteReference(TemplateAnnotationAuthorization a, String id) { return null; }
        @Override public void confirmPromoteReference(TemplateAnnotationAuthorization a, String id, ElnTemplateForms.PromoteConfirm f) { }
        @Override public void confirmVersionCopy(TemplateAnnotationAuthorization a, ElnTemplateForms.VersionCopyConfirm f) { }
    }
}