/* This file is part of the KDE project
   Copyright (C) 2003-2007 Jaroslaw Staniek <js@iidea.pl>

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License as published by the Free Software Foundation; either
   version 2 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

#include <kexidb/fieldlist.h>
#include <kexidb/object.h>

#include <kdebug.h>

#include <assert.h>

using namespace KexiDB;

FieldList::FieldList(bool owner)
 //reasonable sizes: TODO
 : m_fields_by_name(101, false)
{
	m_fields.setAutoDelete( owner );
	m_fields_by_name.setAutoDelete( false );
	m_autoinc_fields = 0;
}

FieldList::FieldList(const FieldList& fl, bool deepCopyFields)
 : m_fields_by_name( fl.m_fields_by_name.size() )
{
	m_fields.setAutoDelete( fl.m_fields.autoDelete() );
	m_fields_by_name.setAutoDelete( false );
	m_autoinc_fields = 0;

	if (deepCopyFields) {
		//deep copy for the fields
		for (Field::ListIterator f_it(fl.m_fields); f_it.current(); ++f_it) {
			Field *f = f_it.current()->copy();
			if (f_it.current()->m_parent == &fl)
				f->m_parent = this;
			addField( f );
		}
	}
}

FieldList::~FieldList()
{
	delete m_autoinc_fields;
}

void FieldList::clear()
{
//	m_name = TQString();
	m_fields.clear();
	m_fields_by_name.clear();
	m_sqlFields = TQString();
	delete m_autoinc_fields;
	m_autoinc_fields = 0;
}

FieldList& FieldList::insertField(uint index, KexiDB::Field *field)
{
	assert(field);
	if (!field)
		return *this;
	if (index>m_fields.count()) {
		KexiDBFatal << "FieldList::insertField(): index (" << index << ") out of range" << endl;
		return *this;
	}
	if (!m_fields.insert(index, field))
		return *this;
	if (!field->name().isEmpty())
		m_fields_by_name.insert(field->name().lower(),field);
	m_sqlFields = TQString();
	return *this;
}

void FieldList::renameField(const TQString& oldName, const TQString& newName)
{
	renameField( m_fields_by_name[ oldName ], newName );
}

void FieldList::renameField(KexiDB::Field *field, const TQString& newName)
{
	if (!field || field != m_fields_by_name[ field->name() ]) {
		KexiDBFatal << "FieldList::renameField() no field found " 
			<< (field ? TQString("\"%1\"").arg(field->name()) : TQString()) << endl;
		return;
	}
	m_fields_by_name.take( field->name() );
	field->setName( newName );
	m_fields_by_name.insert( field->name(), field );
}


FieldList& FieldList::addField(KexiDB::Field *field)
{
	return insertField(m_fields.count(), field);
}

void FieldList::removeField(KexiDB::Field *field)
{
	assert(field);
	if (!field)
		return;
	m_fields_by_name.remove(field->name());
	m_fields.remove(field);
	m_sqlFields = TQString();
}

Field* FieldList::field(const TQString& name)
{
	return m_fields_by_name[name];
}

TQString FieldList::debugString()
{
	TQString dbg;
	dbg.reserve(512);
	Field::ListIterator it( m_fields );
	Field *field;
	bool start = true;
	if (!it.current())
		dbg = "<NO FIELDS>";
	for (; (field = it.current())!=0; ++it) {
		if (!start)
			dbg += ",\n";
		else
			start = false;
		dbg += "  ";
		dbg += field->debugString();
	}
	return dbg;
}

void FieldList::debug()
{
	KexiDBDbg << debugString() << endl;
}

#define _ADD_FIELD(fname) \
{ \
	if (fname.isEmpty()) return fl; \
	f = m_fields_by_name[fname]; \
	if (!f) { KexiDBWarn << subListWarning1(fname) << endl; delete fl; return 0; } \
	fl->addField(f); \
}

static TQString subListWarning1(const TQString& fname) {
	return TQString("FieldList::subList() could not find field \"%1\"").arg(fname);
}

FieldList* FieldList::subList(const TQString& n1, const TQString& n2, 
	const TQString& n3, const TQString& n4,
	const TQString& n5, const TQString& n6,
	const TQString& n7, const TQString& n8,
	const TQString& n9, const TQString& n10,
	const TQString& n11, const TQString& n12,
	const TQString& n13, const TQString& n14,
	const TQString& n15, const TQString& n16,
	const TQString& n17, const TQString& n18)
{
	if (n1.isEmpty())
		return 0;
	Field *f;
	FieldList *fl = new FieldList(false);
	_ADD_FIELD(n1);
	_ADD_FIELD(n2);
	_ADD_FIELD(n3);
	_ADD_FIELD(n4);
	_ADD_FIELD(n5);
	_ADD_FIELD(n6);
	_ADD_FIELD(n7);
	_ADD_FIELD(n8);
	_ADD_FIELD(n9);
	_ADD_FIELD(n10);
	_ADD_FIELD(n11);
	_ADD_FIELD(n12);
	_ADD_FIELD(n13);
	_ADD_FIELD(n14);
	_ADD_FIELD(n15);
	_ADD_FIELD(n16);
	_ADD_FIELD(n17);
	_ADD_FIELD(n18);
	return fl;
}

FieldList* FieldList::subList(const TQStringList& list)
{
	Field *f;
	FieldList *fl = new FieldList(false);
	for(TQStringList::ConstIterator it = list.constBegin(); it != list.constEnd(); ++it) {
		_ADD_FIELD( (*it) );
	}
	return fl;
}

FieldList* FieldList::subList(const TQValueList<uint>& list)
{
	Field *f;
	FieldList *fl = new FieldList(false);
	foreach(TQValueList<uint>::ConstIterator, it, list) {
		f = field(*it);
		if (!f) {
			KexiDBWarn << TQString("FieldList::subList() could not find field at position %1").arg(*it) << endl;
			delete fl;
			return 0;
		}
		fl->addField(f);
	}
	return fl;
}

TQStringList FieldList::names() const
{
	TQStringList r;
//	for (TQDictIterator<Field> it(m_fields_by_name);it.current();++it) {
//		r += it.currentKey().lower();
//	}
	for (Field::ListIterator it(m_fields); it.current(); ++it) {
		r += it.current()->name().lower();
	}
	return r;
}

//static
TQString FieldList::sqlFieldsList(Field::List* list, Driver *driver, 
	const TQString& separator, const TQString& tableAlias, int drvEscaping)
{
	if (!list)
		return TQString();
	TQString result;
	result.reserve(256);
	bool start = true;
	const TQString tableAliasAndDot( tableAlias.isEmpty() ? TQString() : (tableAlias + ".") );
	for (Field::ListIterator it( *list ); it.current(); ++it) {
		if (!start)
			result += separator;
		else
			start = false;
		result += (tableAliasAndDot + driver->escapeIdentifier( it.current()->name(), drvEscaping ));
	}
	return result;
}

TQString FieldList::sqlFieldsList(Driver *driver, 
	const TQString& separator, const TQString& tableAlias, int drvEscaping)
{
	if (!m_sqlFields.isEmpty())
		return m_sqlFields;

	m_sqlFields = FieldList::sqlFieldsList( &m_fields, driver, separator, tableAlias, drvEscaping );
	return m_sqlFields;
}

Field::List* FieldList::autoIncrementFields()
{
	if (!m_autoinc_fields) {
		m_autoinc_fields = new Field::List();
		Field *f;
		for (Field::ListIterator f_it(m_fields); (f = f_it.current()); ++f_it) {
			if (f->isAutoIncrement()) {
				m_autoinc_fields->append( f_it.current() );
			}
		}
	}
	return m_autoinc_fields;
}