EDIT

/**

 * Copyright (C) 2015 EDIT

 * European Distributed Institute of Taxonomy

 * http://www.e-taxonomy.eu

 *

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.remoting.source;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.net.InetSocketAddress;

import java.net.Socket;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import org.apache.commons.lang.StringUtils;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.ResponseHandler;

import org.apache.http.client.config.RequestConfig;

import org.apache.http.client.methods.HttpGet;

import org.apache.http.impl.client.CloseableHttpClient;

import org.apache.http.impl.client.HttpClientBuilder;

import org.apache.http.util.EntityUtils;

import org.apache.log4j.Logger;

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

import com.fasterxml.jackson.core.type.TypeReference;

import com.fasterxml.jackson.databind.ObjectMapper;

import eu.etaxonomy.cdm.api.application.CdmApplicationRemoteConfiguration;

import eu.etaxonomy.cdm.api.application.CdmApplicationState;

import eu.etaxonomy.cdm.config.CdmSourceException;

import eu.etaxonomy.cdm.config.ConfigFileUtil;

import eu.etaxonomy.cdm.database.CdmPersistentDataSource;

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.model.metadata.CdmMetaData;

import eu.etaxonomy.taxeditor.remoting.server.CDMServerException;

import eu.etaxonomy.taxeditor.remoting.server.CDMServerUtils;

/**

 * @author cmathew

 * @date 20 Jan 2015

 */

public class CdmServerInfo {

    public static final Logger logger = Logger.getLogger(CdmServerInfo.class);

    private final static String CDMSERVER_PREFIX = "cdmserver/";

    private final static String NAME_PRODUCTION = "cybertaxonomy.org";

    private final static String SERVER_PRODUCTION = "api.cybertaxonomy.org";

    private final static String NAME_DEMO_1 = "demo I";

    private final static String SERVER_DEMO_1 = "160.45.63.230";

    public final static String SERVER_LOCALHOST = "localhost";

    private final static String NAME_LOCALHOST = "localhost";

    public final static String NAME_LOCALHOST_MGD = "localhost mgd.";

    private final static String NAME_LOCALHOST_DEV = "localhost-dev";

    private final static String NAME_INSTANCE_LOCALHOST_DEV = "local-dev";

    private final static String SERVER_LOCALHOST_DEV = "localhost";

    private final static String BASEPATH_LOCALHOST_DEV = "";

    public final static int NULL_PORT = -1;

    public final static String NULL_PORT_STRING = "N/A";

    private static final String CDM_REMOTE_SERVERS_CONFIG_FILE = "cdm_remote_servers.json";

    private final String name;

    private final String server;

    private int port;

    private final List<CdmInstanceInfo> instances;

    private String cdmlibServicesVersion = "";

    private String cdmlibServicesLastModified = "";

    private String prefix = "";

    private boolean ignoreCdmLibVersion = false;

    public CdmServerInfo(CdmServerInfoConfig parameterObject) {

        this.name = parameterObject.getName();

        this.server = parameterObject.getServer();

        this.port = parameterObject.getPort();

        this.prefix = parameterObject.getPrefix();

        this.ignoreCdmLibVersion = parameterObject.isIgnoreCdmLibVersion();

        instances = new ArrayList<>();

    }

    public CdmInstanceInfo addInstance(String name, String basePath) {

        String _basePath = basePath;

        if(isLocalhostMgd()) {

            _basePath = "";

        }

        CdmInstanceInfo cii = new CdmInstanceInfo(name, _basePath);

        instances.add(cii);

        return cii;

    }

    public boolean isLocalhost() {

        return name.startsWith(SERVER_LOCALHOST);

    }

    public boolean isLocalhostMgd() {

        return NAME_LOCALHOST_MGD.equals(name);

    }

    public String getCdmlibServicesVersion() {

        return cdmlibServicesVersion;

    }

    public String getCdmlibLastModified() {

        return cdmlibServicesLastModified;

    }

    public void refreshInstances() throws CDMServerException {

        instances.clear();

        if(isLocalhostMgd()) {

            addInstancesFromDataSourcesConfig();

        } else {

            addInstancesViaHttp();

        }

        Collections.sort(instances, new Comparator<CdmInstanceInfo>() {

            @Override

            public int compare(CdmInstanceInfo cii1, CdmInstanceInfo cii2)

            {

                return cii1.getName().toString().compareTo(cii2.getName().toString());

            }

        });

    }

    public void updateInfo() throws CDMServerException {

        String url = guessProtocol() + "://" + server + ":" + String.valueOf(port) + "/" + prefix + "info.jsp";

        String responseBody = getResponse(url);

        if(responseBody != null) {

            try {

                JSONObject info = new JSONObject(responseBody);

                cdmlibServicesVersion =  info.getString("cdmlibServicesVersion");

                cdmlibServicesLastModified = info.getString("cdmlibServicesLastModified");

            } catch (JSONException e) {

                throw new CDMServerException(e);

            }

        }

    }

    String guessProtocol() {

        return port == 443 ? "https" : "http";

    }

    public void addInstancesViaHttp() throws CDMServerException {

        updateInfo();

        String url = guessProtocol() + "://" + server + ":" + String.valueOf(port) + "/" + prefix + "instances.jsp";

        String responseBody = getResponse(url);

        if(responseBody != null) {

            try {

                JSONArray array = new JSONArray(responseBody);

                for(int i=0;i<array.length();i++) {

                    JSONObject instance = (JSONObject)array.get(i);

                    if(instance != null) {

                        JSONObject conf = (JSONObject)instance.get("configuration");

                        if(conf != null) {

                            String instanceName = conf.getString("instanceName");

                            // we need to remove the first (char) forward slash from

                            // the base path

                            String basePath = conf.getString("basePath").substring(1);

                            addInstance(instanceName, basePath);

                            logger.info("Added instance with name : " + instanceName + ", basePath : " + basePath);

                        }

                    }

                }

            } catch (JSONException e) {

                throw new CDMServerException(e);

            }

        }

    }

    private String getResponse(String url) throws CDMServerException {

        RequestConfig.Builder requestBuilder = RequestConfig.custom();

        requestBuilder.setConnectTimeout(CdmApplicationRemoteConfiguration.HTTP_READ_TIMEOUT_MIN);

        requestBuilder.setConnectionRequestTimeout(CdmApplicationRemoteConfiguration.HTTP_READ_TIMEOUT_MIN);

        requestBuilder.setSocketTimeout(CdmApplicationRemoteConfiguration.HTTP_READ_TIMEOUT_MIN);

        CloseableHttpClient client = HttpClientBuilder.create().setDefaultRequestConfig(requestBuilder.build()).build();

        HttpGet httpGet = new HttpGet(url);

        logger.info("Executing request " + httpGet.getRequestLine());

        // Create a custom response handler

        ResponseHandler<String> responseHandler = new ResponseHandler<String>() {

            @Override

            public String handleResponse(

                    final HttpResponse response) throws ClientProtocolException, IOException {

                int status = response.getStatusLine().getStatusCode();

                if (status >= 200 && status < 300) {

                    HttpEntity entity = response.getEntity();

                    return entity != null ? EntityUtils.toString(entity) : null;

                } else {

                    throw new ClientProtocolException("Unexpected response status: " + status);

                }

            }

        };

        String responseBody = null;

        try {

            responseBody = client.execute(httpGet, responseHandler);

        } catch (ClientProtocolException e) {

            throw new CDMServerException(e);

        } catch (IOException e) { // java.net.ConnectException: Connection refused, java.net.SocketTimeoutException: Read timed out

            throw new CDMServerException(e);

        } finally{

            try {

                client.close();

                client = null;

            } catch (IOException e) {

                // IGNORE //

            }

        }

        return responseBody;

    }

    public void addInstancesFromDataSourcesConfig() {

        for(ICdmDataSource dataSource : CdmPersistentDataSource.getAllDataSources()){

            String datasourceNCName = CDMServerUtils.xmlNCNamefrom(dataSource.getName());

            logger.info("Adding local instance " + dataSource.getName() + " as " + datasourceNCName);

            addInstance(datasourceNCName, datasourceNCName);

        }

    }

    public String toString(String instanceName, int port) {

        return server + ":" + String.valueOf(port) + "/" + instanceName;

    }

    public CdmInstanceInfo getInstanceFromName(String instanceName) {

        if(instanceName == null) {

            return null;

        }

        for(CdmInstanceInfo instance : instances) {

            if(instance.getName() != null && instance.getName().equals(instanceName)) {

                return instance;

            }

        }

        return null;

    }

    public CdmRemoteSource getCdmRemoteSource(CdmInstanceInfo instance, int port) {

        if(instance != null) {

            return CdmRemoteSource.NewInstance(name,

                    server,

                    port,

                    instance.getBasePath()

                    );

        }

        return null;

    }

    public boolean pingServer() throws CDMServerException, IOException {

        if(isLocalhostMgd()) {

            return true;

        }

        Socket s = new Socket();

        s.connect(new InetSocketAddress(server, port), CdmApplicationRemoteConfiguration.HTTP_READ_TIMEOUT_MIN);

        s.close();

        logger.info("[CDM-Server] Available @ " + server + ":" + port );

        updateInfo();

        return true;

    }

    public boolean pingInstance(CdmInstanceInfo instance, int port) throws CDMServerException  {

        ICdmRemoteSource crs = getCdmRemoteSource(instance, port);

        try {

            if(crs != null && crs.checkConnection()) {

                logger.info("[CDM-Server] Running @ " + server + ":" + port + " for instance " + instance);

                return true;

            }

        } catch (CdmSourceException e) {

            logger.error(e.getMessage(), e);

            throw new CDMServerException(e);

        }

        return false;

    }

    public int compareDbSchemaVersion(CdmInstanceInfo instance, int port) throws CDMServerException {

        ICdmRemoteSource crs = getCdmRemoteSource(instance, port);

        String dbSchemaVersion;

        try {

            dbSchemaVersion = crs.getDbSchemaVersion();

        } catch (CdmSourceException e) {

            throw new CDMServerException(e);

        }

        if(dbSchemaVersion != null) {

            return CdmMetaData.compareVersion(dbSchemaVersion, CdmMetaData.getDbSchemaVersion(), 3, null);

        } else {

            throw new CDMServerException("Cannot determine editor db. schema version");

        }

    }

    public int compareCdmlibServicesVersion() throws CdmSourceException {

        String serverVersion = cdmlibServicesVersion;

        String serverCdmlibLastModified = cdmlibServicesLastModified;

        if(ignoreCdmLibVersion) {

            return 0;

        } else {

            return compareCdmlibServicesVersion(serverVersion, serverCdmlibLastModified);

        }

    }

    public static int compareCdmlibServicesVersion(String serverVersion, String serverCdmlibLastModified) throws CdmSourceException {

        String editorVersion = CdmApplicationState.getCdmlibVersion();

        String editorCdmlibLastModified = CdmApplicationState.getCdmlibLastModified();

        int result = 0;

        if(StringUtils.isBlank(serverVersion) || StringUtils.isBlank(editorVersion)) {

            throw new CdmSourceException("cdmlib-services server or editor version is empty");

        }

        String[] serverVersionSplit = serverVersion.split("\\.");

        String[] editorVersionSplit = editorVersion.split("\\.");

        if(serverVersionSplit.length < 3 || editorVersionSplit.length < 3 || serverVersionSplit.length > 4 || editorVersionSplit.length > 4) {

            throw new CdmSourceException("cdmlib-services server or editor version is invalid");

        }

        Integer serverVersionPart;

        Integer editorVersionPart;

        for(int i=0 ; i<3 ; i++) {

            serverVersionPart = Integer.valueOf(serverVersionSplit[i]);

            editorVersionPart = Integer.valueOf(editorVersionSplit[i]);

            int partCompare = serverVersionPart.compareTo(editorVersionPart);

            if (partCompare != 0){

                return partCompare;

            }

        }

        // at this point major, minor and patch versions are matching

        if(StringUtils.isBlank(serverCdmlibLastModified) || StringUtils.isBlank(editorCdmlibLastModified)) {

            throw new CdmSourceException("cdmlib-services server or editor version is empty");

        }

        String cdmServerIgnoreVersion = System.getProperty("cdm.server.version.lm.ignore");

        if(StringUtils.isBlank(cdmServerIgnoreVersion) || !cdmServerIgnoreVersion.equals("true")) {

            Long serverLastModified = Long.valueOf(serverCdmlibLastModified);

            Long editorLastModified = Long.valueOf(editorCdmlibLastModified);

            return serverLastModified.compareTo(editorLastModified);

        }

        return result;

    }

    public static List<CdmServerInfo> getCdmServers() {

        List<CdmServerInfoConfig> configList;

        File file = new File(ConfigFileUtil.perUserCdmFolderFallback(), CDM_REMOTE_SERVERS_CONFIG_FILE);

        if (file.exists()){

            configList = loadFromConfigFile(file);

        }else{

            configList = loadFromConfigFile(new File(ConfigFileUtil.perUserCdmFolderFallback(), CDM_REMOTE_SERVERS_CONFIG_FILE));

        }

        List<CdmServerInfo> serverInfoList = new ArrayList<CdmServerInfo>(configList.size());

        for(CdmServerInfoConfig config : configList) {

            serverInfoList.add(new CdmServerInfo(config));

        }

        // The local host managed server must not be in the config file

        CdmServerInfoConfig localHostManagedConfig = new CdmServerInfoConfig(NAME_LOCALHOST_MGD, SERVER_LOCALHOST, NULL_PORT, CDMSERVER_PREFIX, false);

        serverInfoList.add(new CdmServerInfo(localHostManagedConfig));

        return serverInfoList;

    }

    private static List<CdmServerInfoConfig>  loadFromConfigFile(File file) {

        List<CdmServerInfoConfig> serverList = null;

        ObjectMapper mapper = new ObjectMapper();

        if(!file.exists()) {

            logger.info("The remote server config file '" + file.getAbsolutePath() +

                    "' does not yet exist, it will be created based on the defaults.");

             try {

                serverList = createDefaultServerConfigList();

                mapper.writerWithDefaultPrettyPrinter().writeValue(new FileOutputStream(file), serverList);

            } catch (IOException e) {

                throw new RuntimeException(e);

            }

        } else {

            try {

                serverList = mapper.readValue(new FileInputStream(file), new TypeReference<List<CdmServerInfoConfig>>(){});

            } catch (IOException e) {

               throw new RuntimeException(e);

            }

        }

        return serverList;

    }

    private static List<CdmServerInfoConfig> createDefaultServerConfigList() {

        List<CdmServerInfoConfig> serverInfoList = new ArrayList<>();

        serverInfoList.add(new CdmServerInfoConfig(NAME_PRODUCTION, SERVER_PRODUCTION, 80, "", false));

        serverInfoList.add(new CdmServerInfoConfig(NAME_DEMO_1, SERVER_DEMO_1, 80, CDMSERVER_PREFIX, false));

        serverInfoList.add(new CdmServerInfoConfig(NAME_LOCALHOST, SERVER_LOCALHOST, 8080, CDMSERVER_PREFIX, true));

        return serverInfoList;

    }

    public String getName() {

        return name;

    }

    public String getServer() {

        return server;

    }

    public int getPort() {

        return port;

    }

    public void setPort(int port) {

        this.port = port;

    }

    public List<CdmInstanceInfo> getInstances() throws CDMServerException {

        if(instances.isEmpty()) {

            refreshInstances();

        }

        return instances;

    }

    public static CdmRemoteSource getDevServerRemoteSource() {

        String value = System.getProperty("cdm.server.dev.port");

        boolean available = false;

        CdmInstanceInfo devInstance = null;

        if(value != null && !value.isEmpty()) {

            int devPort = Integer.valueOf(value);

            CdmServerInfo devCii = new CdmServerInfo(new CdmServerInfoConfig(NAME_LOCALHOST_DEV, SERVER_LOCALHOST_DEV, devPort, "", false));

            try {

                devInstance = devCii.addInstance(NAME_INSTANCE_LOCALHOST_DEV, BASEPATH_LOCALHOST_DEV);

                available = devCii.pingInstance(devInstance, devPort);

                if(available) {

                    logger.info("Will connect local development cdm instance: at port " + devPort);

                    return devCii.getCdmRemoteSource(devInstance, devPort);

                }

            } catch (CDMServerException e) {

                logger.error("Can not connect to local development cdm instance at port " + devPort + ". "

                        + "Make sure the cdm instance is running and that the Spring profile \"remoting\" is "

                        + "activated (-Dspring.profiles.active=remoting)", e);

                //TODO show message dialog only instead of throwing the exception to show the error

                // dialog is not necessary in this situation

            }

            logger.error("local development cdm instance at port " + devPort + " is not accessible");

        }

        return null;

    }

    public class CdmInstanceInfo {

        private final String name;

        /**

         * The full path of the instance including the the prefix (if any).

         * E.g. for an EDIT instance this would be something like "cdmserver/remoting"

         * For a managed local server this would simply be ""

         */

        private final String basePath;

        public CdmInstanceInfo(String name, String basePath) {

            this.name = name;

            this.basePath = basePath;

        }

        public String getName() {

            return name;

        }

        public String getBasePath() {

            return basePath;

        }

    }

}