/*
    WSMO Studio - a Semantic Web Service Editor
    Copyright (c) 2004-2006, Ontotext Lab. / SIRMA Group
    
    This library is free software; you can redistribute it and/or modify it under
    the terms of the GNU Lesser General Public License as published by the Free
    Software Foundation; either version 2.1 of the License, or (at your option)
    any later version.
    This library is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
   FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
   details.
   You should have received a copy of the GNU Lesser General Public License along
   with this library; if not, write to the Free Software Foundation, Inc.,
   59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
   */
  
  /***
   * <p>Title: WSMO Studio</p>
   * <p>Description: Semantic Web Service Editor</p>
   * <p>Copyright:  Copyright (c) 2004-2006</p>
   * <p>Company: Ontotext Lab. / SIRMA </p>
   */
  
  package org.wsmostudio.discovery.epfl;
  
  import ie.deri.wsmx.discovery.lightweight.LightweightDiscovery;
  
  import java.io.File;
  import java.net.MalformedURLException;
  import java.net.URL;
  import java.util.*;
  
  import org.eclipse.core.runtime.*;
  import org.eclipse.jface.dialogs.MessageDialog;
  import org.eclipse.swt.widgets.Display;
  import org.wsmo.common.IRI;
  import org.wsmo.datastore.WsmoRepository;
  import org.wsmo.service.Goal;
  import org.wsmo.service.WebService;
  import org.wsmostudio.discovery.Activator;
  import org.wsmostudio.runtime.LogManager;
  import org.wsmostudio.runtime.WSMORuntime;
  import org.wsmostudio.runtime.cache.WSMOTopEntity;
  
  import ch.epfl.qosdisc.operators.Manager;
  import ch.epfl.qosdisc.operators.TestFrame;
  
  
  public class Discoverer {
  	private static final String FILE_PROTO = "file://";
      private static final String COMPARISON = "comparison";
      private static final String RANKING = "ranking";
      private static final String DIR_CONF = "conf";
      private static final String DIR_DATA = "data";
      private static final String FNAME_ONTO_RANKING = "QoSRankingOntology.wsml";
      private static final String FNAME_ONTO_COMPARITION = "QoSUpperOntology.wsml";
      
      private TestFrame testFrame;
      
      public Discoverer() {
          URL confURL = Activator.getDefault().getBundle().getEntry(DIR_CONF);
          IPath confPath = null;
          try {
              confPath = new Path(FileLocator.toFileURL(confURL).getPath());
          } catch(Exception ioe) {       
              MessageDialog.openError(Display.getCurrent().getActiveShell(), 
                      "Error", 
                      "Error reading configuration file:\n" 
                      + ioe.getMessage());
              ioe.printStackTrace();
          }
          URL dataURL = Activator.getDefault().getBundle().getEntry(DIR_DATA);
          IPath dataPath = null;
          try {
              dataPath = new Path(FileLocator.toFileURL(dataURL).getPath());
          } catch(Exception ioe) {       
              MessageDialog.openError(Display.getCurrent().getActiveShell(), 
                      "Error", 
                      "Error reading ranking and comparition ontologies:\n" 
                      + ioe.getMessage());
              ioe.printStackTrace();
          }
  
          this.testFrame = new TestFrame(confPath.toString());
          TestFrame.props.put(RANKING, FILE_PROTO+dataPath.toString()+FNAME_ONTO_RANKING);
          TestFrame.props.put(COMPARISON, FILE_PROTO+dataPath.toString()+FNAME_ONTO_COMPARITION);
      }
  
      public List<WebService> discover(Set<WebService> services, Goal goal, boolean functional) {
  		if(functional) {
              try {
                  // Add the services to the functional discovery component.
                  LightweightDiscovery lwd = new LightweightDiscovery();
                  lwd.addWebService(services);
                  
                  // Perform the functional discovery.
                  List<WebService> funcServices = lwd.discover(goal);
             
                 
                 // Copy only the remaining services.
                 services.clear();
                 services.addAll(funcServices);
             } 
             catch(NoClassDefFoundError noClass) {
                 MessageDialog.openError(Display.getCurrent().getActiveShell(), 
                         "Missing KAON2 Libraries", 
                         "Error loading KAON2 libraries:\n" 
                         + noClass.getMessage());
                 LogManager.logWarning(noClass);
                 return null;
             }
             catch (Exception e) {
                 MessageDialog.openError(Display.getCurrent().getActiveShell(), 
                         "Functional Discovery Failed", 
                         e.getMessage());
                 LogManager.logError("org.wsmostudio.discovery",
                                     "Functional discovery failed",
                                     e);
                 return null;
             }
 
         }
         
         // Add the services to the test frame.
         for(WebService s : services)
             this.testFrame.addService(s);
         
         // And find the matching services.
         List<WebService> result = this.testFrame.achieveGoal(goal);
 		return result;
 	}
 	
 	public List<WebService> discover(WsmoRepository repo, Goal goal, boolean functional) {
 		List wsIriList = repo.listWebServices();
         Set<WebService> services = new HashSet<WebService>();
         
         
         for(Iterator it = wsIriList.iterator();it.hasNext();) {
             IRI wsIri = (IRI)it.next();
             WebService ws = repo.getWebService(wsIri);
             services.add(ws);
         }
         
         String goalFileLoc = WSMORuntime.getCache().getFileLocationForId((IRI)goal.getIdentifier(), WSMOTopEntity.GOAL);
         Goal g = null;
         try {
             g = Manager.getGoal(new File(goalFileLoc).toURI().toURL().toString());
         }
         catch(MalformedURLException error) {
             LogManager.logError(error);
             return null;
         }
         return discover(services, g, functional);
 	}
 
 }
 
 /*
  * $Log$
  * Revision 1.2  2007/04/17 14:28:02  alex_simov
  * deprication fix
  *
  * Revision 1.1  2007/01/26 14:31:37  alex_simov
  * discovery plug-in moved from EXT module
  *
  * Revision 1.7  2006/10/31 13:02:14  alex_simov
  * no message
  *
  * Revision 1.6  2006/09/19 13:17:05  alex_simov
  * no message
  *
  */