/**
    * This file Copyright (c) 2017 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.integrationtests;
  
  import java.util.Optional;
  import java.util.function.Function;
  
  import org.apache.commons.beanutils.BeanUtilsBean;
  
  /**
   * Aggregates common settings and parameters useful in UI tests.
   */
  public final class IntegrationTestSettings {
  
      private static final IntegrationTestSettings INSTANCE = new IntegrationTestSettings();
  
      public static IntegrationTestSettings access() {
          return INSTANCE;
      }
  
      private BeanUtilsBean beanUtils = BeanUtilsBean.getInstance();
  
      private Function<String, Integer> toInt = converter(Integer.class);
      private Function<String, Boolean> toBool = converter(Boolean.class);
  
  
      public String testOutputDirectory() {
          return property("test.output.dir").orElse("target/failsafe-reports");
      }
  
      public String recordingsDirectory() {
          return property("recordings.dir").orElse(String.format("%s/recordings/", testOutputDirectory()));
      }
  
      public String uploadDirectory() {
          return property("upload.dir").orElse("target/test-classes");
      }
  
      public String seleniumHubContainerName() {
          return property("selenium.hub.name").orElse("selenium-hub");
      }
  
      public String seleniumHubHost() {
          return property("selenium.hub.host").orElse("localhost");
      }
  
      public int concurrentTestInstances() {
          return property("concurrent.instances").map(toInt).orElse(1);
      }
  
      /**
       * The name of the custom docker network which will be created and used
       * for the docker containers.
       */
      public String testNetworkName() {
          return property("selenium.network").orElse("mgnl-integration-tests");
      }
  
      public String vncPassword() {
          return property("vnc.password").orElse("secret");
      }
  
      public String seleniumBrowser() {
          return property("seleniumBrowser").orElse("chrome");
      }
  
      public boolean testEnvironmentSetupRequired() {
          return property("setup.test.env").map(toBool).orElse(true);
     }
 
     public int defaultDelayInSeconds() {
         return 2;
     }
 
     public int driverTimeoutInSeconds() {
         return property("selenium.timeout").map(toInt).orElse(30);
     }
 
     public int vncPort() {
         return property("vnc.port").map(toInt).orElse(5900);
     }
 
     /**
      * When running a test class, this property determines how many test cases can be run
      * concurrently.
      */
     public int concurrentTestCases() {
         return property("concurrent.test.cases").map(toInt).orElse(1);
     }
 
     public int seleniumHubPort() {
         return property("selenium.hub.port").map(toInt).orElse(4444);
     }
 
     public boolean debugMode() {
         return property("debug.mode").map(toBool).orElse(true);
     }
 
     public boolean keepSuccessfulTestRecordings() {
         return property("keep.successful").map(toBool).orElse(false);
     }
 
     public boolean useHeadlessSeleniumNodes() {
         return property("run.headless").map(toBool).orElse(false);
     }
 
     private Optional<String> property(String key) {
         return Optional.ofNullable(System.getProperty(key));
     }
 
     @SuppressWarnings("unchecked")
     private <T> Function<String, T> converter(Class<T> clazz) {
         return str -> (T) beanUtils.getConvertUtils().convert(str, clazz);
     }
 
     public String authorWarLocation() {
         return property("author.war.location").orElse("target/wars/magnoliaAuthor.war");
     }
 
     public String publicWarLocation() {
         return property("public.war.location").orElse("target/wars/magnoliaPublic.war");
     }
 
     public String authorContextPath() {
         return property("authorContextPath").orElse("magnoliaAuthor");
     }
 
     public String publicContextPath() {
         return property("publicContextPath").orElse("magnoliaPublic");
     }
 
 
     /**
      * Test instance URL accessible from outside of the test environment.
      * E.g. if the test env is deployed as a Docker setup (maybe even remote)
      * and integration tests are executed outside of such setup, this URL can
      * still provide "direct" access to the Magnolia deployment. This might be useful
      * for interacting with the instance bypassing the Selenium driver (e.g. via REST).
      */
     public String directContainerRootURL() {
         return String.format("http://%s:%d", publicHostName(), publicPort());
     }
 
     /**
      * Instance host name by it is known with the test environment.
      * E.g. when Selenium and test Magnolia instances are deployed
      * in the same Docker network, Selenium driver can use this
      * host name for navigation. However, this host name is not
      * accessible to the outer world.
      *
      * @see #containerRootUrl()
      */
     public String privateHostName() {
         return property("privateHostName").orElse("server");
     }
 
     /**
      * Test environment-specific port which corresponds to the {@link #privateHostName()}.
      *
      * @see #containerRootUrl()
      */
     public int privatePort() {
         return property("privateContainerHttpPort").map(toInt).orElse(8080);
     }
 
     /**
      * Test Magnolia instance host name available from outside of the test environment.
      * When the test environment setup is deployed on the same machine on which the
      * integration tests are executed, then typically this would be 'localhost'. In
      * case of the remote test env deployment, some other host name should be configured.
      *
      * @see #containerRootUrl()
      */
     public String publicHostName() {
         return property("containerHostName").orElse("localhost");
     }
 
     /**
      * Magnolia instance port open to the outer world. Unlike {@link #privatePort()},
      * this port is used for Mgnl instance access from outside of the Docker environment.
      *
      * @see #publicHostName()
      * @see #directContainerRootURL() ()
      */
     public int publicPort() {
         return property(String.format("%s.public.port", privateHostName())).map(toInt).orElseGet(() ->
                 property("containerHttpPort")
                     .map(toInt)
                     .orElse(8599));
     }
 
     /**
      * Test instance's URL available within the [Docker] test environment and
      * not exposed to the outer world.
      */
     public String containerRootUrl() {
         return String.format("http://%s:%d", privateHostName(), privatePort());
     }
 
     public Integer startupTimeout() {
         return property("startupTimeout").map(toInt).orElse(7);
     }
 
     public String tomcatDockerImage() {
         return property("tomcatDockerImage").orElse("amd64/tomcat:9.0-jre8");
     }
 }