/***************************************************************************
 * $Id: tork.cpp,v 1.160 2007/12/30 12:58:22 hoganrobert Exp $
 *   Copyright (C) 2006 by Robert Hogan                                    *
 *   robert@roberthogan.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 WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  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 St, Fifth Floor, Boston, MA 02110-1301, USA.              *
 ***************************************************************************/

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif


#include <qcstring.h>
#include <qsocket.h>
#include <qdatetime.h>
#include <qbitarray.h>

#include <stdlib.h>
#include <math.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>

#include <kapplication.h>
#include <kdebug.h>
#include <kmessagebox.h>
#include <kinstance.h>
#include <kglobal.h>
#include <kstandarddirs.h>
#include <klocale.h>
#include <kurl.h>
#include <ksock.h>

#include "app.h"

using namespace KIO;

extern "C"
{
    int kdemain(int argc, char **argv)
    {
        KInstance instance( "kio_app" );
        
        kdDebug(7101) << "*** Starting kio_app " << endl;
        
        if (argc != 4) {
            kdDebug(7101) << "Usage: kio_app  protocol domain-socket1 domain-socket2" << endl;
            exit(-1);
        }
        
        kio_appProtocol slave(argv[2], argv[3]);
        slave.dispatchLoop();
        
        kdDebug(7101) << "*** kio_app Done" << endl;
        return 0;
    }
} 


kio_appProtocol::kio_appProtocol(const QCString &pool_socket, const QCString &app_socket)
    : SlaveBase("kio_app", pool_socket, app_socket)
{
    kdDebug() << "kio_appProtocol::kio_appProtocol()" << endl;
}


kio_appProtocol::~kio_appProtocol()
{
    kdDebug() << "kio_appProtocol::~kio_appProtocol()" << endl;
}


void kio_appProtocol::stat(const KURL &url)
{
	kdDebug() << "kio_appProtocol::stat: " << url << endl;

	QString path = url.path();
	if ( path.isEmpty() || path == "/" )
	{
    	kdDebug() << "kio_appProtocol::stat: " << "creating top level entry" << endl;
		// The root is "virtual" - it's not a single physical directory
		KIO::UDSEntry entry;
		m_impl.createTopLevelEntry( entry );
		statEntry( entry );
		finished();
		return;
	}

	QString name;
	bool ok = m_impl.parseURL(url, name, path);

	if ( !ok )
	{
    	kdDebug() << "kio_appProtocol::stat: " << "can't parse url" << endl;
		error(KIO::ERR_MALFORMED_URL, url.prettyURL());
		return;
	}


	if( path.isEmpty() )
	{
    	kdDebug() << "kio_appProtocol::stat4: " << "url empty after parsing" << endl;

		KIO::UDSEntry entry;

		if ( m_impl.statByName(name, entry) )
		{
			statEntry(entry);
			finished();
		}
		else
		{
			error(KIO::ERR_DOES_NOT_EXIST, url.prettyURL());
		}
	}
	else
	{
    	kdDebug() << "kio_appProtocol::stat4: " << "url not empty after parsing: statting" << endl;
		SlaveBase::stat(url);
	}
}

void kio_appProtocol::listDir(const KURL &url)
{
	kdDebug() << "kio_appProtocol::listDir: " << url << endl;

	if ( url.path().length() <= 1 )
	{
    	kdDebug() << "kio_appProtocol::listDir: " << "url empty: listing root" << endl;
		listRoot();
		return;
	}

	QString name, path;
	bool ok = m_impl.parseURL(url, name, path);

	if ( !ok )
	{
		error(KIO::ERR_MALFORMED_URL, url.prettyURL());
		return;
	}

	kdDebug() << "kio_appProtocol::listDir: " << "url is " << url << ": doing a listDir" << endl;
	kdDebug() << "kio_appProtocol::listDir: " << "name is " << name << ": doing a listDir" << endl;
    kdDebug() << "kio_appProtocol::listDir: " << "path is " << path << ": doing a listDir" << endl;
    // We've been given something like app:/appname
	listAppContents(name);
}

void kio_appProtocol::listRoot()
{
	KIO::UDSEntry entry;

	KIO::UDSEntryList system_entries;
	bool ok = m_impl.listRoot(system_entries);

	if (!ok)
	{
		error( m_impl.lastErrorCode(), m_impl.lastErrorMessage() );
		return;
	}

	totalSize(system_entries.count()+1);

	m_impl.createTopLevelEntry(entry);
	listEntry(entry, false);

	KIO::UDSEntryListIterator it = system_entries.begin();
	KIO::UDSEntryListIterator end = system_entries.end();

	for(; it!=end; ++it)
	{
		listEntry(*it, false);
	}

	entry.clear();
	listEntry(entry, true);

	finished();
}


void kio_appProtocol::listAppContents(const QString &name)
{
	KIO::UDSEntry entry;

	KIO::UDSEntryList app_entries;
	bool ok = m_impl.listAppContents(name, app_entries);

	if (!ok)
	{
		error( m_impl.lastErrorCode(), m_impl.lastErrorMessage() );
		return;
	}

	totalSize(app_entries.count()+1);

	m_impl.createTopLevelEntry(entry);
	listEntry(entry, false);

	KIO::UDSEntryListIterator it = app_entries.begin();
	KIO::UDSEntryListIterator end = app_entries.end();

	for(; it!=end; ++it)
	{
		listEntry(*it, false);
	}

	entry.clear();
	listEntry(entry, true);

	finished();

}