/*
 * This file is part of the KFTPGrabber project
 *
 * Copyright (C) 2003-2004 by the KFTPGrabber developers
 * Copyright (C) 2003-2004 Jernej Kos <kostko@jweb-network.net>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * is provided AS IS, WITHOUT ANY WARRANTY; without even the implied
 * warranty of MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, and
 * NON-INFRINGEMENT.  See the GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Steet, Fifth Floor, Boston,
 * MA 02110-1301, USA.
 *
 * In addition, as a special exception, the copyright holders give
 * permission to link the code of portions of this program with the
 * OpenSSL library under certain conditions as described in each
 * individual source file, and distribute linked combinations
 * including the two.
 * You must obey the GNU General Public License in all respects
 * for all of the code used other than OpenSSL.  If you modify
 * file(s) with this exception, you may extend this exception to your
 * version of the file(s), but you are not obligated to do so.  If you
 * do not wish to do so, delete this exception statement from your
 * version.  If you delete this exception statement from all source
 * files in the program, then also delete it here.
 */

#ifndef KFTPSESSION_H
#define KFTPSESSION_H

#include <tqobject.h>
#include <tqguardedptr.h>
#include <tqdom.h>

#include <tqlistview.h>

#include "kftpqueue.h"
#include "logview.h"
#include "kftptabwidget.h"

#include "engine/thread.h"

namespace KFTPWidgets {
  namespace Browser {
    class Actions;
    class View;
  }
}

namespace KFTPBookmarks {
  class Site;
}

namespace KFTPSession {

class Session;

enum Side {
  LeftSide,
  RightSide,
  IgnoreSide
};

#define oppositeSide(x) (x == KFTPSession::LeftSide ? KFTPSession::RightSide : KFTPSession::LeftSide)

/**
 * The Connection class represents a session's connection to a ftp server. There
 * can be many connections in the same session (to the same server), thus providing
 * support for multiple threads at once.
 *
 * Individual transfers must acquire connections before they can use them. When a
 * connection is acquired it cannot be used by another transfer or another remote
 * operation.
 *
 * @author Jernej Kos
 */
class Connection : public TQObject
{
Q_OBJECT
public:
    /**
     * Class constructor.
     *
     * @param session The parent session
     * @param primary Set to true if this is session's primary connection
     */
    Connection(Session *session, bool primary = false);
    
    /**
     * Class destructor.
     */
    ~Connection();

    /**
     * Returns the client thread for this connection.
     *
     * @return A KFTPClientThr object representing a client.
     */
    KFTPEngine::Thread *getClient() const { return m_client; }
    
    /**
     * Returns the URL this connection is connected to.
     *
     * @return A KURL this connection is connected to.
     */
    KURL getUrl() { return m_client->socket()->getCurrentUrl(); }

    /**
     * Returns the current transfer if this connection is locked by one. If
     * it isn't locked NULL will be returned.
     */
    KFTPQueue::Transfer *getTransfer() const { return m_curTransfer; }

    /**
     * Lock this connection for a specific transfer. While the connection is
     * locked no other transfer may use it. The connection will be automaticly
     * unlocked when the transfer completes.
     *
     * @param transfer The transfer which is locking this connection.
     */
    void acquire(KFTPQueue::Transfer *transfer);

    /**
     * Clear existing connection lock. Only the transfer who locked the connection
     * should do this!
     */
    void remove();

    /**
     * Abort any actions going via this connection. It will call abort on the
     * underlying client and emit the aborting signal.
     */
    void abort();
    
    /**
     * Connect to the previously connected URL. If this connection is already
     * established this method does nothing.
     */
    void reconnect();

    /**
     * Is the current connection locked by some transfer ?
     *
     * @return Returns true if the current connection is locked, false otherwise.
     */
    bool isBusy() const { return m_busy; }

    /**
     * Is the current connection actually connected to a server ?
     *
     * @return Returns true if a connection to a server is established.
     */
    bool isConnected();
    
    /**
     * Is the current connection the primary session connection ?
     *
     * @return Returns true if the current connection is primary, false otherwise
     */
    bool isPrimary() const { return m_primary; }
    
    /**
     * Scans a directory - usually called from KFTPSession for remote scans.
     *
     * @param parent The transfer that requested the scan
     */
    void scanDirectory(KFTPQueue::Transfer *parent);
private:
    void addScannedDirectory(KFTPEngine::DirectoryTree *tree, KFTPQueue::Transfer *parent);    
private:
    bool m_primary;
    bool m_busy;
    bool m_aborting;
    bool m_scanning;

    TQGuardedPtr<KFTPQueue::Transfer> m_curTransfer;
    KFTPEngine::Thread *m_client;
private slots:
    void slotTransferCompleted();
    
    void slotEngineEvent(KFTPEngine::Event *event);
signals:
    /**
     * This signal gets emitted when the connection is acquired for exclusive
     * use by a transfer.
     */
    void connectionAcquired();
    
    /**
     * This signal gets emitted when connection is returned to the pool and is
     * no longer locked.
     */
    void connectionRemoved();
    
    /**
     * This signal gets emitted when the connection is lost.
     *
     * @param connection This connection instance
     */
    void connectionLost(KFTPSession::Connection *connection);
    
    /**
     * This signal gets emitted when connection with the remote server is
     * established.
     */
    void connectionEstablished();

    /**
     * This signal gets emitted when this connection is in the process of
     * aborting any currently running operations.
     */
    void aborting();
};

/**
 * A Session instance connects all the relevant elements together. Via the
 * manager this abstraction allows many independent sessions inside one
 * applications.
 *
 * Each session can either be local or remote. A remote session can have
 * multiple connections open (each connection is represented by a Connection
 * instance).
 *
 * @author Jernej Kos
 */
class Session : public TQObject
{
Q_OBJECT
friend class KFTPWidgets::Browser::Actions;
friend class Manager;
friend class Connection;
public:
    /**
     * Class constructor.
     *
     * @param side The side the session should be located on
     */
    Session(Side side);
    
    /**
     * Class destructor.
     */
    ~Session();
    
    /**
     * Has the session registration procedure already been completed ?
     *
     * @return True if the registration procedure has been completed, false otherwise
     */
    bool isRegistred() const { return m_registred; }

    /**
     * Is this a remote session ?
     *
     * @return Returns true if this is a remote session.
     */
    bool isRemote() const { return m_remote; }

    /**
     * Is this session currently active (=visible to the user) ?
     *
     * @return Returns true if this session is currently active.
     */
    bool isActive() const { return m_active; }

    /**
     * Is this session currently connected to a server ? This actually checks if
     * the primary connection is connected to a server.
     *
     * @return Returns true if this session is connected to a server.
     */
    bool isConnected();

    /**
     * Get the site in bookmarks this session is asociated with or NULL if there
     * is no such site.
     *
     * @return Returns the asociated bookmarks site.
     */
    KFTPBookmarks::Site *getSite() const { return m_site; }

    /**
     * Get the session's client thread. This actually returns the client thread
     * of the primary session's connection.
     *
     * @return A KFTPEngine::Thread object representing a client.
     */
    KFTPEngine::Thread *getClient();

    /**
     * Get this session's log widget.
     *
     * @return Returns the session's log widget.
     */
    KFTPWidgets::LogView *getLog() const { return m_log; }

    /**
     * Get this session's file view.
     *
     * @return Returns the session's file view.
     */
    KFTPWidgets::Browser::View *getFileView() const { return m_fileView; }

    /**
     * Get the side on which this session is located.
     *
     * @return Returns the session's side.
     */
    Side getSide() const { return m_side; }

    /**
     * Set bookmark site asociation.
     *
     * @param site A valid site to which this session is asociated.
     */
    void setSite(KFTPBookmarks::Site *site) { m_site = site; }

    /**
     * Are there any free connections (or if some new can be created) to lock ?
     *
     * @return Returns true if there is a connection that can be locked.
     */
    bool isFreeConnection();

    /**
     * Assigns a free connection if there is one. A connection can be created if
     * the limit hasn't yet been reached. If there are no free connections this
     * method returns NULL.
     *
     * @return A free Connection or NULL if there is none.
     */
    Connection *assignConnection();

    /**
     * Disconnects all connections for this session.
     */
    void disconnectAllConnections();

    /**
     * Get the list of current connections for this session.
     *
     * @return A list of current connections.
     */
    TQPtrList<Connection> *getConnectionList() { return &m_connections; }

    /**
     * Reconnect to a new URL. The current connections will be droped and reconnected
     * to the new URL.
     *
     * @param url The URL to connect to.
     */
    void reconnect(const KURL &url);

    /**
     * Abort this session. This will actually call abort on all connections for
     * this session.
     */
    void abort();

    /**
     * Initiate a directory scan, adding all new files and directories under the
     * transfer specified as parent. This method will change the current transfer's
     * status to Locked and will return imediately. The actual scan will take
     * place in a separate thread.
     *
     * @param parent The transfer which requested the scan
     * @param connection An optional connection to use
     */
    void scanDirectory(KFTPQueue::Transfer *parent, Connection *connection = 0);
private:
    Side m_side;
    bool m_remote;
    bool m_active;
    bool m_aborting;
    bool m_registred;

    // Session description
    KFTPBookmarks::Site *m_site;
    KFTPWidgets::LogView *m_log;
    KFTPWidgets::Browser::View *m_fileView;
    KURL m_lastUrl;
    KURL m_reconnectUrl;

    // Connection list
    TQPtrList<Connection> m_connections;

    int getMaxThreadCount();
private slots:
    void slotClientEngineEvent(KFTPEngine::Event *event);
    void slotStartReconnect();
signals:
    void dirScanDone();
    void aborting();

    void freeConnectionAvailable();
};

typedef TQPtrList<Session> SessionList;

/**
 * The Manager class provides access to sessions, their registration and deletion.
 *
 * @author Jernej Kos
 */
class Manager : public TQObject
{
Q_OBJECT
public:
    /**
     * Get a global manager instance.
     */
    static Manager *self();
    
    /**
     * Class constructor.
     *
     * @param parent Parent object
     * @param stat A widget that contains log tabs
     * @param left A widget that contains sessions on the left side
     * @param right A widget that contains sessions on the right side
     */
    Manager(TQObject *parent, TQTabWidget *stat, KFTPTabWidget *left, KFTPTabWidget *right);

    /**
     * Spawn a new local (=unconnected) session. This method may reuse an old local session.
     *
     * @param side The side on which the session should be created.
     * @param forceNew Should a new session be created if a similar session already exists.
     * @return Allways returns a valid session.
     */
    Session *spawnLocalSession(Side side, bool forceNew = false);

    /**
     * Spawn a new remote session. This method may reuse an old remote session. It may also
     * spawn a new local session if the URL appears local.
     *
     * @param side The side on which the session should be created.
     * @param remoteUrl URL to which the session should connect upon creation.
     * @param site The bookmarked site the session is connecting to.
     * @param mustUnlock Must the returned session be unlocked ?
     * @return Allways returns a valid session.
     */
    Session *spawnRemoteSession(Side side, const KURL &remoteUrl, KFTPBookmarks::Site *site = 0, bool mustUnlock = false);

    /**
     * Register a new session with the session manager. Every session calls this method in
     * its constructor to init the session - this method shouldn't be called otherwise.
     *
     * @param session A new session.
     */
    void registerSession(Session *session);

    /**
     * Destroy the session. All connections and transfers related to this session are
     * aborted and disconnected first.
     *
     * @param session The session that is going to be destroyed.
     */
    void unregisterSession(Session *session);
    
    /**
     * Disconnects all sessions and their connections.
     */
    void disconnectAllSessions();

    /**
     * Find a session related to a client thread.
     *
     * @param client The client thread related to a session.
     * @return Returns a valid session if one is found, NULL otherwise.
     */
    Session *find(KFTPEngine::Thread *client);

    /**
     * Find a session related to a file view widget.
     *
     * @param fileView The file view widget related to a session.
     * @return Returns a valid session if one is found, NULL otherwise.
     */
    Session *find(KFTPWidgets::Browser::View *fileView);

    /**
     * Find a session related to a log widget.
     *
     * @param log The log widget related to a session.
     * @return Returns a valid session if one is found, NULL otherwise.
     */
    Session *find(KFTPWidgets::LogView *log);

    /**
     * Find a session by the url it is connected to.
     *
     * @param url The URL a session is connected to.
     * @param mustUnlock Must the session be unlocked ?
     * @return Returns a valid session if one is found, NULL otherwise.
     */
    Session *find(const KURL &url, bool mustUnlock = false);

    /**
     * Finds a session by its state (remote/local).
     *
     * @param local Must a session be local ?
     * @return Returns a valid session if one is found, NULL otherwise.
     */
    Session *find(bool local);

    /**
     * Finds a session that was last connected to a specific URL that is placed
     * on a specific side.
     *
     * @param url The URL to which the session was connected to.
     * @param side The side where the session must be.
     * @return Returns a valid session if one is found, NULL otherwise.
     */
    Session *findLast(const KURL &url, Side side);

    /**
     * Get the list of all sessions in existance.
     *
     * @return The session list.
     */
    SessionList *getSessionList() { return &m_sessionList; }

    /**
     * Emits the update signal.
     */
    void doEmitUpdate();

    /**
     * Returns the tab widget that holds the log widgets.
     *
     * @return Returns a TQTabWidget that holds the log widgets.
     */
    TQTabWidget *getStatTabs() const { return m_statTabs; }

    /**
     * Returns the tab widget that holds the sessions on a specific side.
     *
     * @param side The side of the tab widget.
     * @return Returns a KFTPTabWidget that holds the sessions.
     */
    KFTPTabWidget *getTabs(Side side);

    /**
     * Make a session active (=visible to the user).
     *
     * @param session Session to be made active.
     */
    void setActive(Session *session);

    /**
     * Get the active session on a specific side.
     *
     * @param side The side where the session is active.
     * @return Returns a valid session.
     */
    Session *getActive(Side side);
    
    /**
     * Get the currently active view.
     *
     * @return The active view instance
     */
    KFTPWidgets::Browser::View *getActiveView();
    
    /**
     * Get the currently active session.
     */
    Session *getActiveSession();
protected:
    static Manager *m_self;
    
    /**
     * Event filter handler.
     */
    bool eventFilter(TQObject *object, TQEvent *event);
    
    /**
     * Change the currently active session to the browser view inheriting
     * the passed object.
     *
     * @param object The object that has browser view as some parent
     */
    void switchFocusToObject(const TQObject *object);
private:
    SessionList m_sessionList;

    // These variables should be assigned right after construction
    TQTabWidget *m_statTabs;
    KFTPTabWidget *m_leftTabs;
    KFTPTabWidget *m_rightTabs;

    // Currently active sessions
    Session *m_active;
    Session *m_leftActive;
    Session *m_rightActive;
private slots:
    void slotActiveChanged(TQWidget *page);
    void slotSwitchFocus();
public slots:
    void slotSessionCloseRequest(TQWidget *page);
signals:
    void update();
};

}

#endif
