EDIT

// $Id$

/**

 * 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.IOException;

import java.net.Socket;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.List;

import org.apache.http.HttpEntity;

import org.apache.http.HttpResponse;

import org.apache.http.client.ClientProtocolException;

import org.apache.http.client.HttpClient;

import org.apache.http.client.ResponseHandler;

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

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

import org.apache.http.util.EntityUtils;

import org.apache.log4j.Logger;

import org.json.JSONArray;

import org.json.JSONException;

import org.json.JSONObject;

import eu.etaxonomy.cdm.config.CdmSourceException;

import eu.etaxonomy.cdm.database.CdmPersistentDataSource;

import eu.etaxonomy.cdm.database.ICdmDataSource;

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

/**

 * @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 = "edit-production";

    private final static String SERVER_PRODUCTION = "dev.e-taxonomy.eu";

    private final static String NAME_INTEGRATION = "edit-integration";

    private final static String SERVER_INTEGRATION = "int.e-taxonomy.eu";

    private final static String NAME_DEMO_1 = "edit-WS I";

    private final static String SERVER_DEMO_1 = "160.45.63.230";

    private final static String NAME_DEMO_2 = "edit-WS II";

    private final static String SERVER_DEMO_2 = "160.45.63.231";

    private final static String NAME_TEST = "edit-test";

    private final static String SERVER_TEST = "test.e-taxonomy.eu";

    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 int PORT_LOCALHOST_DEV = 8080;

    private final static String BASEPATH_LOCALHOST_DEV = "";

    private final String name;

    private final String server;

    private final int port;

    private final List<CdmInstanceInfo> instances;

    private static List<CdmServerInfo> cdmServerInfoList;

    public CdmServerInfo(String name, String server, int port) {

        this.name = name;

        this.server = server;

        this.port = port;

        instances = new ArrayList<CdmInstanceInfo>();

    }

    public CdmInstanceInfo addInstance(String name, String 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 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 addInstancesViaHttp() throws CDMServerException {

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

        HttpClient client = new DefaultHttpClient();

        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) {

            throw new CDMServerException(e);

        }

        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);

            }

        }

    }

    public void addInstancesFromDataSourcesConfig() {

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

            logger.warn("Adding local instance " + dataSource.getName());

            addInstance(dataSource.getName(), dataSource.getName());

        }

    }

    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(),

                    null);

        }

        return null;

    }

    public boolean pingServer(){

        try {

            Socket s = new Socket(server, port);

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

            return true;

        } catch (IOException ioe) {

        }

        return false;

    }

    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) {

            throw new CDMServerException(e);

        }

        return false;

    }

    public static List<CdmServerInfo> getCdmServers() {

        if(cdmServerInfoList == null) {

            cdmServerInfoList = new ArrayList<CdmServerInfo>();

            //cdmServerInfoList.add(new CdmServerInfo(NAME_PRODUCTION, SERVER_PRODUCTION, 80));

            //cdmServerInfoList.add(new CdmServerInfo(NAME_INTEGRATION, SERVER_INTEGRATION, 80));

            cdmServerInfoList.add(new CdmServerInfo(NAME_DEMO_1, SERVER_DEMO_1, 80));

            cdmServerInfoList.add(new CdmServerInfo(NAME_DEMO_2, SERVER_DEMO_2, 80));

            cdmServerInfoList.add(new CdmServerInfo(NAME_TEST, SERVER_TEST, 80));

            cdmServerInfoList.add(new CdmServerInfo(NAME_LOCALHOST, SERVER_LOCALHOST, 8080));

            cdmServerInfoList.add(new CdmServerInfo(NAME_LOCALHOST_MGD, SERVER_LOCALHOST,8080));

        }

        return cdmServerInfoList;

    }

    public String getName() {

        return name;

    }

    public String getServer() {

        return server;

    }

    public int getPort() {

        return 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(NAME_LOCALHOST_DEV, SERVER_LOCALHOST_DEV, devPort);

            try {

                devInstance = devCii.addInstance(NAME_INSTANCE_LOCALHOST_DEV, BASEPATH_LOCALHOST_DEV);

                available = devCii.pingInstance(devInstance, devPort);

                if(available) {

                    return devCii.getCdmRemoteSource(devInstance, devPort);

                }

            } catch (Exception e) {

            }

        }

        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 "remoting"

         */

        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;

        }

    }

}