/*
 * 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.    
 */
#include "apache/das/rdb/ModifiedDataObject.h"

namespace apache {
	namespace das {
		namespace rdb {

DASDataObject::DASDataObject(const Table& table, commonj::sdo::DataObjectPtr dataObject, 
			commonj::sdo::ChangeSummaryPtr changeSummary) : PKObject(table) {
	
	commonj::sdo::SettingList* settingList = 0;
	this->changeSummary = changeSummary;
	occChecked = false;
	this->dataObject = dataObject;
	bool modifiedOnGraph = changeSummary->isDeleted(dataObject) || changeSummary->isModified(dataObject);

	if (modifiedOnGraph) {
		settingList = &changeSummary->getOldValues(dataObject);
	}

	std::map<std::string, const commonj::sdo::Setting*> settingMap;
	const std::map<std::string, const Column*> columns = table.getColumns();
	std::string statement;
	unsigned int pkColumnCount = table.getPKColumnCount();
	unsigned int pkCount = 0;

	if (modifiedOnGraph) {

		for (int i = 0 ; i < settingList->size() ; i++) {
			settingMap.insert(std::make_pair((*settingList)[i].getProperty().getName(), &(*settingList)[i]));
		}

	}

	for (std::map<std::string, const Column*>::const_iterator columnsIterator = columns.begin() ;
		columnsIterator != columns.end() && pkColumnCount > pkCount ; columnsIterator++) {
			const Column& column = *columnsIterator->second;

			if (column.isPK()) {

				if (modifiedOnGraph) {
					
					std::map<std::string, const commonj::sdo::Setting*>::const_iterator settingIterator = 
						settingMap.find(column.getPropertyName());

					if (settingIterator != settingMap.end()) {

						if (settingIterator->second->isNull() || !settingIterator->second->isSet()) {
							//throw exception
						}

						ColumnData* oldPKData = new ColumnData(column, *settingIterator->second);
						addPrimaryKey(column.getPropertyName(), 
							*(oldPKData));

						continue;

					} 

				}

				if (dataObject->isNull(column.getPropertyName()) || !dataObject->isSet(column.getPropertyName())) {
					//throw exception
				}

				addPrimaryKey(column.getPropertyName(), *(new ColumnData(column, dataObject)));

			}

	}
	
}

bool DASDataObject::isOCCChecked(void) const {
	return occChecked;
}

void DASDataObject::setOCCChecked(bool occChecked) {
	this->occChecked = occChecked;
}

long DASDataObject::getOldOCC(void) const {
	const Column* occCol = getTable().getOCCColumn();

	if (occCol != 0) {

		try {
			const commonj::sdo::Setting& setting = changeSummary->getOldValue(dataObject, *dataObject->getInstanceProperty(occCol->getPropertyName()));

			if (!setting.isNull() && setting.isSet()) {
				return setting.getIntValue();
			}

		} catch (commonj::sdo::SDOIndexOutOfRangeException&) {
			return getNewOCC();
		}

	}

	return 0;
	
}

long DASDataObject::getNewOCC(void) const {
	const Column* occCol = getTable().getOCCColumn();

	if (occCol != 0) {

		if (dataObject->isSet(occCol->getPropertyName()) && !dataObject->isNull(occCol->getPropertyName())) {
			return dataObject->getInt(occCol->getName());
		}

	}

	return 0;

}

void DASDataObject::printStmt() {
	std::cout << "[" << getTable().getTableName() << "]" << std::endl;

	for (std::list<std::string>::iterator it = updateStatements.begin() ; it != updateStatements.end() ; it++) {
		std::cout << *it << std::endl;
	}

	std::cout << std::endl;

}

DASDataObject::~DASDataObject(void) {
	
	for (std::map<std::string, RelationshipStatement*>::iterator it = fks.begin() ; it != fks.end() ; it++) {
		delete it->second;
	}

}

const commonj::sdo::DataObjectPtr DASDataObject::getDataObject(void) const {
	return dataObject;
}

std::string DASDataObject::getWhereStmt(void) const {
	std::string stmt = "where ";
	const KeyDataList& pks = getPrimaryKeys();
	unsigned int i = 1;

	for (KeyDataList::const_iterator it = pks.begin() ; it != pks.end() ; it++) {
		stmt.append(getTable().getTableName() + "." + it->second->getColumn().getName()).append("=").append(/*"2"*/it->second->toSQL());

		if (i != pks.size()) {
			stmt.append(" and ");
		}

		i++;

	}

	if (!isOCCChecked()) {
		const Column* occCol = getTable().getOCCColumn();

		if (occCol != 0) {
			stmt.append(" and ").append(occCol->getName()).append("=").append(StringWrapper::toString(getOldOCC()));
		}

	}

	return stmt;

}

std::string DASDataObject::getStatement(void) const {
	return "";
}

RelationshipStatement& DASDataObject::addFK(const Relationship& relationship, const KeyDataList* keyDataList) {
	std::map<std::string, RelationshipStatement*>::iterator it = fks.find(relationship.getName());
	RelationshipStatement* relatStmt;

	if (it == fks.end()) {
		relatStmt = new RelationshipStatement(relationship, keyDataList);
		relatStmt->setDASDataObject(*this);
		fks.insert(std::make_pair(relationship.getName(), relatStmt));

	} else if (keyDataList != 0) {
		relatStmt = it->second;
		relatStmt->setFKList(keyDataList);

	}

	return *relatStmt;

}

void DASDataObject::execute(StatementPtr stmt) {
	std::string statement = getStatement();

	if (statement != "") {
		const Column* occColumn = getTable().getOCCColumn();
		bool noData = false;
		ResultSetPtr rs;

		try {
			rs = stmt->executeQuery(statement);

		} catch (SQLException& ex) {

			if (ex.getODBCReturnCode() == SQL_NO_DATA) {
				noData = true;
			} else {
				throw;
			}

		}
		
		if (occColumn != 0 && !isOCCChecked()) {

			if (noData || rs->getRowCount() == 0) {
				throw DASOptimisticConcurrencyControlException();
			} else {
				setOCCChecked(true);
			}
			
		}

	}

	for (std::list<RelationshipStatement*>::const_iterator it = dependencies.begin() ;
		it != dependencies.end() ; it++) {

			(*it)->execute(stmt);

	}

}

void DASDataObject::addDependency(RelationshipStatement& relationshipStatement) {
	dependencies.push_back(&relationshipStatement);
}

		};
	};
};