/**************************************************************
 * 
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 * 
 *   http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 * 
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_desktop.hxx"

#include "dp_gui_updatedata.hxx"

#include "sal/config.h"
#include "osl/file.hxx"
#include "osl/conditn.hxx"
#include "cppuhelper/exc_hlp.hxx"
#include "tools/resid.hxx"
#include "tools/resmgr.hxx"
#include "tools/solar.h"
#include "tools/string.hxx"
#include "vcl/dialog.hxx"
#include "vcl/msgbox.hxx"
#include "vcl/svapp.hxx"
#include "vos/mutex.hxx"
#include "vcl/dialog.hxx"
#include "cppuhelper/implbase3.hxx"

#include "com/sun/star/beans/PropertyValue.hpp"
#include "com/sun/star/beans/NamedValue.hpp"
#include "com/sun/star/xml/dom/XElement.hpp"
#include "com/sun/star/xml/dom/XNode.hpp"
#include "com/sun/star/xml/dom/XNodeList.hpp"
#include "com/sun/star/ucb/NameClash.hpp"
#include "com/sun/star/ucb/InteractiveAugmentedIOException.hpp"
#include "com/sun/star/ucb/XCommandEnvironment.hpp"
#include "com/sun/star/ucb/XProgressHandler.hpp"
#include "com/sun/star/deployment/XExtensionManager.hpp"
#include "com/sun/star/deployment/ExtensionManager.hpp"
#include "com/sun/star/deployment/XUpdateInformationProvider.hpp"
#include "com/sun/star/deployment/DependencyException.hpp"
#include "com/sun/star/deployment/LicenseException.hpp"
#include "com/sun/star/deployment/VersionException.hpp"
#include "com/sun/star/deployment/ui/LicenseDialog.hpp"
#include "com/sun/star/task/XInteractionHandler.hpp"
#include "com/sun/star/ui/dialogs/XExecutableDialog.hpp"
#include "com/sun/star/ui/dialogs/ExecutableDialogResults.hpp"  
#include "com/sun/star/task/XInteractionAbort.hpp"
#include "com/sun/star/task/XInteractionApprove.hpp"

#include "dp_descriptioninfoset.hxx"
#include "dp_gui.hrc"
#include "dp_gui_updateinstalldialog.hxx"
#include "dp_gui_shared.hxx"
#include "dp_gui_updatedata.hxx"
#include "dp_ucb.h"
#include "dp_misc.h"
#include "dp_version.hxx"
#include "dp_gui_thread.hxx"
#include "dp_gui_extensioncmdqueue.hxx"
#include "ucbhelper/content.hxx"
#include "osl/mutex.hxx"
#include "vos/mutex.hxx"
#include "rtl/ref.hxx"
#include "com/sun/star/uno/Sequence.h"
#include "comphelper/anytostring.hxx"
#include "toolkit/helper/vclunohelper.hxx"

#include <vector>

class Window;

namespace cssu = ::com::sun::star::uno;
namespace css = ::com::sun::star;

using ::rtl::OUString;


namespace dp_gui {

class UpdateInstallDialog::Thread: public dp_gui::Thread {
    friend class UpdateCommandEnv;
public:
    Thread(cssu::Reference< cssu::XComponentContext > ctx,
        UpdateInstallDialog & dialog, std::vector< dp_gui::UpdateData > & aVecUpdateData);

    void stop();

    

private:
    Thread(Thread &); // not defined
    void operator =(Thread &); // not defined

    virtual ~Thread();

    virtual void execute();
    void downloadExtensions();
    void download(::rtl::OUString const & aUrls, UpdateData & aUpdatData);
    void installExtensions();
    void removeTempDownloads();

    UpdateInstallDialog & m_dialog;
    cssu::Reference< css::deployment::XUpdateInformationProvider >
        m_updateInformation;

    // guarded by Application::GetSolarMutex():
    cssu::Reference< css::task::XAbortChannel > m_abort;
    cssu::Reference< cssu::XComponentContext > m_xComponentContext;
    std::vector< dp_gui::UpdateData > & m_aVecUpdateData;
    ::rtl::Reference<UpdateCommandEnv> m_updateCmdEnv;

    //A folder which is created in the temp directory in which then the updates are downloaded
    ::rtl::OUString m_sDownloadFolder;

    bool m_stop;

};

class UpdateCommandEnv
    : public ::cppu::WeakImplHelper3< css::ucb::XCommandEnvironment,
                                      css::task::XInteractionHandler,
                                      css::ucb::XProgressHandler >
{
    friend class UpdateInstallDialog::Thread;

    UpdateInstallDialog & m_updateDialog;
    ::rtl::Reference<UpdateInstallDialog::Thread> m_installThread; 
    cssu::Reference< cssu::XComponentContext > m_xContext;

public:
    virtual ~UpdateCommandEnv();
    UpdateCommandEnv( cssu::Reference< cssu::XComponentContext > const & xCtx, 
        UpdateInstallDialog & updateDialog,
        ::rtl::Reference<UpdateInstallDialog::Thread>const & thread);

    // XCommandEnvironment
    virtual cssu::Reference<css::task::XInteractionHandler > SAL_CALL
    getInteractionHandler() throw (cssu::RuntimeException);
    virtual cssu::Reference<css::ucb::XProgressHandler >
    SAL_CALL getProgressHandler() throw (cssu::RuntimeException);

    // XInteractionHandler
    virtual void SAL_CALL handle(
        cssu::Reference<css::task::XInteractionRequest > const & xRequest )
        throw (cssu::RuntimeException);

    // XProgressHandler
    virtual void SAL_CALL push( cssu::Any const & Status )
        throw (cssu::RuntimeException);
    virtual void SAL_CALL update( cssu::Any const & Status )
        throw (cssu::RuntimeException);
    virtual void SAL_CALL pop() throw (cssu::RuntimeException);
};


UpdateInstallDialog::Thread::Thread(
    cssu::Reference< cssu::XComponentContext> xCtx,
    UpdateInstallDialog & dialog,
    std::vector< dp_gui::UpdateData > & aVecUpdateData):
    m_dialog(dialog),
    m_xComponentContext(xCtx),
    m_aVecUpdateData(aVecUpdateData),
    m_updateCmdEnv(new UpdateCommandEnv(xCtx, m_dialog, this)),
    m_stop(false)
{}

void UpdateInstallDialog::Thread::stop() {
    cssu::Reference< css::task::XAbortChannel > abort;
    {
        vos::OGuard g(Application::GetSolarMutex());
        abort = m_abort;
        m_stop = true;
    }
    if (abort.is()) {
        abort->sendAbort();
    }
}

UpdateInstallDialog::Thread::~Thread() {}

void UpdateInstallDialog::Thread::execute() 
{
    try {
        downloadExtensions();    
        installExtensions();
    }
    catch (...) 
    {
    }

    //clean up the temp directories
    try {
        removeTempDownloads();
    } catch( ... ) {
    }

    {
        //make sure m_dialog is still alive
        ::vos::OGuard g(Application::GetSolarMutex());
        if (! m_stop) 
             m_dialog.updateDone();
    }
    //UpdateCommandEnv keeps a reference to Thread and prevents destruction. Therefore remove it.
    m_updateCmdEnv->m_installThread.clear();
}


UpdateInstallDialog::UpdateInstallDialog(
    Window * parent,  
    std::vector<dp_gui::UpdateData> & aVecUpdateData,
    cssu::Reference< cssu::XComponentContext > const & xCtx):
    ModalDialog(
        parent,
        DpGuiResId(RID_DLG_UPDATEINSTALL)),

        m_thread(new Thread(xCtx, *this, aVecUpdateData)),
        m_xComponentContext(xCtx),
        m_bError(false),
        m_bNoEntry(true),
        m_bActivated(false),
        m_sInstalling(String(DpGuiResId(RID_DLG_UPDATE_INSTALL_INSTALLING))),
        m_sFinished(String(DpGuiResId(RID_DLG_UPDATE_INSTALL_FINISHED))),
        m_sNoErrors(String(DpGuiResId(RID_DLG_UPDATE_INSTALL_NO_ERRORS))),
        m_sErrorDownload(String(DpGuiResId(RID_DLG_UPDATE_INSTALL_ERROR_DOWNLOAD))),
        m_sErrorInstallation(String(DpGuiResId(RID_DLG_UPDATE_INSTALL_ERROR_INSTALLATION))),
        m_sErrorLicenseDeclined(String(DpGuiResId(RID_DLG_UPDATE_INSTALL_ERROR_LIC_DECLINED))),
        m_sNoInstall(String(DpGuiResId(RID_DLG_UPDATE_INSTALL_EXTENSION_NOINSTALL))),       
        m_sThisErrorOccurred(String(DpGuiResId(RID_DLG_UPDATE_INSTALL_THIS_ERROR_OCCURRED))),
        m_ft_action(this, DpGuiResId(RID_DLG_UPDATE_INSTALL_DOWNLOADING)),
        m_statusbar(this,DpGuiResId(RID_DLG_UPDATE_INSTALL_STATUSBAR)),
        m_ft_extension_name(this, DpGuiResId(RID_DLG_UPDATE_INSTALL_EXTENSION_NAME)),
        m_ft_results(this, DpGuiResId(RID_DLG_UPDATE_INSTALL_RESULTS)),
        m_mle_info(this, DpGuiResId(RID_DLG_UPDATE_INSTALL_INFO)),
        m_line(this, DpGuiResId(RID_DLG_UPDATE_INSTALL_LINE)),
        m_help(this, DpGuiResId(RID_DLG_UPDATE_INSTALL_HELP)),
        m_ok(this, DpGuiResId(RID_DLG_UPDATE_INSTALL_OK)),
        m_cancel(this, DpGuiResId(RID_DLG_UPDATE_INSTALL_ABORT))
{
    FreeResource();

    m_xExtensionManager = css::deployment::ExtensionManager::get( xCtx );

    m_cancel.SetClickHdl(LINK(this, UpdateInstallDialog, cancelHandler));
    m_mle_info.EnableCursor(sal_False);
    if ( ! dp_misc::office_is_running())
        m_help.Disable();
}

UpdateInstallDialog::~UpdateInstallDialog() {}

sal_Bool UpdateInstallDialog::Close() 
{
    m_thread->stop();
    return ModalDialog::Close();
}

short UpdateInstallDialog::Execute() 
{   
    m_thread->launch();
    return ModalDialog::Execute();
}


// make sure the solar mutex is locked before calling
void UpdateInstallDialog::updateDone() 
{
    if (!m_bError)
        m_mle_info.InsertText(m_sNoErrors);
    m_ok.Enable();
    m_ok.GrabFocus();
    m_cancel.Disable();
}
// make sure the solar mutex is locked before calling
//sets an error message in the text area
void UpdateInstallDialog::setError(INSTALL_ERROR err, ::rtl::OUString const & sExtension, 
    OUString const & exceptionMessage) 
{
    String sError;
    m_bError = true;

    switch (err)
    {
    case ERROR_DOWNLOAD:
        sError = m_sErrorDownload; 
        break;
    case ERROR_INSTALLATION:
        sError = m_sErrorInstallation; 
        break;
    case ERROR_LICENSE_DECLINED:
        sError = m_sErrorLicenseDeclined; 
        break;

    default:
        OSL_ASSERT(0);
    }

    sError.SearchAndReplace(String(OUSTR("%NAME")), String(sExtension), 0);
    //We want to have an empty line between the error messages. However, 
    //there shall be no empty line after the last entry.
    if (m_bNoEntry)
        m_bNoEntry = false;
    else
        m_mle_info.InsertText(OUSTR("\n"));
    m_mle_info.InsertText(sError);
    //Insert more information about the error 
    if (exceptionMessage.getLength())
        m_mle_info.InsertText(m_sThisErrorOccurred + exceptionMessage + OUSTR("\n"));

    m_mle_info.InsertText(m_sNoInstall);
    m_mle_info.InsertText(OUSTR("\n"));
}

void UpdateInstallDialog::setError(OUString const & exceptionMessage) 
{
    m_bError = true;
    m_mle_info.InsertText(exceptionMessage + OUSTR("\n"));
}

IMPL_LINK(UpdateInstallDialog, cancelHandler, void *, EMPTYARG) 
{
    m_thread->stop();
    EndDialog(RET_CANCEL);
    return 0;
}

//------------------------------------------------------------------------------------------------

void UpdateInstallDialog::Thread::downloadExtensions()
{
    try 
    {
        //create the download directory in the temp folder
        OUString sTempDir;
        if (::osl::FileBase::getTempDirURL(sTempDir) != ::osl::FileBase::E_None)
            throw cssu::Exception(OUSTR("Could not get URL for the temp directory. No extensions will be installed."), 0);

        //create a unique name for the directory
        OUString tempEntry, destFolder;
        if (::osl::File::createTempFile(&sTempDir, 0, &tempEntry ) != ::osl::File::E_None)
            throw cssu::Exception(OUSTR("Could not create a temporary file in ") + sTempDir + 
             OUSTR(". No extensions will be installed"), 0 );
     
        tempEntry = tempEntry.copy( tempEntry.lastIndexOf( '/' ) + 1 );
        
        destFolder = dp_misc::makeURL( sTempDir, tempEntry );
        destFolder += OUSTR("_");
        m_sDownloadFolder = destFolder;
        try 
        {
            dp_misc::create_folder(0, destFolder, m_updateCmdEnv.get(), true );
        } catch (cssu::Exception & e) 
        {
            throw cssu::Exception(e.Message + OUSTR(" No extensions will be installed."), 0);
        }

        
        sal_uInt16 count = 0;
        typedef std::vector<UpdateData>::iterator It;
        for (It i = m_aVecUpdateData.begin(); i != m_aVecUpdateData.end(); i++)
        {
            UpdateData & curData = *i;
           
            if (!curData.aUpdateInfo.is() || curData.aUpdateSource.is())
                continue;
            //We assume that m_aVecUpdateData contains only information about extensions which 
            //can be downloaded directly.
            OSL_ASSERT(curData.sWebsiteURL.getLength() == 0);
 
			//update the name of the extension which is to be downloaded
            {
                ::vos::OGuard g(Application::GetSolarMutex());
                if (m_stop) {
                    return;
                }
                m_dialog.m_ft_extension_name.SetText(curData.aInstalledPackage->getDisplayName());
                sal_uInt16 prog = (sal::static_int_cast<sal_uInt16>(100) * ++count) /
                    sal::static_int_cast<sal_uInt16>(m_aVecUpdateData.size());
                m_dialog.m_statusbar.SetValue(prog);
            }
            dp_misc::DescriptionInfoset info(m_xComponentContext, curData.aUpdateInfo);
            //remember occurring exceptions in case we need to print out error information
            ::std::vector< ::std::pair<OUString, cssu::Exception> > vecExceptions;
            cssu::Sequence<OUString> seqDownloadURLs = info.getUpdateDownloadUrls();
            OSL_ENSURE(seqDownloadURLs.getLength() > 0, "No download URL provided!");
            for (sal_Int32 j = 0; j < seqDownloadURLs.getLength(); j++)
            {
                try 
                {
                    OSL_ENSURE(seqDownloadURLs[j].getLength() > 0, "Download URL is empty!");
                    download(seqDownloadURLs[j], curData);
                    if (curData.sLocalURL.getLength() > 0)
                        break;
                }
                catch ( cssu::Exception & e )
                {
                    vecExceptions.push_back( ::std::make_pair(seqDownloadURLs[j], e));
                    //There can be several different errors, for example, the URL is wrong, webserver cannot be reached,
                    //name cannot be resolved. The UCB helper API does not specify different special exceptions for these
                    //cases. Therefore ignore and continue.
                    continue;
                }
            } 
            //update the progress and display download error
            {
                ::vos::OGuard g(Application::GetSolarMutex());
                if (m_stop) {
                    return;
                }
                if (curData.sLocalURL.getLength() == 0)
                {
                    //Construct a string of all messages contained in the exceptions plus the respective download URLs
                    ::rtl::OUStringBuffer buf(256);
                    typedef ::std::vector< ::std::pair<OUString, cssu::Exception > >::const_iterator CIT;
                    for (CIT j = vecExceptions.begin(); j != vecExceptions.end(); j++)
                    {
                        if (j != vecExceptions.begin())
                            buf.appendAscii("\n");
                        buf.append(OUSTR("Could not download "));
                        buf.append(j->first);
                        buf.appendAscii(". ");
                        buf.append(j->second.Message);
                    }
                    m_dialog.setError(UpdateInstallDialog::ERROR_DOWNLOAD, curData.aInstalledPackage->getDisplayName(), 
                        buf.makeStringAndClear());
                }
            }
     
        }
    }
    catch (cssu::Exception & e)
    {
        ::vos::OGuard g(Application::GetSolarMutex());
        if (m_stop) {
            return;
        }
        m_dialog.setError(e.Message);
    }
}
void UpdateInstallDialog::Thread::installExtensions()
{
    //Update the fix text in the dialog to "Installing extensions..."
    {
        vos::OGuard g(Application::GetSolarMutex());
        if (m_stop) {
            return;
        }
        m_dialog.m_ft_action.SetText(m_dialog.m_sInstalling);
        m_dialog.m_statusbar.SetValue(0);
    }

    sal_uInt16 count = 0;
    typedef std::vector<UpdateData>::iterator It;
    for (It i = m_aVecUpdateData.begin(); i != m_aVecUpdateData.end(); i++, count++)
    {         
        //update the name of the extension which is to be installed
        {
            ::vos::OGuard g(Application::GetSolarMutex());
            if (m_stop) {
                return;
            }
            //we only show progress after an extension has been installed.
            if (count > 0) {
                m_dialog.m_statusbar.SetValue(
                (sal::static_int_cast<sal_uInt16>(100) * count) /
                sal::static_int_cast<sal_uInt16>(m_aVecUpdateData.size()));
             }
            m_dialog.m_ft_extension_name.SetText(i->aInstalledPackage->getDisplayName());
        }
//         TimeValue v = {1, 0};
//       osl::Thread::wait(v);
        bool bError = false;
        bool bLicenseDeclined = false;
        cssu::Reference<css::deployment::XPackage> xExtension;
        UpdateData & curData = *i;
        cssu::Exception exc;
        try
        {
            cssu::Reference< css::task::XAbortChannel > xAbortChannel(
                curData.aInstalledPackage->createAbortChannel() );
            {
                vos::OGuard g(Application::GetSolarMutex());
                if (m_stop) {
                    return;
                }
                m_abort = xAbortChannel;
            }
            if (!curData.aUpdateSource.is() && curData.sLocalURL.getLength())
            {
                css::beans::NamedValue prop(OUSTR("EXTENSION_UPDATE"), css::uno::makeAny(OUSTR("1")));
                if (!curData.bIsShared)
                    xExtension = m_dialog.getExtensionManager()->addExtension(
                        curData.sLocalURL, css::uno::Sequence<css::beans::NamedValue>(&prop, 1),
                        OUSTR("user"), xAbortChannel, m_updateCmdEnv.get());
                else
                    xExtension = m_dialog.getExtensionManager()->addExtension(
                        curData.sLocalURL, css::uno::Sequence<css::beans::NamedValue>(&prop, 1),
                        OUSTR("shared"), xAbortChannel, m_updateCmdEnv.get());
            }
            else if (curData.aUpdateSource.is())
            {
                OSL_ASSERT(curData.aUpdateSource.is());
                //I am not sure if we should obtain the install properties and pass them into
                //add extension. Currently it contains only "SUPPRESS_LICENSE". So it it could happen
                //that a license is displayed when updating from the shared repository, although the
                //shared extension was installed using "SUPPRESS_LICENSE".
                css::beans::NamedValue prop(OUSTR("EXTENSION_UPDATE"), css::uno::makeAny(OUSTR("1")));
                if (!curData.bIsShared)
                    xExtension = m_dialog.getExtensionManager()->addExtension(
                        curData.aUpdateSource->getURL(), css::uno::Sequence<css::beans::NamedValue>(&prop, 1),
                        OUSTR("user"), xAbortChannel, m_updateCmdEnv.get());
                else
                    xExtension = m_dialog.getExtensionManager()->addExtension(
                        curData.aUpdateSource->getURL(), css::uno::Sequence<css::beans::NamedValue>(&prop, 1),
                        OUSTR("shared"), xAbortChannel, m_updateCmdEnv.get());
            }
        }
        catch (css::deployment::DeploymentException & de)
        {
            if (de.Cause.has<css::deployment::LicenseException>())
            {
                bLicenseDeclined = true;
            }
            else
            {
                exc = de.Cause.get<cssu::Exception>();
                bError = true;
            }
        }
        catch (cssu::Exception& e)
        {
            exc = e;
            bError = true;
        }     

        if (bLicenseDeclined)
        {
            ::vos::OGuard g(Application::GetSolarMutex());
            if (m_stop) {
                return;
            }
            m_dialog.setError(UpdateInstallDialog::ERROR_LICENSE_DECLINED, 
                curData.aInstalledPackage->getDisplayName(), OUString());
        }
        else if (!xExtension.is() || bError)
        {
            ::vos::OGuard g(Application::GetSolarMutex());
            if (m_stop) {
                return;
            }
            m_dialog.setError(UpdateInstallDialog::ERROR_INSTALLATION, 
                curData.aInstalledPackage->getDisplayName(), exc.Message);
        }
    }
    {
        vos::OGuard g(Application::GetSolarMutex());
        if (m_stop) {
            return;
        }
        m_dialog.m_statusbar.SetValue(100);
        m_dialog.m_ft_extension_name.SetText(OUString());
        m_dialog.m_ft_action.SetText(m_dialog.m_sFinished);
    }
}

void UpdateInstallDialog::Thread::removeTempDownloads()
{
    if (m_sDownloadFolder.getLength())
    {
        dp_misc::erase_path(m_sDownloadFolder, 
            cssu::Reference<css::ucb::XCommandEnvironment>(),false /* no throw: ignore errors */ );
        //remove also the temp file which we have used to create the unique name
        OUString tempFile = m_sDownloadFolder.copy(0, m_sDownloadFolder.getLength() - 1);
        dp_misc::erase_path(tempFile, cssu::Reference<css::ucb::XCommandEnvironment>(),false);
        m_sDownloadFolder = OUString();
    }
}


void UpdateInstallDialog::Thread::download(OUString const & sDownloadURL, UpdateData & aUpdateData)
{
    {
        ::vos::OGuard g(Application::GetSolarMutex());
        if (m_stop) {
            return;
        }
    }

    OSL_ASSERT(m_sDownloadFolder.getLength());
    OUString destFolder, tempEntry;
    if (::osl::File::createTempFile(
        &m_sDownloadFolder,
        0, &tempEntry ) != ::osl::File::E_None)
    {
        //ToDo feedback in window that download of this component failed
        throw cssu::Exception(OUSTR("Could not create temporary file in folder ") + destFolder + OUSTR("."), 0);
    }
    tempEntry = tempEntry.copy( tempEntry.lastIndexOf( '/' ) + 1 );

    destFolder = dp_misc::makeURL( m_sDownloadFolder, tempEntry );
    destFolder += OUSTR("_");
    
    ::ucbhelper::Content destFolderContent;
    dp_misc::create_folder( &destFolderContent, destFolder, m_updateCmdEnv.get() );

    ::ucbhelper::Content sourceContent;    
    dp_misc::create_ucb_content( &sourceContent, sDownloadURL, m_updateCmdEnv.get() ); 

	const OUString sTitle(sourceContent.getPropertyValue(
		                  dp_misc::StrTitle::get() ).get<OUString>() );
    
	if (destFolderContent.transferContent(
            sourceContent, ::ucbhelper::InsertOperation_COPY,
            sTitle, css::ucb::NameClash::OVERWRITE ))
    {
        //the user may have cancelled the dialog because downloading took to long
        {
            ::vos::OGuard g(Application::GetSolarMutex());
            if (m_stop) {
                return;
            }
            //all errors should be handeld by the command environment.
            aUpdateData.sLocalURL = destFolder + OUString( RTL_CONSTASCII_USTRINGPARAM( "/" ) ) + sTitle;
        }
    }
}


// -------------------------------------------------------------------------------------------------------

UpdateCommandEnv::UpdateCommandEnv( cssu::Reference< cssu::XComponentContext > const & xCtx, 
    UpdateInstallDialog & updateDialog,
    ::rtl::Reference<UpdateInstallDialog::Thread>const & thread)
    : m_updateDialog( updateDialog ),
    m_installThread(thread),
    m_xContext(xCtx)
{
}

UpdateCommandEnv::~UpdateCommandEnv()
{
}


// XCommandEnvironment
//______________________________________________________________________________
cssu::Reference<css::task::XInteractionHandler> UpdateCommandEnv::getInteractionHandler()
throw (cssu::RuntimeException)
{
    return this;
}

//______________________________________________________________________________
cssu::Reference<css::ucb::XProgressHandler> UpdateCommandEnv::getProgressHandler()
throw (cssu::RuntimeException)
{
    return this;
}

// XInteractionHandler
void UpdateCommandEnv::handle(
    cssu::Reference< css::task::XInteractionRequest> const & xRequest )
    throw (cssu::RuntimeException)
{
    cssu::Any request( xRequest->getRequest() );
    OSL_ASSERT( request.getValueTypeClass() == cssu::TypeClass_EXCEPTION );
    dp_misc::TRACE(OUSTR("[dp_gui_cmdenv.cxx] incoming request:\n")
        + ::comphelper::anyToString(request) + OUSTR("\n\n"));
    
    css::deployment::VersionException verExc;	
    bool approve = false;
    bool abort = false;

    if (request >>= verExc)
    {   //We must catch the version exception during the update,
        //because otherwise the user would be confronted with the dialogs, asking
        //them if they want to replace an already installed version of the same extension.
        //During an update we assume that we always want to replace the old version with the 
        //new version.
        approve = true;
    }

    if (approve == false && abort == false)
    {
        //forward to interaction handler for main dialog.
        handleInteractionRequest( m_xContext, xRequest );
    }
    else
	{
	    // select:
        cssu::Sequence< cssu::Reference< css::task::XInteractionContinuation > > conts(
            xRequest->getContinuations() );
        cssu::Reference< css::task::XInteractionContinuation > const * pConts =
            conts.getConstArray();
        sal_Int32 len = conts.getLength();
        for ( sal_Int32 pos = 0; pos < len; ++pos )
        {
            if (approve) {
                cssu::Reference< css::task::XInteractionApprove > xInteractionApprove(
                    pConts[ pos ], cssu::UNO_QUERY );
                if (xInteractionApprove.is()) {
                    xInteractionApprove->select();
                    // don't query again for ongoing continuations:
                    approve = false;
                }
            }
            else if (abort) {
                cssu::Reference< css::task::XInteractionAbort > xInteractionAbort(
                    pConts[ pos ], cssu::UNO_QUERY );
                if (xInteractionAbort.is()) {           
                    xInteractionAbort->select();
                    // don't query again for ongoing continuations:
                    abort = false;
                }
            }
        }
	}
}

// XProgressHandler
void UpdateCommandEnv::push( cssu::Any const & /*Status*/ )
throw (cssu::RuntimeException)
{
}


void UpdateCommandEnv::update( cssu::Any const & /*Status */)
throw (cssu::RuntimeException)
{
}

void UpdateCommandEnv::pop() throw (cssu::RuntimeException)
{
}


} //end namespace dp_gui