/*! @file

    @id $Id: browser.hxx 15 2010-06-03 14:17:27Z marc $
*/
//       1         2         3         4         5         6         7         8
// 45678901234567890123456789012345678901234567890123456789012345678901234567890

#ifndef BROWSER_HXX
#define BROWSER_HXX

#include <ui_browser.h>
#include <QtGui/QMainWindow>
#include <QtGui/QLineEdit>
#include <QtGui/QProgressBar>
#include <QtGui/QSlider>
#include <QtGui/QMessageBox>
#include <QtGui/QPrinter>
#include <QtGui/QPrintDialog>
#include <QtGui/QPrintPreviewDialog>
#include <QtWebKit/QWebPage>
#include <QtWebKit/QWebView>
#include <QtWebKit/QWebFrame>
#include <QtWebKit/QWebHistory>
#include <QtNetwork/QNetworkReply>
#include <QtNetwork/QNetworkAccessManager>
#include <QtNetwork/QSslError>
#include <QtNetwork/QNetworkProxy>
#include <QtCore/QTemporaryFile>
#include <QtCore/QProcess>
#include <QtCore/QDir>
#include <QtGui/QFileDialog>

#include <smartcardauth.hxx>
#include <downloadmanager.hxx>

#include <stdexcept>
#include <cassert>

#include <QtCore/QDebug>
#ifndef LOG
#define LOG qDebug()<<__PRETTY_FUNCTION__
#endif

extern SmartCardAuth _scAuth;

class SslClientAuthNetworkAccessManager: public QNetworkAccessManager {
    Q_OBJECT;
  public:
    
    SslClientAuthNetworkAccessManager(QObject* parent = 0):
        QNetworkAccessManager(parent) {
      LOG;
    }
    
    virtual ~SslClientAuthNetworkAccessManager() {
      LOG;
    }

  Q_SIGNALS:

    void created(QNetworkReply*);
    
  protected:
    
    virtual QNetworkReply* createRequest(Operation op,
                                         const QNetworkRequest& req,
                                         QIODevice* outgoingData = 0 ) {
      LOG<<req.url();
      QNetworkReply* rep
        (QNetworkAccessManager::createRequest(op, req, outgoingData));
      created(rep);
      LOG<<"Reply to URL: "<<rep->url().toString();
      return rep;
    }

};

class Browser: public QMainWindow, protected Ui::Browser {

    Q_OBJECT;

  public:

    typedef std::map<QString, std::pair<QString, QString> > MimeTypes;

  public:

    Browser(const QString& url, MimeTypes mimeTypes, bool kiosk = false):
        _url(0), _find(0), _home(url), _kiosk(kiosk), _mimetypes(mimeTypes) {
      LOG<<url;
      QNetworkProxyFactory::setUseSystemConfiguration(true);
      QWebSettings::globalSettings()->setAttribute
        (QWebSettings::PluginsEnabled, true);
      if (!check(url))
        throw std::runtime_error(tr("access to URL %1 not allowed")
                                 .arg(url).toStdString());
      setupUi(this);
      statusBar()->addPermanentWidget(_progress = new QProgressBar());
      statusBar()->addPermanentWidget(_zoom = new QSlider(Qt::Horizontal));
      _zoom->setMinimum(1);
      _zoom->setMaximum(100);
      _zoom->setValue(10);
      assert(connect(_zoom, SIGNAL(valueChanged(int)), SLOT(zoom(int))));
      _toolbar->addWidget(_url = new QLineEdit(_toolbar));
      on_actionNewTab_triggered();
      _url->setText(url);
      assert(connect(_url, SIGNAL(returnPressed()), SLOT(load())));
      assert(connect(&_networkManager,
                     SIGNAL(extendedContextInitialization(ssl_ctx_st*,
                                                          QSslSocket*)),
                     &_scAuth,
                     SLOT(extendedContextInitialization(ssl_ctx_st*,
                                                        QSslSocket*))));
      assert(connect(&_networkManager, SIGNAL(created(QNetworkReply*)),
                     &_downloadManager, SLOT(add(QNetworkReply*))));
      
      assert(connect(&_downloadManager, SIGNAL(progress(qint64, qint64)),
                     SLOT(progress(qint64, qint64))));
      assert(connect(&_downloadManager, SIGNAL(started()),
                     SLOT(started())));
      assert(connect(&_downloadManager, SIGNAL(finished()),
                     SLOT(finished())));
      
      if (_kiosk) {
        _menu->hide();
        _url->setEnabled(false);
      }
      load(url);
    }

    ~Browser() {
      LOG;
      for (DownloadProcesses::iterator it(_downloadProcesses.begin());
           it!=_downloadProcesses.end(); ++it) {
        LOG<<"delete:"<<it->second->fileName();
        delete it->second;
        it->second = 0;
        it->first->terminate();
        delete it->first;
      }
    }

    QString networkError(QNetworkReply::NetworkError err) {
      LOG<<err;
      switch (err) {
        case QNetworkReply::NoError:
          return tr("Network connection successful, remote host can be"
                    " reached.");
        case QNetworkReply::ConnectionRefusedError:
          return tr("The remote server refused the connection (the server is"
                    " not accepting requests).");
        case QNetworkReply::RemoteHostClosedError:
          return tr("The remote server closed the connection prematurely,"
                    " before the entire reply was received and processed.");
        case QNetworkReply::HostNotFoundError:
          return tr("The remote host name was not found (invalid hostname).");
        case QNetworkReply::TimeoutError:
          return tr("The connection to the remote server timed out.");
        case QNetworkReply::OperationCanceledError:
          return tr("The operation was canceled via calls to abort() or"
                    " close() before it was finished.");
        case QNetworkReply::SslHandshakeFailedError:
          return tr("The SSL/TLS handshake failed and the encrypted channel"
                    " could not be established. The sslErrors() signal should"
                    " have been emitted.");
        case QNetworkReply::ProxyConnectionRefusedError:
          return tr("The connection to the proxy server was refused (the"
                    " proxy server is not accepting requests).");
        case QNetworkReply::ProxyConnectionClosedError:
          return tr("The proxy server closed the connection prematurely,"
                    " before the entire reply was received and processed.");
        case QNetworkReply::ProxyNotFoundError:
          return tr("The proxy host name was not found (invalid proxy"
                    " hostname).");
        case QNetworkReply::ProxyTimeoutError:
          return tr("The connection to the proxy timed out or the proxy did"
                    " not reply in time to the request sent.");
        case QNetworkReply::ProxyAuthenticationRequiredError:
          return tr("The proxy requires authentication in order to honour the"
                    " request but did not accept any credentials offered"
                    " (if any).");
        case QNetworkReply::ContentAccessDenied:
          return tr("The access to the remote content was denied (similar to"
                    " HTTP error 401).");
        case QNetworkReply::ContentOperationNotPermittedError:
          return tr("The operation requested on the remote content is not"
                    " permitted.");
        case QNetworkReply::ContentNotFoundError:
          return tr("The remote content was not found at the server (similar"
                    " to HTTP error 404).");
        case QNetworkReply::AuthenticationRequiredError:
          return tr("The remote server requires authentication to serve the"
                    " content but the credentials provided were not accepted"
                    " (if any).");
        case QNetworkReply::ProtocolUnknownError:
          return tr("The Network Access API cannot honor the request because"
                    " the protocol is not known.");
        case QNetworkReply::ProtocolInvalidOperationError:
          return tr("The requested operation is invalid for this protocol.");
        case QNetworkReply::UnknownNetworkError:
          return tr("An unknown network-related error was detected.");
        case QNetworkReply::UnknownProxyError:
          return tr("An unknown proxy-related error was detected.");
        case QNetworkReply::UnknownContentError:
          return tr("An unknonwn error related to the remote content was"
                    " detected.");
        case QNetworkReply::ProtocolFailure:
          return tr("A breakdown in protocol was detected (parsing error,"
                    " invalid or unexpected responses, etc.).");
        default:
          return tr("<strong>Unknown network error (code: %1).</string>")
            .arg(err);
      }
    }

    //! Whitelisting
    bool check(QUrl page) {
      return true;
    }
    
  private Q_SLOTS:
      
    void load() {
      LOG;
      load(_url->text());
    }
    
    void load(QString page) {
      if (QUrl(page).scheme()=="")
        page = "http://"+page;
      if (page.contains(QRegExp("^gg[: ]")))
        page = QString("http://google.com/search?q=%1")
          .arg(page.mid(3));
      if (page.contains(QRegExp("^wp[: ]")))
        page = QString("http://%1.wikipedia.com/wiki/%2")
          .arg(QLocale::system().name().left(2)).arg(page.mid(3));
      load(QUrl(page));
    }
    
    void load(QUrl page) {
      LOG<<page.toString();
      statusBar()->showMessage(tr("Checking: %1").arg(page.toString()));
      if (!check(page)) {
        LOG<<"########## BLACK LISTED IGNORED ##########";
        statusBar()->showMessage(tr("Forbidden: %1").arg(page.toString()));
        QMessageBox::warning(this, tr("Access Denied"),
                             tr("<p>Access denied due to security"
                                " considerations.</p><p>You are not"
                                " allowed to connect to %1.")
                             .arg(page.toString()));
        return;
      }
      startDownload(page);
    }

    void startDownload(QUrl url) {
      LOG<<url.toString();
      statusBar()->showMessage(tr("Reading: %1").arg(url.toString()));
      if (!url.isValid()) {
        statusBar()->showMessage(tr("Illegal URL: %1").arg(url.errorString()));
        return;
      }
      //if (url.scheme()=="") url.setScheme("http");
      dynamic_cast<QWebView*>(_tabs->currentWidget())->load(url);
    }
    
    void zoom(int i) {
      LOG<<100.0*i/10.0;
      statusBar()->showMessage(tr("Zoom: %1%").arg(100.0*i/10.0));
      dynamic_cast<QWebView*>(_tabs->currentWidget())->setZoomFactor(i/10.0);
    }
    
    void on_actionHome_activated() {
      LOG;
      load(_home);
    }
    
//     void on_actionNew_triggered() { //@!todo exec new process
//       LOG;
//       (new Browser(dynamic_cast<QWebView*>(_tabs->currentWidget())->url().toString(), _kiosk, false))->show();
//     }

    void on_actionNewTab_triggered() {
      QWebView* browser(new QWebView);
      browser->page()->setLinkDelegationPolicy(QWebPage::DelegateAllLinks);
      browser->page()->setNetworkAccessManager(&_networkManager);
      browser->page()->setForwardUnsupportedContent(true);
      _url->setFocus();
      // QWebView
      assert(connect(browser, SIGNAL(urlChanged(const QUrl&)),
                     SLOT(urlChanged(const QUrl&))));
      assert(connect(browser, SIGNAL(linkClicked(const QUrl&)),
                     SLOT(linkClicked(const QUrl&))));
      assert(connect(browser, SIGNAL(iconChanged()),
                     SLOT(iconChanged())));
      assert(connect(browser, SIGNAL(titleChanged(const QString&)),
                     SLOT(titleChanged(const QString&))));
      assert(connect(browser, SIGNAL(statusBarMessage(const QString&)),
                     SLOT(statusBarMessage(const QString&))));
      assert(connect(browser, SIGNAL(loadProgress(int)),
                     SLOT(loadProgress(int))));
      assert(connect(browser, SIGNAL(loadStarted()),
                     SLOT(loadStarted())));
      assert(connect(browser, SIGNAL(loadFinished(bool)),
                     SLOT(loadFinished(bool))));
      assert(connect(browser, SIGNAL(iconChanged()),
                     SLOT(iconChanged())));
      // QWebPage WebAction
      assert(connect(browser->pageAction(QWebPage::OpenLink),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredOpenLink(bool))));
      assert(connect(browser->pageAction(QWebPage::OpenLinkInNewWindow),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredOpenLinkInNewWindow(bool))));
      assert(connect(browser->pageAction(QWebPage::OpenFrameInNewWindow),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredOpenFrameInNewWindow(bool))));
      assert(connect(browser->pageAction(QWebPage::DownloadLinkToDisk),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredDownloadLinkToDisk(bool))));
      assert(connect(browser->pageAction(QWebPage::CopyLinkToClipboard),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredCopyLinkToClipboard(bool))));
      assert(connect(browser->pageAction(QWebPage::OpenImageInNewWindow),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredOpenImageInNewWindow(bool))));
      assert(connect(browser->pageAction(QWebPage::DownloadImageToDisk),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredDownloadImageToDisk(bool))));
      assert(connect(browser->pageAction(QWebPage::CopyImageToClipboard),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredCopyImageToClipboard(bool))));
      assert(connect(browser->pageAction(QWebPage::Back),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredBack(bool))));
      assert(connect(browser->pageAction(QWebPage::Forward),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredForward(bool))));
      assert(connect(browser->pageAction(QWebPage::Stop),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredStop(bool))));
      assert(connect(browser->pageAction(QWebPage::Reload),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredReload(bool))));
      assert(connect(browser->pageAction(QWebPage::Cut),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredCut(bool))));
      assert(connect(browser->pageAction(QWebPage::Copy),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredCopy(bool))));
      assert(connect(browser->pageAction(QWebPage::Paste),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredPaste(bool))));
      assert(connect(browser->pageAction(QWebPage::Undo),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredUndo(bool))));
      assert(connect(browser->pageAction(QWebPage::Redo),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredRedo(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToNextChar),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToNextChar(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToPreviousChar),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToPreviousChar(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToNextWord),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToNextWord(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToPreviousWord),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToPreviousWord(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToNextLine),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToNextLine(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToPreviousLine),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToPreviousLine(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToStartOfLine),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToStartOfLine(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToEndOfLine),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToEndOfLine(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToStartOfBlock),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToStartOfBlock(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToEndOfBlock),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToEndOfBlock(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToStartOfDocument),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToStartOfDocument(bool))));
      assert(connect(browser->pageAction(QWebPage::MoveToEndOfDocument),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredMoveToEndOfDocument(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectNextChar),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectNextChar(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectPreviousChar),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectPreviousChar(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectNextWord),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectNextWord(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectPreviousWord),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectPreviousWord(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectNextLine),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectNextLine(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectPreviousLine),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectPreviousLine(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectStartOfLine),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectStartOfLine(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectEndOfLine),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectEndOfLine(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectStartOfBlock),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectStartOfBlock(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectEndOfBlock),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectEndOfBlock(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectStartOfDocument),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectStartOfDocument(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectEndOfDocument),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectEndOfDocument(bool))));
      assert(connect(browser->pageAction(QWebPage::DeleteStartOfWord),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredDeleteStartOfWord(bool))));
      assert(connect(browser->pageAction(QWebPage::DeleteEndOfWord),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredDeleteEndOfWord(bool))));
      assert(connect(browser->pageAction(QWebPage::SetTextDirectionDefault),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSetTextDirectionDefault(bool))));
      assert(connect(browser->pageAction(QWebPage::SetTextDirectionLeftToRight),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSetTextDirectionLeftToRight(bool))));
      assert(connect(browser->pageAction(QWebPage::SetTextDirectionRightToLeft),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSetTextDirectionRightToLeft(bool))));
      assert(connect(browser->pageAction(QWebPage::ToggleBold),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredToggleBold(bool))));
      assert(connect(browser->pageAction(QWebPage::ToggleItalic),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredToggleItalic(bool))));
      assert(connect(browser->pageAction(QWebPage::ToggleUnderline),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredToggleUnderline(bool))));
      assert(connect(browser->pageAction(QWebPage::InspectElement),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredInspectElement(bool))));
      assert(connect(browser->pageAction(QWebPage::InsertParagraphSeparator),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredInsertParagraphSeparator(bool))));
      assert(connect(browser->pageAction(QWebPage::InsertLineSeparator),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredInsertLineSeparator(bool))));
      assert(connect(browser->pageAction(QWebPage::SelectAll),
                     SIGNAL(triggered(bool)),
                     SLOT(triggeredSelectAll(bool))));
      // QWebPage
      assert(connect(browser->page(), SIGNAL(contentsChanged()),
                     SLOT(contentsChanged())));
      assert(connect(browser->page(),
                     SIGNAL(databaseQuotaExceeded(QWebFrame*, QString)),
                     SLOT(databaseQuotaExceeded(QWebFrame*, QString))));
      assert(connect(browser->page(),
                     SIGNAL(downloadRequested(const QNetworkRequest&)),
                     SLOT(downloadRequested(const QNetworkRequest&))));
      assert(connect(browser->page(), SIGNAL(frameCreated(QWebFrame*)),
                     SLOT(frameCreated(QWebFrame*))));
      assert(connect(browser->page(),
                     SIGNAL(geometryChangeRequested(const QRect&)),
                     SLOT(geometryChangeRequested(const QRect&))));
//       assert(connect(browser->page(), SIGNAL(linkClicked(const QUrl&)),
//                      SLOT(linkClicked(const QUrl&))));
      assert(connect(browser->page(),
                     SIGNAL(linkHovered(const QString&, const QString&,
                                        const QString&)),
                     SLOT(linkHovered(const QString&, const QString&,
                                      const QString&))));
//       assert(connect(browser->page(), SIGNAL(loadFinished(bool)),
//                      SLOT(loadFinished(bool))));
//       assert(connect(browser->page(), SIGNAL(loadProgress(int)),
//                      SLOT(loadProgress(int))));
//       assert(connect(browser->page(), SIGNAL(loadStarted()),
//                      SLOT(loadStarted())));
      assert(connect(browser->page(),
                     SIGNAL(menuBarVisibilityChangeRequested(bool)),
                     SLOT(menuBarVisibilityChangeRequested(bool))));
      assert(connect(browser->page(), SIGNAL(microFocusChanged()),
                     SLOT(microFocusChanged())));
      assert(connect(browser->page(), SIGNAL(printRequested(QWebFrame*)),
                     SLOT(printRequested(QWebFrame*))));
      assert(connect(browser->page(), SIGNAL(repaintRequested(const QRect&)),
                     SLOT(repaintRequested(const QRect&))));
      assert(connect(browser->page(),
                     SIGNAL(restoreFrameStateRequested(QWebFrame*)),
                     SLOT(restoreFrameStateRequested(QWebFrame*))));
      assert(connect(browser->page(),
                     SIGNAL(saveFrameStateRequested(QWebFrame*,
                                                    QWebHistoryItem*)),
                     SLOT(saveFrameStateRequested(QWebFrame*,
                                                  QWebHistoryItem*))));
      assert(connect(browser->page(),
                     SIGNAL(scrollRequested(int, int, const QRect&)),
                     SLOT(scrollRequested(int, int, const QRect&))));
      assert(connect(browser->page(), SIGNAL(selectionChanged()),
                     SLOT(selectionChanged())));
//       assert(connect(browser->page(), SIGNAL(statusBarMessage(const QString&)),
//                      SLOT(statusBarMessage(const QString&))));
      assert(connect(browser->page(),
                     SIGNAL(statusBarVisibilityChangeRequested(bool)),
                     SLOT(statusBarVisibilityChangeRequested(bool))));
      assert(connect(browser->page(),
                     SIGNAL(toolBarVisibilityChangeRequested(bool)),
                     SLOT(toolBarVisibilityChangeRequested(bool))));
      assert(connect(browser->page(),
                     SIGNAL(unsupportedContent(QNetworkReply*)),
                     SLOT(unsupportedContent(QNetworkReply*))));
      assert(connect(browser->page(), SIGNAL(windowCloseRequested()),
                     SLOT(windowCloseRequested())));
      // QNetworkAccessManager
      assert(connect(browser->page()->networkAccessManager(),
                     SIGNAL(authenticationRequired(QNetworkReply*,
                                                   QAuthenticator*)),
                     SLOT(authenticationRequired(QNetworkReply*,
                                                 QAuthenticator*))));
      assert(connect(browser->page()->networkAccessManager(),
                     SIGNAL(proxyAuthenticationRequired(const QNetworkProxy&,
                                                 QAuthenticator*)),
                     SLOT(proxyAuthenticationRequired(const QNetworkProxy&,
                                               QAuthenticator*))));
      assert(connect(browser->page()->networkAccessManager(),
                     SIGNAL(sslErrors(QNetworkReply*, const QList<QSslError>&)),
                     SLOT(sslErrors(QNetworkReply*, const QList<QSslError>&))));
      _tabs->setCurrentIndex(_tabs->addTab(browser, "*empty*"));
      _tabs->setTabsClosable(_tabs->count()>1);
    }

    void on__tabs_currentChanged(int index) {
      _url->setText(dynamic_cast<QWebView*>(_tabs->currentWidget())
                    ->url().toString());
      activateTab();
    }
    
    void on__tabs_tabCloseRequested(int index) {
      _error.erase(_tabs->widget(index));
      _errorUrl.erase(_tabs->widget(index));
      _tabs->removeTab(index);
      _tabs->setTabsClosable(_tabs->count()>1);
    }

    void on_actionPrintPreview_triggered() {
      QPrintPreviewDialog preview(&_printer, this);
      connect(&preview, SIGNAL(paintRequested(QPrinter*)),
              dynamic_cast<QWebView*>(_tabs->currentWidget()),
              SLOT(print(QPrinter*)));
      preview.exec();
    }
    
    void on_actionInstantPrint_triggered() {
      dynamic_cast<QWebView*>(_tabs->currentWidget())->print(&_printer);
    }
    
    void on_actionPrint_triggered() {
      QPrintDialog dialog(&_printer, this);
      dialog.setWindowTitle(tr("Print Document"));
      if (dialog.exec()!=QDialog::Accepted) return;
      on_actionInstantPrint_triggered();
    }

    void on_actionClose_triggered() {
      LOG;
      close();
    }

    void on_actionBack_triggered() {
      LOG;
      dynamic_cast<QWebView*>(_tabs->currentWidget())->history()->back();
    }

    void on_actionBack_hovered() {
      LOG;
      if (!dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
          ->backItem().isValid())
        return;
      actionBack->setStatusTip
        (tr("%1 - %2", "statusbar actionBack_hovered %1=url %2=title")
         .arg(dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
              ->backItem().url().toString())
         .arg(dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
              ->backItem().title()));
      actionBack->showStatusText(this);
    }

    void on_actionForward_triggered() {
      LOG;
      dynamic_cast<QWebView*>(_tabs->currentWidget())->history()->forward();
    }

    void on_actionForward_hovered() {
      LOG;
      if (!dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
          ->forwardItem().isValid())
        return;
      actionForward->setStatusTip
        (tr("%1 - %2", "statusbar actionForward_hovered %1=url %2=title")
         .arg(dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
              ->forwardItem().url().toString())
         .arg(dynamic_cast<QWebView*>(_tabs->currentWidget())->history()
              ->forwardItem().title()));
      actionForward->showStatusText(this);
    }

    void on_actionReload_triggered() {
      LOG;
      dynamic_cast<QWebView*>(_tabs->currentWidget())->reload();
    }

    void on_actionStop_triggered() {
      LOG;
      _downloadManager.abort();
    }

    void on_actionFind_triggered() {
      if (!_find) {
        statusBar()->addPermanentWidget(_find = new QLineEdit);
        _find->setText(dynamic_cast<QWebView*>(_tabs->currentWidget())
                       ->selectedText());
        assert(connect(_find, SIGNAL(returnPressed()), SLOT(find())));
      }
      _find->setFocus();
    }

    void find() {
      dynamic_cast<QWebView*>(_tabs->currentWidget())->findText(_find->text());
    }

    void on_actionUnFind_triggered() {
      delete _find; _find=0;
    }
    
    void on_actionAbout_triggered() {
      QMessageBox::aboutQt(this);
    }
    
    //@name                                                       QWebView slots
    //@{
    
    void urlChanged(const QUrl& url) { //!@todo
      LOG<<url.toString();
      if (sender()!=_tabs->currentWidget()) return;
      LOG<<"signal on current tab";
      if (_url) _url->setText(url.toString());
    }
    
    void linkClicked(const QUrl& url) { //!@todo
      LOG<<url.toString();
      if (sender()!=_tabs->currentWidget()) return;
      LOG<<"signal on current tab";
      load(url);
    }
    
    void iconChanged() { //!@todo
      LOG;
      if (sender()!=_tabs->currentWidget()) return;
      LOG<<"signal on current tab";
      setWindowIcon(dynamic_cast<QWebView*>(_tabs->currentWidget())->icon());
    }
    
    void titleChanged(const QString& text) { //!@todo
      LOG<<text;
      if (sender()!=_tabs->currentWidget()) return;
      LOG<<"signal on current tab";
      _tabs->setTabText(_tabs->indexOf(qobject_cast<QWidget*>(sender())),
                        trUtf8("%1").arg(text));
    }
    
    void statusBarMessage(const QString& text) { //!@todo
      LOG<<text;
      if (sender()!=_tabs->currentWidget()) return;
      LOG<<"signal on current tab";
      if (text.size()) statusBar()->showMessage(tr("Info: %1").arg(text));
    }
    
    void loadProgress(int i) {
      LOG<<i;
    }
    
    void loadStarted() {
      LOG;
    }
    
    void loadFinished(bool ok) {
      LOG<<(ok?"success":"error");
//       if (!ok) {
//         dynamic_cast<QWebView*>(sender())
//           ->setHtml(tr("<html><title>Page Load Error</title>"
//                        "<body><h1>Page Load Error</h1>%1"
//                        "</body></html>")
//                     .arg(_error[sender()]),
//                     _errorUrl[sender()]);
//       }
      if (sender()!=_tabs->currentWidget()) return;
      LOG<<"signal on current tab";
      _error[sender()].clear();
      if (ok) statusBar()->showMessage(tr("done."));
      activateTab();
    }

    //@}

    //@name                                             QWebPage WebAction slots
    //@{
    
    void triggeredOpenLink(bool) {
      LOG;
    }
    
    void triggeredOpenLinkInNewWindow(bool) {
      LOG;
    }
    
    void triggeredOpenFrameInNewWindow(bool) {
      LOG;
    }
    
    void triggeredDownloadLinkToDisk(bool) {
      LOG;
    }
    
    void triggeredCopyLinkToClipboard(bool) {
      LOG;
    }
    
    void triggeredOpenImageInNewWindow(bool) {
      LOG;
    }
    
    void triggeredDownloadImageToDisk(bool) {
      LOG;
    }
    
    void triggeredCopyImageToClipboard(bool) {
      LOG;
    }
    
    void triggeredBack(bool) {
      LOG;
    }
    
    void triggeredForward(bool) {
      LOG;
    }
    
    void triggeredStop(bool) {
      LOG;
    }
    
    void triggeredReload(bool) {
      LOG;
    }
    
    void triggeredCut(bool) {
      LOG;
    }
    
    void triggeredCopy(bool) {
      LOG;
    }
    
    void triggeredPaste(bool) {
      LOG;
    }
    
    void triggeredUndo(bool) {
      LOG;
    }
    
    void triggeredRedo(bool) {
      LOG;
    }
    
    void triggeredMoveToNextChar(bool) {
      LOG;
    }
    
    void triggeredMoveToPreviousChar(bool) {
      LOG;
    }
    
    void triggeredMoveToNextWord(bool) {
      LOG;
    }
    
    void triggeredMoveToPreviousWord(bool) {
      LOG;
    }
    
    void triggeredMoveToNextLine(bool) {
      LOG;
    }
    
    void triggeredMoveToPreviousLine(bool) {
      LOG;
    }
    
    void triggeredMoveToStartOfLine(bool) {
      LOG;
    }
    
    void triggeredMoveToEndOfLine(bool) {
      LOG;
    }
    
    void triggeredMoveToStartOfBlock(bool) {
      LOG;
    }
    
    void triggeredMoveToEndOfBlock(bool) {
      LOG;
    }
    
    void triggeredMoveToStartOfDocument(bool) {
      LOG;
    }
    
    void triggeredMoveToEndOfDocument(bool) {
      LOG;
    }
    
    void triggeredSelectNextChar(bool) {
      LOG;
    }
    
    void triggeredSelectPreviousChar(bool) {
      LOG;
    }
    
    void triggeredSelectNextWord(bool) {
      LOG;
    }
    
    void triggeredSelectPreviousWord(bool) {
      LOG;
    }
    
    void triggeredSelectNextLine(bool) {
      LOG;
    }
    
    void triggeredSelectPreviousLine(bool) {
      LOG;
    }
    
    void triggeredSelectStartOfLine(bool) {
      LOG;
    }
    
    void triggeredSelectEndOfLine(bool) {
      LOG;
    }
    
    void triggeredSelectStartOfBlock(bool) {
      LOG;
    }
    
    void triggeredSelectEndOfBlock(bool) {
      LOG;
    }
    
    void triggeredSelectStartOfDocument(bool) {
      LOG;
    }
    
    void triggeredSelectEndOfDocument(bool) {
      LOG;
    }
    
    void triggeredDeleteStartOfWord(bool) {
      LOG;
    }
    
    void triggeredDeleteEndOfWord(bool) {
      LOG;
    }
    
    void triggeredSetTextDirectionDefault(bool) {
      LOG;
    }
    
    void triggeredSetTextDirectionLeftToRight(bool) {
      LOG;
    }
    
    void triggeredSetTextDirectionRightToLeft(bool) {
      LOG;
    }
    
    void triggeredToggleBold(bool) {
      LOG;
    }
    
    void triggeredToggleItalic(bool) {
      LOG;
    }
    
    void triggeredToggleUnderline(bool) {
      LOG;
    }
    
    void triggeredInspectElement(bool) {
      LOG;
    }
    
    void triggeredInsertParagraphSeparator(bool) {
      LOG;
    }
    
    void triggeredInsertLineSeparator(bool) {
      LOG;
    }
    
    void triggeredSelectAll(bool) {
      LOG;
    }
    
    //@}

    //@name                                                       QWebPage slots
    //@{
    
    void contentsChanged() {
      LOG;
    }
    
    void databaseQuotaExceeded(QWebFrame* frame, QString databaseName) {
      LOG<<databaseName;
    }
    
    void downloadRequested(const QNetworkRequest& request) {
      LOG;
    }
    
    void frameCreated(QWebFrame* frame) {
      LOG;
    }
    
    void geometryChangeRequested(const QRect& geom) {
      LOG;
    }
    
//     void linkClicked(const QUrl& url) {
//       LOG<<url.toString();
//     }
    
    void linkHovered(const QString& link, const QString& title,
                     const QString& textContent) {
      LOG<<link<<title<<textContent;
      statusBar()->showMessage(tr("%1", "statusbar for hovered link %1=url")
                               .arg(link));
    }
    
//     void loadFinished(bool ok) {
//       LOG<<(ok?"succeess":"error");
//     }
    
//     void loadProgress(int progress) {
//       LOG<<progress;
//     }
    
//     void loadStarted() {
//       LOG;
//     }
    
    void menuBarVisibilityChangeRequested(bool visible) {
      LOG;
    }
    
    void microFocusChanged() {
      LOG;
    }
    
    void printRequested(QWebFrame* frame) {
      LOG;
    }
    
    void repaintRequested(const QRect& dirtyRect) {
      //LOG;
    }
    
    void restoreFrameStateRequested(QWebFrame* frame) {
      LOG;
    }
    
    void saveFrameStateRequested(QWebFrame* frame, QWebHistoryItem* item) {
      LOG;
    }
    
    void scrollRequested(int dx, int dy, const QRect& rectToScroll) {
      LOG;
    }
    
    void selectionChanged() {
      LOG;
    }
    
//     void statusBarMessage(const QString& text) {
//       LOG;
//     }
    
    void statusBarVisibilityChangeRequested(bool visible) {
      LOG;
    }
    
    void toolBarVisibilityChangeRequested(bool visible) {
      LOG;
    }

    //@name                                                     handle downloads
    //@{
    
    void unsupportedContent(QNetworkReply* reply) {
      LOG<<reply->header(QNetworkRequest::ContentTypeHeader).toString();
      LOG<<"Status:"<<networkError(reply->error());
      assert(connect(reply, SIGNAL(finished()), SLOT(downloadFinished())));
    }

    void downloadFinished() {
      QNetworkReply *reply(qobject_cast<QNetworkReply*>(sender()));
      LOG<<"Location:"<<reply->header(QNetworkRequest::LocationHeader)
        .toString();
      LOG<<"Content-Type:"<<reply->header(QNetworkRequest::ContentTypeHeader)
        .toString();
      LOG<<"Status:"<<networkError(reply->error());
      LOG<<"URL:"<<reply->url().toString();
      LOG<<"File:"<<reply->url().toLocalFile();
      LOG<<"Path:"<<reply->url().path();
      MimeTypes::iterator it
        (_mimetypes.find(reply->header(QNetworkRequest::ContentTypeHeader)
                         .toString()));
      if (it!=_mimetypes.end()) {
        QTemporaryFile *file =
          new QTemporaryFile(QDir::tempPath()+QDir::separator()
                             +"swisssurferXXXXXX."+it->second.first, this);
        file->open();
        file->write(reply->readAll());
        file->close();
        QProcess* process(new QProcess);
        _downloadProcesses[process] = file;
        assert(connect(process, SIGNAL(finished(int, QProcess::ExitStatus)),
                       SLOT(processFinished())));
        QStringList args(it->second.second.split(" ")
                         .replaceInStrings("<FILENAME>", file->fileName()));
        QString prg(args.takeFirst());
        LOG<<"Running:"<<prg<<args.join(" ");
        process->start(prg, args);
      } else {
        QString saveFile
          (QFileDialog::getSaveFileName(this, tr("Save File As ..."),
                                        !reply->url().toLocalFile().isEmpty()
                                        ?reply->url().toLocalFile()
                                        :reply->url().path()));
        if (!saveFile.isEmpty()) {
          QFile file(saveFile);
          file.open(QIODevice::WriteOnly);
          file.write(reply->readAll());
          file.close();
        }
      }
    }

    void processFinished() {
      delete _downloadProcesses[qobject_cast<QProcess*>(sender())];
      _downloadProcesses.erase(qobject_cast<QProcess*>(sender()));
    }

    //@}
    
    void windowCloseRequested() {
      LOG;
    }
    
    //@}

    //@name                                              DownloadManager signals
    //@{

    void progress(qint64 done, qint64 total) {
      _progress->setMaximum(total);
      _progress->setValue(done);
    }

    void started() {
      actionStop->setEnabled(true);
      _progress->setRange(0, 0);
      _progress->setValue(0);
      _progress->show();
    }
        
    void finished() {
      LOG;
      actionStop->setEnabled(false);
      _progress->hide();
    }

    //@}
    
    //@name                                        QNetworkAccessManager signals
    //@{

    void authenticationRequired(QNetworkReply* reply,
                                QAuthenticator* authenticator) {
      LOG;
      statusBar()->showMessage(tr("authentication required"));
//       _error[sender()] += tr("<h2>%1</h2><p>URL: %3</p><p>%2</p>")
//         .arg(tr("Authentication Required"))
//         .arg(networkError(reply->error()))
//         .arg(reply->url().toString());
//       _errorUrl[sender()] = reply->url();
    }
    
    void proxyAuthenticationRequired(const QNetworkProxy& proxy,
                                     QAuthenticator* authenticator) {
      LOG;
    }
    
    void sslErrors(QNetworkReply* reply, const QList<QSslError>& errors) {
      LOG;
      statusBar()->showMessage(tr("ssl error"));
//       QString e;
//       for (QList<QSslError>::const_iterator err(errors.begin());
//            err!=errors.end(); ++err)
//         e+=tr("<li>%1</li>", "single ssl error").arg(err->errorString());
//       _error[sender()] += tr("<h2>%1</h2><p>URL: %4</p><p>%2</p>"
//                              "<h3>SSL Errors</h3>"
//                              "<p><ul>%3</ul></p>")
//         .arg(tr("SSL Error"))
//         .arg(networkError(reply->error()))
//         .arg(e)
//         .arg(reply->url().toString());
//       _errorUrl[sender()] = reply->url();
    }
    
    //@}

  private:

    void activateTab() {
      iconChanged();
      actionForward->setEnabled(dynamic_cast<QWebView*>(_tabs->currentWidget())
                                ->history()->canGoForward());
      actionBack->setEnabled(dynamic_cast<QWebView*>(_tabs->currentWidget())
                             ->history()->canGoBack());
    }
    
  private:
    
    QLineEdit* _url;
    QLineEdit* _find;
    QSlider* _zoom;
    QProgressBar* _progress;
    QString _home;
    bool _kiosk;
    std::map<QObject*, QString> _error;
    std::map<QObject*, QUrl> _errorUrl;
    QPrinter _printer;
    SslClientAuthNetworkAccessManager _networkManager;
    DownloadManager _downloadManager;
    typedef std::map<QProcess*, QTemporaryFile*> DownloadProcesses;
    DownloadProcesses _downloadProcesses;
    MimeTypes _mimetypes;
    
};

#endif