/*
 * Copyright (c) 2005, 2021 Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2005, 2015 SAP. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     SAP - initial API and implementation

package org.eclipse.persistence.testing.framework.wdf;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;
import java.util.Properties;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.rmi.PortableRemoteObject;

import org.eclipse.persistence.config.PersistenceUnitProperties;
import org.eclipse.persistence.platform.database.DatabasePlatform;
import org.eclipse.persistence.testing.framework.wdf.customizer.AdjustArrayTypeCustomizer;
import org.eclipse.persistence.testing.framework.wdf.server.Notification;
import org.eclipse.persistence.testing.framework.wdf.server.ServerTestRunner;
import org.junit.Assert;
import org.junit.runner.Description;
import org.junit.runner.notification.RunNotifier;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;

public class SkipBugzillaTestRunner extends BlockJUnit4ClassRunner {

    private static final String TEST_TO_BE_INVESTIGATED_RUN = "test.to-be-investigated.run";
    private static final String TEST_ISSUE_RUN = "test.issue.run";
    private static final String TEST_BUGZILLA_RUN = "test.bugzilla.run";


    @Override
    public void run(RunNotifier notifier) {
        if (Boolean.parseBoolean(System.getProperty("servertest"))) {
            runOnServer(notifier);
        } else {
            super.run(notifier);
        }
    }

    /**
     * Delegates test execution to the server. On the server, JUnit will be
     * invoked to run the tests with a special run listener, which collects
     * the notifications (events). On the client, the recorded notifications will be
     * replayed on the run notifier passed to this message.
     * @param notifier the run notifier to replay the notifications recorded on the server
     */
    private void runOnServer(RunNotifier notifier) {
        Properties properties = new Properties();
        String url = getMandatorySystemProperty("server.url");
        properties.put("java.naming.provider.url", url);
        Context context;
        try {
            context = new InitialContext(properties);
            String testrunner = getMandatorySystemProperty("server.testrunner.wdf");
            String dataSourceName = getMandatorySystemProperty("datasource.name");

            Object object = context.lookup(testrunner);
            ServerTestRunner runner = (ServerTestRunner) PortableRemoteObject.narrow(object, ServerTestRunner.class);
            String testClassName = getTestClass().getJavaClass().getName();
            List<Notification> notifications = runner.runTestClass(testClassName, dataSourceName, testProperties);

            for (Notification notification : notifications) {
                notification.notify(notifier);
            }
        } catch (NamingException e) {
            throw new RuntimeException(e);
        }
    }

    private String getMandatorySystemProperty(final String propertyName) {
        String url = System.getProperty(propertyName);
        if (url == null) {
            Assert.fail("System property '" + propertyName + "' must be set.");
        }
        return url;
    }

    final long bugid;
    final long issueid;
    final boolean runAllBugzilla;
    final boolean runAllIssues;
    final boolean runAllUnknown;
    final boolean runOnlyUnknown;
    final Class<? extends DatabasePlatform> databasePlatformClass;
    private final Map<String, String> testProperties;


    @SuppressWarnings("unchecked")
    public SkipBugzillaTestRunner(Class<?> klass) throws Throwable {
        super(klass);

        testProperties = AbstractBaseTest.getTestProperties();


        addProperty(TEST_BUGZILLA_RUN);
        addProperty(TEST_ISSUE_RUN);
        addProperty(TEST_TO_BE_INVESTIGATED_RUN);

        String databasePlatformClassName = testProperties.get(PersistenceUnitProperties.TARGET_DATABASE);


        if (databasePlatformClassName != null) {
            databasePlatformClass = (Class<? extends DatabasePlatform>) Class.forName(databasePlatformClassName);
            AdjustArrayTypeCustomizer.setDatabasePlatformClass(databasePlatformClass);
        } else {
            databasePlatformClass = null; // FIXME
        }

        String testBugzillaRun = testProperties.get(TEST_BUGZILLA_RUN);
        if ("all".equals(testBugzillaRun)) {
            runAllBugzilla = true;
            bugid = -1;
        } else {
            runAllBugzilla = false;
            if (testBugzillaRun != null) {
                bugid = Long.parseLong(testBugzillaRun);
            } else {
                bugid = -1;
            }
        }

        String testIssueRun = testProperties.get(TEST_ISSUE_RUN);
        if ("all".equals(testIssueRun)) {
            runAllIssues = true;
            issueid = -1;
        } else {
            runAllIssues = false;
            if (testIssueRun != null) {
                issueid = Long.parseLong(testIssueRun);
            } else {
                issueid = -1;
            }
        }

        String testToBeInvestigatedRun = testProperties.get(TEST_TO_BE_INVESTIGATED_RUN);
        if ("all".equals(testToBeInvestigatedRun)) {
            runAllUnknown = true;
            runOnlyUnknown = false;
        } else if ("only".equals(testToBeInvestigatedRun)) {
            runAllUnknown = false;
            runOnlyUnknown = true;
        } else {
            runAllUnknown = false;
            runOnlyUnknown = false;
        }


    }

    private void addProperty(final String name) {
        String value = System.getProperty(name);
        if(value != null) {
            testProperties.put(name, value);
        }
    }

    @Override
    protected void runChild(FrameworkMethod method, RunNotifier notifier) {
        try {
            skipMethod(method, notifier, SKIP_SKIPPER);
            skipMethod(method, notifier, BUGZILLA_SKIPPER);
            skipMethod(method, notifier, ISSUE_SKIPPER);
            skipMethod(method, notifier, TO_BE_INVESTIGATED_SKIPPER);
            super.runChild(method, notifier);
        } catch (SkipException ex) {
            Description description = describeChild(method);
            notifier.fireTestIgnored(description);
        }
    }

    private <T extends Annotation> void skipMethod(FrameworkMethod method, RunNotifier notifier, Skipper<T> skipper)
            throws SkipException {
        Method reflectMethod = method.getMethod();
        T a = skipper.getAnnotation(reflectMethod);
        if (a == null) {
            if (skipper.skipOthers()) {
                throw new SkipException();
            }
            return;
        }

        if (skipper.runAll()) {
            return;
        }

        if (skipper.runThis(a)) {
            return;
        }

        Class<? extends DatabasePlatform>[] databases = skipper.getDatabases(a);
        String[] databaseNames = skipper.getDatabaseNames(a);

        if ((databases == null || databases.length == 0) && (databaseNames == null || databaseNames.length == 0)) {
            // all databases are unsupported
            throw new SkipException();
        }

        if (databasePlatformClass != null) {
            if (databases != null) {
                for (Class<? extends DatabasePlatform> clazz : databases) {
                    if (clazz.isAssignableFrom(databasePlatformClass)) {
                        // the current database platform is not supported
                        throw new SkipException();
                    }
                }
            }

            if (databaseNames != null) {
                for (String name : databaseNames) {
                    if (databasePlatformClass.getName().equals(name)) {
                        // the current database platform is not supported
                        throw new SkipException();
                    }
                }
            }
        }

        return;
    }

    private static class SkipException extends Exception {
        private static final long serialVersionUID = 1L;
    }

    private Skipper<Skip> SKIP_SKIPPER = new Skipper<Skip>() {

        @Override
        public Skip getAnnotation(Method method) {
            return method.getAnnotation(Skip.class);
        }

        @Override
        public Class<? extends DatabasePlatform>[] getDatabases(Skip skip) {
            return skip.databases();
        }

        @Override
        public boolean runAll() {
            return false;
        }

        @Override
        public boolean runThis(Skip skip) {

            if(skip.server()) {
                return !ServerInfoHolder.isOnServer();
            }

            return false;
        }

        @Override
        public boolean skipOthers() {
            return false;
        }

        @Override
        public String[] getDatabaseNames(Skip skip) {
            return skip.databaseNames();
        }

    };

    private final Skipper<Bugzilla> BUGZILLA_SKIPPER = new Skipper<Bugzilla>() {

        @Override
        public Bugzilla getAnnotation(Method method) {
            return method.getAnnotation(Bugzilla.class);
        }

        @Override
        public Class<? extends DatabasePlatform>[] getDatabases(Bugzilla t) {
            return t.databases();
        }

        @Override
        public boolean runAll() {
            return runAllBugzilla;
        }

        @Override
        public boolean runThis(Bugzilla t) {
            return t.bugid() == bugid;
        }

        @Override
        public boolean skipOthers() {
            return false;
        }

        @Override
        public String[] getDatabaseNames(Bugzilla t) {
            return t.databaseNames();
        }

    };

    private final Skipper<Issue> ISSUE_SKIPPER = new Skipper<Issue>() {

        @Override
        public Issue getAnnotation(Method method) {
            return method.getAnnotation(Issue.class);
        }

        @Override
        public Class<? extends DatabasePlatform>[] getDatabases(Issue t) {
            return t.databases();
        }

        @Override
        public boolean runAll() {
            return runAllIssues;
        }

        @Override
        public boolean runThis(Issue t) {
            return t.issueid() == issueid;
        }

        @Override
        public boolean skipOthers() {
            return false;
        }

        @Override
        public String[] getDatabaseNames(Issue t) {
            return t.databaseNames();
        }

    };

    private final Skipper<ToBeInvestigated> TO_BE_INVESTIGATED_SKIPPER = new Skipper<ToBeInvestigated>() {

        @Override
        public ToBeInvestigated getAnnotation(Method method) {
            return method.getAnnotation(ToBeInvestigated.class);
        }

        @Override
        public Class<? extends DatabasePlatform>[] getDatabases(ToBeInvestigated t) {
            return t.databases();
        }

        @Override
        public boolean runAll() {
            return runAllUnknown || runOnlyUnknown;
        }

        @Override
        public boolean runThis(ToBeInvestigated t) {
            return false;
        }

        @Override
        public boolean skipOthers() {
            return runOnlyUnknown;
        }

        @Override
        public String[] getDatabaseNames(ToBeInvestigated t) {
            return t.databaseNames();
        }

    };

    private interface Skipper<T extends Annotation> {
        T getAnnotation(Method method);

        boolean runAll();

        boolean runThis(T t);

        boolean skipOthers();

        Class<? extends DatabasePlatform>[] getDatabases(T t);

        String[] getDatabaseNames(T t);
    }


}