package net.sf.taverna.t2.ui.perspectives.biocatalogue.integration.service_panel;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import javax.swing.Icon;
import javax.wsdl.Operation;
import javax.wsdl.WSDLException;
import javax.xml.parsers.ParserConfigurationException;

import org.apache.log4j.Logger;
import org.xml.sax.SAXException;

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;

import net.sf.taverna.biocatalogue.model.SoapOperationIdentity;
import net.sf.taverna.biocatalogue.model.Util;
import net.sf.taverna.t2.activities.wsdl.WSDLActivityHealthChecker;
import net.sf.taverna.t2.servicedescriptions.ServiceDescription;
import net.sf.taverna.t2.servicedescriptions.ServiceDescriptionProvider;
import net.sf.taverna.t2.ui.perspectives.biocatalogue.BioCataloguePerspective;
import net.sf.taverna.t2.ui.perspectives.biocatalogue.integration.config.BioCataloguePluginConfiguration;
import net.sf.taverna.wsdl.parser.UnknownOperationException;
import net.sf.taverna.wsdl.parser.WSDLParser;

public class BioCatalogueServiceProvider implements ServiceDescriptionProvider
{
  public static final String PROVIDER_NAME = "Service Catalogue - selected services";
  
  private static BioCatalogueServiceProvider instanceOfSelf = null;
  private static FindServiceDescriptionsCallBack callBack;
  
  private static List<SoapOperationIdentity> registeredSOAPOperations;
  private static List<RESTFromBioCatalogueServiceDescription> registeredRESTMethods;
  
  private static Logger logger = Logger.getLogger(BioCatalogueServiceProvider.class);
  
  
	public BioCatalogueServiceProvider() {
	  BioCatalogueServiceProvider.instanceOfSelf = this;
	}
	
	@SuppressWarnings("unchecked")
  public void findServiceDescriptionsAsync(FindServiceDescriptionsCallBack callBack)
	{
		BioCatalogueServiceProvider.callBack = callBack;
    callBack.status("Starting Service Catalogue Service Provider");
		
    // --- Initilise the service provider with stored services ---
    
    // read stored settings
    // NB! it's crucial to set the custom classloader, otherwise XStream would fail,
    //     as it would attempt to use the default one, which wouldn't know about the
    //     plugin's classes
    logger.info("Starting to deserialise the list of services stored in the configuration file");
    XStream xstream = new XStream(new DomDriver());
    xstream.setClassLoader(BioCataloguePerspective.class.getClassLoader());
    
    BioCataloguePluginConfiguration configuration = BioCataloguePluginConfiguration.getInstance();
    
    // *** load stored SOAP operations ***
    String loadedSOAPServicesXMLString = configuration.getProperty(BioCataloguePluginConfiguration.SOAP_OPERATIONS_IN_SERVICE_PANEL);
    
    Object loadedSOAPServices = (loadedSOAPServicesXMLString == null ?
                                 null :
                                 xstream.fromXML(loadedSOAPServicesXMLString));
    
    registeredSOAPOperations = (loadedSOAPServices == null || !(loadedSOAPServices instanceof List<?>) ?
                                new ArrayList<SoapOperationIdentity>() :
                                (List<SoapOperationIdentity>)loadedSOAPServices
                               );
    logger.info("Deserialised " + registeredSOAPOperations.size() + Util.pluraliseNoun("SOAP operation", registeredSOAPOperations.size()));
    
    // prepare the correct format of data for initialisation
    List<ServiceDescription> results = new ArrayList<ServiceDescription>();
    for (SoapOperationIdentity opId : registeredSOAPOperations) {
      results.add(new WSDLOperationFromBioCatalogueServiceDescription(opId));
    }
    
    
    // *** load stored REST methods ***
    String loadedRESTMethodsXMLString = configuration.getProperty(BioCataloguePluginConfiguration.REST_METHODS_IN_SERVICE_PANEL);
    
    Object loadedRESTMethods = (loadedRESTMethodsXMLString == null ?
                                null :
                                xstream.fromXML(loadedRESTMethodsXMLString));
    
    registeredRESTMethods = (loadedRESTMethods == null || !(loadedRESTMethods instanceof List<?>) ?
                             new ArrayList<RESTFromBioCatalogueServiceDescription>() :
                             (List<RESTFromBioCatalogueServiceDescription>)loadedRESTMethods);
    logger.info("Deserialised " + registeredRESTMethods.size() + Util.pluraliseNoun("REST method", registeredRESTMethods.size()));
    
    results.addAll(registeredRESTMethods);
		
    
		// *** send the services to the Service Panel ***
		callBack.partialResults(results);
		
		
		// NB! This is to be called when it is known that no more items will be added - 
		// it's never true for this provider, as items may be added on user request
		// at any time!
		//
		// callBack.finished();
	}
	
	public Icon getIcon() {
		return null;
	}
	
	public String getName(){
	  // TODO - not sure where this is used
		return "My dummy service";
	}
	
	public String getId() {
    return "http://www.taverna.org.uk/2010/services/servicecatalogue";
  }
	
	
	/**
	 * Adds a new "processor" - i.e. a WSDL operation into the main Service Panel.
	 * 
	 * @param wsdlLocation URL of the WSDL location of the operation to add.
	 * @param operationName Name of the operation within specified WSDL document.
	 * @return True if the operation was added;
	 *         false if the service provided was not yet initiliased (unlikely) or
	 *         when supplied strings were empty/null.
	 */
	public static boolean registerNewWSDLOperation(SoapOperationIdentity soapOperationDetails)
	{
	  if (BioCatalogueServiceProvider.instanceOfSelf == null || soapOperationDetails == null ||
	      soapOperationDetails.getWsdlLocation() == null || soapOperationDetails.getWsdlLocation().length() == 0 ||
	      soapOperationDetails.getOperationName() == null || soapOperationDetails.getOperationName().length() == 0)
	  {
	    // the service provider hasn't been initialised yet
	    // OR not all details available
	    return (false);
	  }
	  else
	  {
	    // record the newly added operation in the internal list
	    registeredSOAPOperations.add(soapOperationDetails);
	    
	    // add the provided operation to the Service Panel
	    ServiceDescription service = new WSDLOperationFromBioCatalogueServiceDescription(soapOperationDetails);
	    BioCatalogueServiceProvider.callBack.partialResults(Collections.singletonList(service));
	    return (true);
	  }
	    
	}
	
	/**
	 * Adds a SOAP/WSDL service and all of its operations into the Taverna's Service Panel.
	 */
	public static boolean registerNewWSDLService(String wsdlURL)
	{
	  if (BioCatalogueServiceProvider.instanceOfSelf == null || wsdlURL == null)
	  {
	    // the service provider hasn't been initialised yet
	    // OR not all details available
	    return (false);
	  }
	  else
	  {
		  // Do the same thing as in the WSDL service provider
			callBack.status("Service Catalogue service provider: Parsing wsdl: " + wsdlURL);
			WSDLParser parser = null;
			try {
				parser = new WSDLParser(wsdlURL);
				List<Operation> operations = parser.getOperations();
				callBack.status("Found " + operations.size() + " WSDL operations of service "
						+ wsdlURL);
				List<WSDLOperationFromBioCatalogueServiceDescription> items = new ArrayList<WSDLOperationFromBioCatalogueServiceDescription>();
				for (Operation operation : operations) {
					WSDLOperationFromBioCatalogueServiceDescription item;
					try {
						String operationName = operation.getName();
						String operationDesc = parser.getOperationDocumentation(operationName);
						String use = parser.getUse(operationName);
						String style = parser.getStyle();
						if (!WSDLActivityHealthChecker.checkStyleAndUse(style, use)) {
							logger.warn("Unsupported style and use combination " + style + "/" + use + " for operation " + operationName + " from " + wsdlURL);
							continue;
						}
						item = new WSDLOperationFromBioCatalogueServiceDescription(wsdlURL, operationName, operationDesc);
						items.add(item);
						
					    // Record the newly added operation in the internal list
						SoapOperationIdentity soapOperationDetails = new SoapOperationIdentity(wsdlURL, operationName, operationDesc);
					    registeredSOAPOperations.add(soapOperationDetails);
					} catch (UnknownOperationException e) {
						String message = "Encountered an unexpected operation name:"
								+ operation.getName();
						callBack.fail(message, e);
					    return false;
					}
				}
				callBack.partialResults(items);
				callBack.finished();
				return true;
			} catch (ParserConfigurationException e) {
				String message = "Error configuring the WSDL parser";
				callBack.fail(message, e);
			    return false;
			} catch (WSDLException e) {
				String message = "There was an error with the wsdl: " + wsdlURL;
				callBack.fail(message, e);
			    return false;
			} catch (IOException e) {
				String message = "There was an IO error parsing the wsdl: " + wsdlURL
						+ " Possible reason: the wsdl location was incorrect.";
				callBack.fail(message, e);
			    return false;
			} catch (SAXException e) {
				String message = "There was an error with the XML in the wsdl: "
						+ wsdlURL;
				callBack.fail(message, e);
			    return false;
			} catch (IllegalArgumentException e) { // a problem with the wsdl url
				String message = "There was an error with the wsdl: " + wsdlURL + " "
						+ "Possible reason: the wsdl location was incorrect.";
				callBack.fail(message, e);
			    return false;
			} catch (Exception e) { // anything else we did not expect
				String message = "There was an error with the wsdl: " + wsdlURL;
				callBack.fail(message, e);
			    return false;
			}
		}
	    
	}
	
	
	public static boolean registerNewRESTMethod(RESTFromBioCatalogueServiceDescription restServiceDescription)
	{
	  if (restServiceDescription == null) {
	    return (false);
	  }
	  else
	  {
	    // record the newly added method in the internal list
	    registeredRESTMethods.add(restServiceDescription);
	    
	    // add the provided method to the Service Panel
	    BioCatalogueServiceProvider.callBack.partialResults(Collections.singletonList(restServiceDescription));
	    return (true);
	  }
	}
	
	
	public static List<SoapOperationIdentity> getRegisteredSOAPOperations() {
	  return (registeredSOAPOperations);
	}
	
	public static List<RESTFromBioCatalogueServiceDescription> getRegisteredRESTMethods() {
    return (registeredRESTMethods);
  }
  
	
	/**
	 * Clears internal lists of stored SOAP operations / REST methods.
	 * Therefore, once Taverna is restarted, the stored services will
	 * be effectively "forgotten".
	 */
	public static void clearRegisteredServices() {
	  registeredRESTMethods.clear();
	  registeredSOAPOperations.clear();
	}
	
}