//
// Tizen Web Device API
// Copyright (c) 2012 Samsung Electronics Co., Ltd.
//
// Licensed 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 "FolderQueryGenerator.h"
#include "FolderFilterValidatorFactory.h"
#include "ConversationFilterValidatorFactory.h"
#include "IMessagingTypes.h"
#include "log.h"
#include <Commons/Exception.h>
#include <email-types.h>
#include <Logger.h>

using namespace std;
using namespace DeviceAPI::Tizen;

namespace DeviceAPI {
		namespace Messaging {

		const std::string FolderQueryGenerator::STRING_MATCH_EXACTLY         = "EXACTLY";
		const std::string FolderQueryGenerator::STRING_MATCH_CONTAINS        = "CONTAINS";
		const std::string FolderQueryGenerator::STRING_MATCH_STARTSWITH      = "STARTSWITH";
		const std::string FolderQueryGenerator::STRING_MATCH_ENDSWITH        = "ENDSWITH";
		const std::string FolderQueryGenerator::STRING_MATCH_EXISTS          = "EXISTS";

		const int FolderQueryGenerator::ACCOUNT_ID_NOT_INITIALIZED = -1;

		FolderQueryGenerator::FolderQueryGenerator():m_messageType(ACCOUNT_ID_NOT_INITIALIZED) {
		}

		FolderQueryGenerator::~FolderQueryGenerator() {
		}


		void FolderQueryGenerator::visitPreComposite(DeviceAPI::Tizen::FilterType& type, int depth){
			LoggerD("<<<");
		}

		void FolderQueryGenerator::visitInComposite(DeviceAPI::Tizen::FilterType& type, int depth){
			LoggerD("<<<");

			if(type != INTERSECTION_FILTER){
				LoggerE("[ERROR] >>> invalid Filter type:" << type);
				ThrowMsg(WrtDeviceApis::Commons::InvalidArgumentException, "invalid Fiilter Type");
				return;
			}
		}

		void FolderQueryGenerator::visitPostComposite(DeviceAPI::Tizen::FilterType& type, int depth){
			LoggerD("<<<");
		}

		bool FolderQueryGenerator::getMatchExactlyClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value)
		{
			std::string retClause;
			std::string valueString = value->toString();

			do{
				if(attrName.compare(FolderFilterValidatorFactory::ATTRIBUTE_ACCOUNTID)==0){
					m_accountId = atoi(value->toString().c_str());
					break;
				}else if(attrName.compare(FolderFilterValidatorFactory::ATTRIBUTE_FOLDERPATH)==0){
					m_folderPathProcessing = TRUE;				
					m_folderpath = value->toString();
					break;
				}
			}while(false);

			return FALSE;
		}

		bool FolderQueryGenerator::getMatchExistClause(std::string& attrName)
		{
			std::string retClause;

			do{
				if(attrName.compare(FolderFilterValidatorFactory::ATTRIBUTE_ACCOUNTID)==0){
					return TRUE;
				}
				else
				{
					return FALSE;
				}
			}while(false);

			return FALSE;
		}

		std::string FolderQueryGenerator::getMatchStartsWithClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value){
			std::string retClause;
			LoggerD("<<< NOT IMPLEMENTED YET");
			return retClause;
		}

		std::string FolderQueryGenerator::getMatchEndsWithClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value){
			std::string retClause;
			LoggerD("<<< NOT IMPLEMENTED YET");
			return retClause;
		}

		std::string FolderQueryGenerator::getMatchContainsClause(std::string& attrName, DeviceAPI::Tizen::AnyPtr& value){
			std::string retClause;
			LoggerD("<<< NOT IMPLEMENTED YET");
			return retClause;
		}

		void FolderQueryGenerator::visitAttribute(std::string& attrName, DeviceAPI::Tizen::MatchFlag& matchFlag,
				DeviceAPI::Tizen::AnyPtr& matchValue, int depth){
			LoggerD("<<< attrName:[" << attrName << "], matchFlag:[" << matchFlag << "]");

			if(matchValue == NULL)
				return;

			LoggerD("matchValue:" << matchValue->toString());

			visitAttributeEach(attrName, matchFlag, matchValue, depth);

			LoggerD(">>>");
		}

		void FolderQueryGenerator::visitAttributeEach(std::string& attrName, DeviceAPI::Tizen::MatchFlag& matchFlag, DeviceAPI::Tizen::AnyPtr& value, int depth){
			LoggerD("<<< attrName:[" << attrName << "], value:[" << value->toString() << "]");

			if(matchFlag == DeviceAPI::Tizen::MATCH_EXACTLY){
				LoggerD("STRING_MATCH_EXACTLY");
				getMatchExactlyClause(attrName, value);
			}else if(matchFlag == DeviceAPI::Tizen::MATCH_CONTAINS){
				LoggerD("STRING_MATCH_CONTAINS");
				getMatchContainsClause(attrName, value);
			}else if(matchFlag== DeviceAPI::Tizen::MATCH_STARTSWITH){
				LoggerD("STRING_MATCH_STARTSWITH");
				getMatchStartsWithClause(attrName, value);
			}else if(matchFlag == DeviceAPI::Tizen::MATCH_ENDSWITH){
				LoggerD("STRING_MATCH_ENDSWITH");
				getMatchEndsWithClause(attrName, value);
			}else if(matchFlag == DeviceAPI::Tizen::MATCH_EXISTS){
				LoggerD("STRING_MATCH_EXISTS");
				getMatchExistClause(attrName);
			}else{
				LoggerD("[ERROR]invalid match flag[" << matchFlag << "]");
				ThrowMsg(WrtDeviceApis::Commons::PlatformException, "invalid match flag:[" << matchFlag << "]");
			}
			LoggerD(">>>");
		}

		void FolderQueryGenerator::visitAttributeRange(std::string& attrName, DeviceAPI::Tizen::AnyPtr& initialValue, DeviceAPI::Tizen::AnyPtr& endValue, int depth) {
			LoggerD("<<< NOT IMPLEMENTED YET");
		}

		int FolderQueryGenerator::getAccountId()
		{
			return m_accountId;
		}
		
		std::string FolderQueryGenerator::getFolderPath()
		{
			return m_folderpath;
		}

		bool FolderQueryGenerator::isFolderPathExist()
		{
			LoggerE("m_folderPathProcessing : " << m_folderPathProcessing); 			
			return m_folderPathProcessing;
		}

		void FolderQueryGenerator::reset(){
			m_folderPathProcessing = FALSE;
			m_accountId = 0;
			m_folderpath.clear();
		}


	}
}