*  soapUI, copyright (C) 2004-2011 eviware.com

*

*  soapUI is free software; you can redistribute it and/or modify it under the

*  terms of version 2.1 of the GNU Lesser General Public License as published by

*  the Free Software Foundation.

*

*  soapUI 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 at gnu.org.

*/

* WSDL project implementation

*

* @author Ole.Matzura

*/

    PropertyExpansionContainer, PropertyChangeListener, TestRunnable

  public final static String AFTER_LOAD_SCRIPT_PROPERTY = WsdlProject.class.getName() + "@setupScript";

  public final static String BEFORE_SAVE_SCRIPT_PROPERTY = WsdlProject.class.getName() + "@tearDownScript";

  public final static String RESOURCE_ROOT_PROPERTY = WsdlProject.class.getName() + "@resourceRoot";

  private WorkspaceImpl workspace;

  protected String path;

  protected List<AbstractInterface<?>> interfaces = new ArrayList<AbstractInterface<?>>();

  protected List<WsdlTestSuite> testSuites = new ArrayList<WsdlTestSuite>();

  protected List<WsdlMockService> mockServices = new ArrayList<WsdlMockService>();

  private Set<ProjectListener> projectListeners = new HashSet<ProjectListener>();

  protected SoapuiProjectDocumentConfig projectDocument;

  private ImageIcon disabledIcon;

  private ImageIcon closedIcon;

  private ImageIcon remoteIcon;

  private ImageIcon openEncyptedIcon;

  protected EndpointStrategy endpointStrategy = new DefaultEndpointStrategy();

  protected long lastModified;

  private boolean remote;

  private boolean open = true;

  private boolean disabled;

  private SoapUIScriptEngine afterLoadScriptEngine;

  private SoapUIScriptEngine beforeSaveScriptEngine;

  private PropertyExpansionContext context = new DefaultPropertyExpansionContext( this );

  protected DefaultWssContainer wssContainer;

  private String projectPassword = null;

  private String hermesConfig;

  private boolean wrongPasswordSupplied;

  /*

   * 3 state flag: 1. 0 - project not encrypted 2. 1 - encrypted , good

   * password, means that it could be successfully decrypted 3. -1 - encrypted,

   * but with bad password or no password.

   */

  protected int encrypted;

  private ImageIcon closedEncyptedIcon;

  private SoapUIScriptEngine afterRunScriptEngine;

  private SoapUIScriptEngine beforeRunScriptEngine;

  private Set<ProjectRunListener> runListeners = new HashSet<ProjectRunListener>();

  protected final static Logger log = Logger.getLogger( WsdlProject.class );

  public WsdlProject() throws XmlException, IOException, SoapUIException

  {

    this( ( WorkspaceImpl )null );

  }

  public WsdlProject( String path ) throws XmlException, IOException, SoapUIException

  {

    this( path, ( WorkspaceImpl )null );

  }

  public WsdlProject( String projectFile, String projectPassword )

  {

    this( projectFile, null, true, true, null, projectPassword );

  }

  public WsdlProject( WorkspaceImpl workspace )

  {

    this( null, workspace, true );

  }

  public WsdlProject( String path, WorkspaceImpl workspace )

  {

    this( path, workspace, true );

  }

  public WsdlProject( String path, WorkspaceImpl workspace, boolean create )

  {

    this( path, workspace, create, true, null, null );

  }

  public WsdlProject( String path, WorkspaceImpl workspace, boolean create, boolean open, String tempName,

      String projectPassword )

  {

    super( null, workspace, "/project.gif" );

    this.workspace = workspace;

    this.path = path;

    this.projectPassword = projectPassword;

    for( ProjectListener listener : SoapUI.getListenerRegistry().getListeners( ProjectListener.class ) )

    {

      addProjectListener( listener );

    }

    for( ProjectRunListener listener : SoapUI.getListenerRegistry().getListeners( ProjectRunListener.class ) )

    {

      addProjectRunListener( listener );

    }

    try

    {

      if( path != null && open )

      {

        File file = new File( path.trim() );

        if( file.exists() )

        {

          try

          {

            loadProject( file.toURI().toURL() );

            lastModified = file.lastModified();

          }

          catch( MalformedURLException e )

          {

            SoapUI.logError( e );

            disabled = true;

          }

        }

        else

        {

          try

          {

            if( !PathUtils.isHttpPath( path ) )

              SoapUI.log.info( "File [" + file.getAbsolutePath() + "] does not exist, trying URL instead" );

            remote = true;

            loadProject( new URL( path ) );

          }

          catch( MalformedURLException e )

          {

            SoapUI.logError( e );

            disabled = true;

          }

        }

      }

    }

    catch( SoapUIException e )

    {

      SoapUI.logError( e );

      disabled = true;

    }

    finally

    {

      closedIcon = UISupport.createImageIcon( "/closedProject.gif" );

      remoteIcon = UISupport.createImageIcon( "/remoteProject.gif" );

      disabledIcon = UISupport.createImageIcon( "/disabledProject.gif" );

      openEncyptedIcon = UISupport.createImageIcon( "/openEncryptedProject.gif" );

      closedEncyptedIcon = UISupport.createImageIcon( "/closedEncryptedProject.gif" );

      this.open = open && !disabled && ( this.encrypted != -1 );

      if( projectDocument == null )

      {

        projectDocument = SoapuiProjectDocumentConfig.Factory.newInstance();

        setConfig( projectDocument.addNewSoapuiProject() );

        if( tempName != null || path != null )

          getConfig().setName( StringUtils.isNullOrEmpty( tempName ) ? getNameFromPath() : tempName );

        setPropertiesConfig( getConfig().addNewProperties() );

        wssContainer = new DefaultWssContainer( this, getConfig().addNewWssContainer() );

        // setResourceRoot("${projectDir}");

      }

      if( getConfig() != null )

      {

        endpointStrategy.init( this );

      }

      if( getSettings() != null )

      {

        setProjectRoot( path );

      }

      addPropertyChangeListener( this );

    }

  }

  public boolean isRemote()

  {

    return remote;

  }

  public void loadProject( URL file ) throws SoapUIException

  {

    try

    {

      UISupport.setHourglassCursor();

      UrlWsdlLoader loader = new UrlWsdlLoader( file.toString(), this );

      loader.setUseWorker( false );

      projectDocument = SoapuiProjectDocumentConfig.Factory.parse( loader.load() );

      // see if there is encoded data

      this.encrypted = checkForEncodedData( projectDocument.getSoapuiProject() );

      setConfig( projectDocument.getSoapuiProject() );

      // removed cached definitions if caching is disabled

      if( !getSettings().getBoolean( WsdlSettings.CACHE_WSDLS ) )

      {

        removeDefinitionCaches( projectDocument );

      }

      log.info( "Loaded project from [" + file.toString() + "]" );

      // TODO remove this after beta2

      updateChecksToScans( getConfig() );

      try

      {

        int majorVersion = Integer

            .parseInt( projectDocument.getSoapuiProject().getSoapuiVersion().split( "\\." )[0] );

        if( majorVersion > Integer.parseInt( SoapUI.SOAPUI_VERSION.split( "\\." )[0] ) )

          log.warn( "Project '" + projectDocument.getSoapuiProject().getName() + "' is from a newer version ("

              + projectDocument.getSoapuiProject().getSoapuiVersion() + ") of soapUI than this ("

              + SoapUI.SOAPUI_VERSION + ") and parts of it may be incompatible or incorrect. "

              + "Saving this project with this version of soapUI may cause it to function differently." );

      }

      catch( Exception e )

      {

      }

      List<InterfaceConfig> interfaceConfigs = getConfig().getInterfaceList();

      for( InterfaceConfig config : interfaceConfigs )

      {

        AbstractInterface<?> iface = InterfaceFactoryRegistry.build( this, config );

        interfaces.add( iface );

      }

      List<TestSuiteConfig> testSuiteConfigs = getConfig().getTestSuiteList();

      for( TestSuiteConfig config : testSuiteConfigs )

      {

        testSuites.add( buildTestSuite( config ) );

      }

      List<MockServiceConfig> mockServiceConfigs = getConfig().getMockServiceList();

      for( MockServiceConfig config : mockServiceConfigs )

      {

        mockServices.add( new WsdlMockService( this, config ) );

      }

      if( !getConfig().isSetWssContainer() )

        getConfig().addNewWssContainer();

      wssContainer = new DefaultWssContainer( this, getConfig().getWssContainer() );

      endpointStrategy.init( this );

      if( !getConfig().isSetProperties() )

        getConfig().addNewProperties();

      if( !getConfig().isSetAbortOnError() )

        getConfig().setAbortOnError( false );

      // if( !getConfig().isSetFailOnErrors() )

      // getConfig().setFailOnErrors( true );

      if( !getConfig().isSetRunType() )

        getConfig().setRunType( TestSuiteRunTypesConfig.SEQUENTIAL );

      setPropertiesConfig( getConfig().getProperties() );

      afterLoad();

    }

    catch( Exception e )

    {

      if( e instanceof XmlException )

      {

        XmlException xe = ( XmlException )e;

        XmlError error = xe.getError();

        if( error != null )

          System.err.println( "Error at line " + error.getLine() + ", column " + error.getColumn() );

      }

      if( e instanceof RestConversionException )

      {

        log.error( "Project file needs to be updated manually, please reload the project." );

        throw new SoapUIException( "Failed to load project from file [" + file.toString() + "]", e );

      }

      e.printStackTrace();

      throw new SoapUIException( "Failed to load project from file [" + file.toString() + "]", e );

    }

    finally

    {

      UISupport.resetCursor();

    }

  }

  protected WsdlTestSuite buildTestSuite( TestSuiteConfig config )

  {

    return new WsdlTestSuite( this, config );

  }

  public boolean isWrongPasswordSupplied()

  {

    return wrongPasswordSupplied;

  }

  /**

   * Decode encrypted data and restore user/pass

   *

   * @param soapuiProject

   * @return 0 - not encrypted, 1 - successfull decryption , -1 error while

   *         decrypting, bad password, no password.

   * @throws IOException

   * @throws GeneralSecurityException

   * @author robert nemet

   */

  protected int checkForEncodedData( ProjectConfig soapuiProject ) throws IOException, GeneralSecurityException

  {

    byte[] encryptedContent = soapuiProject.getEncryptedContent();

    char[] password = null;

    // no encrypted data then go back

    if( encryptedContent == null || encryptedContent.length == 0 )

      return 0;

    String projectPassword = null;

    if( workspace != null )

    {

      projectPassword = workspace.getProjectPassword( soapuiProject.getName() );

    }

    else

    {

      projectPassword = this.projectPassword;

    }

    if( projectPassword == null )

    {

      password = UISupport.promptPassword( "Enter Password:", soapuiProject.getName() );

    }

    else

    {

      password = projectPassword.toCharArray();

    }

    byte[] data = null;

    // no pass go back.

    if( password == null )

    {

      return -1;

    }

    try

    {

      data = OpenSSL.decrypt( "des3", password, encryptedContent );

    }

    catch( Exception e )

    {

      e.printStackTrace();

      return -1;

    }

    String decryptedData = new String( data, "UTF-8" );

    if( decryptedData != null )

    {

      if( decryptedData.length() > 0 )

      {

        try

        {

          // projectDocument.getSoapuiProject().set(

          // XmlObject.Factory.parse( decryptedData ) );

          projectDocument.getSoapuiProject().set( XmlUtils.createXmlObject( decryptedData ) );

          wrongPasswordSupplied = false;

        }

        catch( XmlException e )

        {

          UISupport.showErrorMessage( "Wrong password. Project needs to be reloaded." );

          wrongPasswordSupplied = true;

          getWorkspace().clearProjectPassword( soapuiProject.getName() );

          return -1;

        }

      }

    }

    else

    {

      UISupport.showErrorMessage( "Wrong project password" );

      wrongPasswordSupplied = true;

      getWorkspace().clearProjectPassword( soapuiProject.getName() );

      return -1;

    }

    projectDocument.getSoapuiProject().setEncryptedContent( null );

    return 1;

  }

  @Override

  public void afterLoad()

  {

    super.afterLoad();

    try

    {

      ProjectListener[] a = projectListeners.toArray( new ProjectListener[projectListeners.size()] );

      for( int c = 0; c < a.length; c++ )

      {

        a[c].afterLoad( this );

      }

      runAfterLoadScript();

    }

    catch( Exception e )

    {

      SoapUI.logError( e );

    }

  }

  protected void setProjectRoot( String path )

  {

    if( path != null && projectDocument != null )

    {

      int ix = path.lastIndexOf( File.separatorChar );

      if( ix > 0 )

        getSettings().setString( ProjectSettings.PROJECT_ROOT, path.substring( 0, ix ) );

    }

  }

  public void setResourceRoot( String resourceRoot )

  {

    String old = getResourceRoot();

    getConfig().setResourceRoot( resourceRoot );

    notifyPropertyChanged( RESOURCE_ROOT_PROPERTY, old, resourceRoot );

  }

  public String getResourceRoot()

  {

    if( !getConfig().isSetResourceRoot() )

      getConfig().setResourceRoot( "" );

    return getConfig().getResourceRoot();

  }

  @Override

  public ImageIcon getIcon()

  {

    if( isDisabled() )

      return disabledIcon;

    else if( getEncrypted() != 0 )

    {

      if( isOpen() )

      {

        return openEncyptedIcon;

      }

      else

      {

        return closedEncyptedIcon;

      }

    }

    else if( !isOpen() )

      return closedIcon;

    else if( isRemote() )

      return remoteIcon;

    else

      return super.getIcon();

  }

  private String getNameFromPath()

  {

    int ix = path.lastIndexOf( isRemote() ? '/' : File.separatorChar );

    String name = ix == -1 ? path : path.substring( ix + 1 );

    return name;

  }

  @Override

  public String getDescription()

  {

    if( isOpen() )

      return super.getDescription();

    String name = getName();

    if( isDisabled() )

      name += " - disabled [" + getPath() + "]";

    else

      name += " - closed [" + getPath() + "]";

    return name;

  }

  public WorkspaceImpl getWorkspace()

  {

    return workspace;

  }

  public AbstractInterface<?> getInterfaceAt( int index )

  {

    return interfaces.get( index );

  }

  public AbstractInterface<?> getInterfaceByName( String interfaceName )

  {

    return ( AbstractInterface<?> )getWsdlModelItemByName( interfaces, interfaceName );

  }

  public AbstractInterface<?> getInterfaceByTechnicalId( String technicalId )

  {

    for( int c = 0; c < getInterfaceCount(); c++ )

    {

      if( getInterfaceAt( c ).getTechnicalId().equals( technicalId ) )

        return getInterfaceAt( c );

    }

    return null;

  }

  public int getInterfaceCount()

  {

    return interfaces.size();

  }

  public String getPath()

  {

    return path;

  }

  public boolean save() throws IOException

  {

    return save( null );

  }

  public boolean save( String folder ) throws IOException

  {

    if( !isOpen() || isDisabled() || isRemote() )

      return true;

    if( path == null || isRemote() )

    {

      path = StringUtils.createFileName2( getName(), '-' ) + "-soapui-project.xml";

      if( folder != null )

      {

        path = folder + File.separatorChar + path;

      }

      File file = null;

      while( file == null

          || ( file.exists() && !UISupport.confirm( "File [" + file.getName() + "] exists, overwrite?",

              "Overwrite File?" ) ) )

      {

        file = UISupport.getFileDialogs().saveAs( this, "Save project " + getName(), ".xml", "XML Files (*.xml)",

            new File( path ) );

        if( file == null )

          return false;

      }

      path = file.getAbsolutePath();

    }

    File projectFile = new File( path );

    while( projectFile.exists() && !projectFile.canWrite() )

    {

      if( UISupport.confirm( "Project file [" + path + "] can not be written to, save to new file?", "Save Project" ) )

      {

        projectFile = UISupport.getFileDialogs().saveAs( this, "Save project " + getName(), ".xml",

            "XML Files (*.xml)", projectFile );

        if( projectFile == null )

          return false;

        path = projectFile.getAbsolutePath();

      }

      else

        return false;

    }

    // check modified

    if( projectFile.exists() && lastModified != 0 && lastModified < projectFile.lastModified() )

    {

      if( !UISupport.confirm( "Project file for [" + getName() + "] has been modified externally, overwrite?",

          "Save Project" ) )

        return false;

    }

    if( projectFile.exists() && getSettings().getBoolean( UISettings.CREATE_BACKUP ) )

    {

      createBackup( projectFile );

    }

    return saveIn( projectFile );

  }

  public boolean saveBackup() throws IOException

  {

    File projectFile;

    if( path == null || isRemote() )

    {

      projectFile = new File( StringUtils.createFileName2( getName(), '-' ) + "-soapui-project.xml" );

    }

    else

    {

      projectFile = new File( path );

    }

    File backupFile = getBackupFile( projectFile );

    return saveIn( backupFile );

  }

  public boolean saveIn( File projectFile ) throws IOException

  {

    long size = 0;

    beforeSave();

    // work with copy beacuse we do not want to change working project while

    // working with it

    // if user choose save project, save all etc.

    SoapuiProjectDocumentConfig projectDocument = ( SoapuiProjectDocumentConfig )this.projectDocument.copy();

    // check for caching

    if( !getSettings().getBoolean( WsdlSettings.CACHE_WSDLS ) )

    {

      // no caching -> create copy and remove definition cachings

      removeDefinitionCaches( projectDocument );

    }

    // remove project root

    XmlBeansSettingsImpl tempSettings = new XmlBeansSettingsImpl( this, null, projectDocument.getSoapuiProject()

        .getSettings() );

    tempSettings.clearSetting( ProjectSettings.PROJECT_ROOT );

    // check for encryption

    String passwordForEncryption = getSettings().getString( ProjectSettings.SHADOW_PASSWORD, null );

    // if it has encryptedContend that means it is not decrypted corectly( bad

    // password, etc ), so do not encrypt it again.

    if( projectDocument.getSoapuiProject().getEncryptedContent() == null )

    {

      if( passwordForEncryption != null )

      {

        if( passwordForEncryption.length() > 1 )

        {

          // we have password so do encryption

          try

          {

            String data = getConfig().xmlText();

            byte[] encrypted = OpenSSL.encrypt( "des3", passwordForEncryption.toCharArray(), data.getBytes() );

            projectDocument.getSoapuiProject().setEncryptedContent( encrypted );

            projectDocument.getSoapuiProject().setInterfaceArray( null );

            projectDocument.getSoapuiProject().setTestSuiteArray( null );

            projectDocument.getSoapuiProject().setMockServiceArray( null );

            projectDocument.getSoapuiProject().unsetWssContainer();

            projectDocument.getSoapuiProject().unsetSettings();

            projectDocument.getSoapuiProject().unsetProperties();

          }

          catch( GeneralSecurityException e )

          {

            UISupport.showErrorMessage( "Encryption Error" );

          }

        }

        else

        {

          // no password no encryption.

          projectDocument.getSoapuiProject().setEncryptedContent( null );

        }

      }

    }

    // end of encryption.

    XmlOptions options = new XmlOptions();

    if( SoapUI.getSettings().getBoolean( WsdlSettings.PRETTY_PRINT_PROJECT_FILES ) )

      options.setSavePrettyPrint();

    projectDocument.getSoapuiProject().setSoapuiVersion( SoapUI.SOAPUI_VERSION );

    try

    {

      File tempFile = File.createTempFile( "project-temp-", ".xml", projectFile.getParentFile() );

      // save once to make sure it can be saved

      FileOutputStream tempOut = new FileOutputStream( tempFile );

      projectDocument.save( tempOut, options );

      tempOut.close();

      if( getSettings().getBoolean( UISettings.LINEBREAK ) )

      {

        normalizeLineBreak( projectFile, tempFile );

      }

      else

      {

        // now save it for real

        FileOutputStream projectOut = new FileOutputStream( projectFile );

        projectDocument.save( projectOut, options );

        projectOut.close();

        // delete tempFile here so we have it as backup in case second save

        // fails

        if( !tempFile.delete() )

        {

          SoapUI.getErrorLog().warn( "Failed to delete temporary project file; " + tempFile.getAbsolutePath() );

          tempFile.deleteOnExit();

        }

      }

      size = projectFile.length();

    }

    catch( Throwable t )

    {

      SoapUI.logError( t );

      UISupport.showErrorMessage( "Failed to save project [" + getName() + "]: " + t.toString() );

      return false;

    }

    lastModified = projectFile.lastModified();

    log.info( "Saved project [" + getName() + "] to [" + projectFile.getAbsolutePath() + " - " + size + " bytes" );

    setProjectRoot( getPath() );

    return true;

  }

  private static void normalizeLineBreak( File target, File tmpFile )

  {

    try

    {

      FileReader fr = new FileReader( tmpFile );

      BufferedReader in = new BufferedReader( fr );

      FileWriter fw = new FileWriter( target );

      BufferedWriter out = new BufferedWriter( fw );

      String line = "";

      while( ( line = in.readLine() ) != null )

      {

        out.write( line );

        out.newLine();

        out.flush();

      }

      out.close();

      fw.close();

      in.close();

      fr.close();

    }

    catch( FileNotFoundException e )

    {

      // TODO Auto-generated catch block

      e.printStackTrace();

    }

    catch( IOException e )

    {

      // TODO Auto-generated catch block

      e.printStackTrace();

    }

    if( !tmpFile.delete() )

    {

      SoapUI.getErrorLog().warn( "Failed to delete temporary file: " + tmpFile.getAbsolutePath() );

      tmpFile.deleteOnExit();

    }

  }

  public void beforeSave()

  {

    try

    {

      ProjectListener[] a = projectListeners.toArray( new ProjectListener[projectListeners.size()] );

      for( int c = 0; c < a.length; c++ )

      {

        a[c].beforeSave( this );

      }

      runBeforeSaveScript();

    }

    catch( Exception e )

    {

      SoapUI.logError( e );

    }

    // notify

    for( AbstractInterface<?> iface : interfaces )

      iface.beforeSave();

    for( WsdlTestSuite testSuite : testSuites )

      testSuite.beforeSave();

    for( WsdlMockService mockService : mockServices )

      mockService.beforeSave();

    endpointStrategy.onSave();

  }

  protected void createBackup( File projectFile ) throws IOException

  {

    File backupFile = getBackupFile( projectFile );

    log.info( "Backing up [" + projectFile + "] to [" + backupFile + "]" );

    Tools.copyFile( projectFile, backupFile, true );

  }

  protected File getBackupFile( File projectFile )

  {

    String backupFolderName = getSettings().getString( UISettings.BACKUP_FOLDER, "" );

    File backupFolder = new File( backupFolderName );

    if( !backupFolder.isAbsolute() )

    {

      backupFolder = new File( projectFile.getParentFile(), backupFolderName );

    }

    if( !backupFolder.exists() )

      backupFolder.mkdirs();

    File backupFile = new File( backupFolder, projectFile.getName() + ".backup" );

    return backupFile;

  }

  protected void removeDefinitionCaches( SoapuiProjectDocumentConfig config )

  {

    for( InterfaceConfig ifaceConfig : config.getSoapuiProject().getInterfaceList() )

    {

      if( ifaceConfig.isSetDefinitionCache() )

      {

        log.info( "Removing definition cache from interface [" + ifaceConfig.getName() + "]" );

        ifaceConfig.unsetDefinitionCache();

      }

    }

  }

  public AbstractInterface<?> addNewInterface( String name, String type )

  {

    AbstractInterface<?> iface = ( AbstractInterface<?> )InterfaceFactoryRegistry.createNew( this, type, name );

    if( iface != null )

    {

      iface.getConfig().setType( type );

      interfaces.add( iface );

      fireInterfaceAdded( iface );

    }

    return iface;

  }

  public void addProjectListener( ProjectListener listener )

  {

    projectListeners.add( listener );

  }

  public void removeProjectListener( ProjectListener listener )

  {

    projectListeners.remove( listener );

  }

  public void fireInterfaceAdded( AbstractInterface<?> iface )

  {

    ProjectListener[] a = projectListeners.toArray( new ProjectListener[projectListeners.size()] );

    for( int c = 0; c < a.length; c++ )

    {

      a[c].interfaceAdded( iface );

    }

  }

  public void fireInterfaceRemoved( AbstractInterface<?> iface )

  {

    ProjectListener[] a = projectListeners.toArray( new ProjectListener[projectListeners.size()] );

    for( int c = 0; c < a.length; c++ )

    {

      a[c].interfaceRemoved( iface );

    }

  }

  public void fireInterfaceUpdated( AbstractInterface<?> iface )

  {

    ProjectListener[] a = projectListeners.toArray( new ProjectListener[projectListeners.size()] );

    for( int c = 0; c < a.length; c++ )