/*
 * ModuleParameter.cpp
 *
 *  Created on: 2011-4-29
 *      Author: dev
 */
#include "ModuleParameter.h"
#include "Algorithm.h"
// #include "json/json.h"
#include "Utils.h"
// #include "Log.h"
// #include "error.h"

#include <iostream>
#include <cassert>
using namespace std;
using namespace pai::utils;
namespace pai {
namespace module {

CModuleParameter::CModuleParameter():
		workflow_id(""), local_tmp_dir(""), hdfs_tmp_dir(""), m_rootParameterItem(), m_strClass(""), m_importPath("")
{
	// TODO Auto-generated constructor stub
}

CModuleParameter::CModuleParameter(const CModuleParameter& srcParameter):
		workflow_id(srcParameter.workflow_id), local_tmp_dir(srcParameter.local_tmp_dir), hdfs_tmp_dir(srcParameter.hdfs_tmp_dir),
		m_rootParameterItem(srcParameter.m_rootParameterItem), m_strClass(srcParameter.m_strClass), m_importPath(srcParameter.m_importPath)
{

}

CModuleParameter::~CModuleParameter() {
//	cout << "detor in ModuleParameter " << endl;
}

void CModuleParameter::Clone(const CModuleParameter& srcParameter)
{
   if(&srcParameter != this)
   {
	   workflow_id = srcParameter.workflow_id;
	   local_tmp_dir = srcParameter.local_tmp_dir;
	   hdfs_tmp_dir = srcParameter.hdfs_tmp_dir;
	   m_rootParameterItem = srcParameter.m_rootParameterItem;
	   //REMOVEME
	   m_strClass = srcParameter.m_strClass;
   }
}

bool CModuleParameter::operator==(const CModuleParameter& otherParameter) const
{
    if(m_rootParameterItem == otherParameter.m_rootParameterItem &&
    		local_tmp_dir == otherParameter.local_tmp_dir &&
    		hdfs_tmp_dir == otherParameter.hdfs_tmp_dir &&
    		workflow_id == otherParameter.workflow_id &&
    		m_strClass == otherParameter.m_strClass &&
    		m_importPath == otherParameter.m_importPath) {
    	return true;
    }
	return false;
}

void CModuleParameter::AddParameterItem(const CParameterItem& item)
{
    m_rootParameterItem.AddParameterItem(item);
}
void CModuleParameter::AddParameterItem(QString& paramId,const pai::module::ParameterType paramType,const std::string& paramStringValue)
{
	CParameterItem  paramItem ;
	paramItem.SetId(paramId.toStdString());
	paramItem.SetName(paramId);
	paramItem.SetType(paramType);
	paramItem.SetStringValue(paramStringValue);
	this->AddParameterItem(paramItem);
}

void CModuleParameter::AddParameterItem(const std::string& paramId,const pai::module::ParameterType paramType,const std::string& paramStringValue)
{
	CParameterItem  paramItem ;
	paramItem.SetId(paramId);
	paramItem.SetName(paramId);
	paramItem.SetType(paramType);
	paramItem.SetStringValue(paramStringValue);
	this->AddParameterItem(paramItem);

}

void CModuleParameter::RemoveParameterItem(const std::string& paramId)
{
	m_rootParameterItem.RemoveParameterItem(paramId);
}

CParameterItem* CModuleParameter::GetParameterItem(const std::string& strItemName)
{
	return m_rootParameterItem.GetParameterItem(strItemName);
}

int CModuleParameter::GetParameterItemCount() const
{
	return m_rootParameterItem.GetChildCount();
}

int CModuleParameter::GetParamItemIndex(const std::string& strItemName) const
{
    for(int i=0; i< m_rootParameterItem.GetChildCount(); ++i)
    {
        CParameterItem* pItem = m_rootParameterItem.GetParameterItem(i);
		if(pItem!=NULL && pItem->GetName().toStdString()==strItemName)
		{
			return i;
		}
	}
    std::stringstream errorMsg;
	errorMsg <<"\n\t "<< __FILE__ << ":" << __LINE__<< "\t the warn information:" << std::endl
		<< "\t The child parameter named "<<strItemName<<"  not exists in the following parameter "<< m_rootParameterItem.GetName().toStdString()<< std::endl;
    // pai::log::Warn(errorMsg.str());
	return -1;
}

CParameterItem* CModuleParameter::GetParameterItem(int iIndex)
{
	return m_rootParameterItem.GetParameterItem(iIndex);
}

std::vector<CParameterItem> CModuleParameter::GetParameterItems() const
{
	std::vector<CParameterItem> vecResultItems;
//	for(int i=0; i< m_rootParameterItem.GetChildCount(); ++i)
//	{
//	    CParameterItem* pItem = m_rootParameterItem.GetParameterItem(i);
//	    if(pItem->GetType() == CUSTOM)
//	    {
//	        CCompositeParameterItem* pChildItem = dynamic_cast<CCompositeParameterItem*>(pItem);
//	        if(pChildItem != NULL)
//	        {
//	            CParameterItem* pConvertedItem = CCompositeParameterItem::ConvergentToCParameterItemAsNewInstance(pChildItem);
//	            vecResultItems.push_back(*(pConvertedItem));
//	            delete pConvertedItem;
//	            pConvertedItem=NULL;
//	        }
//	    }
//	    else
//	    {
//	        vecResultItems.push_back(*(pItem));
//	    }
//	}
	m_rootParameterItem.GetAllLeafParameterItems(vecResultItems);
	return vecResultItems;
}

void CModuleParameter::GetCategoryNames(std::vector<std::string>& vecCategoryNames)
{
    m_rootParameterItem.GetCategoryNames(vecCategoryNames);
}

std::vector<CParameterItem*> CModuleParameter::GetParameterItemsByCategory(const std::string& strCategory) const
{
    return m_rootParameterItem.GetParameterItemsByCategory(strCategory);
}

CCompositeParameterItem* CModuleParameter::GetRootParameterItem() const
{
    return const_cast<CCompositeParameterItem*>(&m_rootParameterItem);
}

// void CModuleParameter::LoadFromJson(const Json::Value& root,bool bAmendID)
// {
// 	Json::Value vParams = root["Params"];
// 	if(!vParams.isNull())
// 	{
// 		//TODO:test
// 		//pModuleParam = new CModuleParameter();
//         for(unsigned int i=0; i<vParams.size(); i++)
//         {
//             _LoadFromJson(vParams[i],this->GetRootParameterItem(),bAmendID);
//         }
// 	}
// }

// void CModuleParameter::SaveToJson(Json::Value& root)
// {
//     Json::Value vParams;

//     CCompositeParameterItem* pParentItem = this->GetRootParameterItem();
//     if (NULL == pParentItem)
//     {
//     	std::stringstream errorMsg;
// 		errorMsg <<"\n\t "<< __FILE__ << ":" << __LINE__<< "\t the error information:" << std::endl
// 			<< "\t CModuleParameter SaveToJson() save json error!"<< std::endl
// 			<< "\t The pParentItem is NULL"<<std::endl
// 			<< "\t Please ask Workflow team for help!"<<std::endl;
// 		pai::log::Error(errorMsg.str());
// 		throw pai::error::runtime_error(errorMsg.str());
//     }
//     for(int i=0; i<pParentItem->GetChildCount(); i++)
//     {
//         Json::Value vParam;
//         _SaveToJson(vParam,pParentItem->GetParameterItem(i));
//         vParams.append(vParam);
//     }

//     root["Params"] = vParams;
// }
// void CModuleParameter::_LoadFromJson(const Json::Value& paramJsonNode, CCompositeParameterItem* pParentItem,bool bAmendID)
// {
//     if(pParentItem == NULL)
//     {
//     	std::stringstream errorMsg;
// 		errorMsg <<"\n\t "<< __FILE__ << ":" << __LINE__<< "\t the error information:" << std::endl
// 			<< "\t CModuleParameter _LoadFromJson() load json error!"<< std::endl
// 			<< "\t The pParentItem is NULL"<<std::endl
// 			<< "\t Please ask Workflow team for help!"<<std::endl;
//         // pai::log::Error(errorMsg.str());
//         // throw pai::error::runtime_error(errorMsg.str());
//     }
//     CParameterItem* pItem = NULL;
//     if(paramJsonNode["ParameterType"].isString())
//     {
//         //把小写全部转化成大写字符串
//         std::string strType = paramJsonNode["ParameterType"].asString();
//         for(string::iterator iter=strType.begin(); iter!=strType.end(); ++iter)
//         {
//             if(islower(int(*iter)))  *iter = char(toupper(int(*iter)));
//         }
//         if(strType == "CUSTOM" || strType == "ARRAY")
//         {
//             pItem = new CCompositeParameterItem();
//         }
//         else
//         {
//             pItem = new CParameterItem();
//         }
//         //设置ParameterType
//         pItem->SetType(pItem->GetTypeMap()[strType]);
//     }
//     if(pItem == NULL)
// 	{
// 		std::stringstream errorMsg;
// 		errorMsg <<"\n\t "<< __FILE__ << ":" << __LINE__<< "\t the error information:" << std::endl
// 			<< "\t CModuleParameter _LoadFromJson() save json error!"<< std::endl
// 			<< "\t The pItem is NULL"<<std::endl
// 			<< "\t Please ask Workflow team for help!"<<std::endl;
// 		pai::log::Error(errorMsg.str());
// 		throw pai::error::runtime_error(errorMsg.str());
// 	}
//     CParameterItem& parameterItem = *pItem;
//     if(paramJsonNode["Default"].isString())
//         parameterItem.SetStringValue(paramJsonNode["Default"].asString());
//     if(paramJsonNode["Default"].isString())
//         parameterItem.SetDefault(paramJsonNode["Default"].asString());
//     if(paramJsonNode["ParameterID"].isString())
//         parameterItem.SetId(paramJsonNode["ParameterID"].asString());
//     if(paramJsonNode["ParameterName"].isString())
//         parameterItem.SetName(paramJsonNode["ParameterName"].asString());
//     if(!paramJsonNode["Value"].isNull())
//         parameterItem.SetStringValue(paramJsonNode["Value"].asString());
//     if(paramJsonNode["ParameterInputType"].isString())
//     {
//         //把小写全部转化成大写字符串
//         std::string strInType = paramJsonNode["ParameterInputType"].asString();
//         for(string::iterator iter=strInType.begin(); iter!=strInType.end(); ++iter)
//         {
//             if(islower(int(*iter)))  *iter = char(toupper(int(*iter)));
//         }
//         //设置ParameterType
//         parameterItem.SetInputType(parameterItem.GetInputTypeMap()[strInType]);
//         if (!m_importPath.empty() && !paramJsonNode["Value"].isNull() && !paramJsonNode["Value"].asString().empty() && (parameterItem.GetInputType() == HDFSFILEEDITOR))
// 		{
// 			parameterItem.SetStringValue(m_importPath + paramJsonNode["Default"].asString());
// 		}

//     }
//     if(paramJsonNode["ParameterAcceptDropTypes"].isString())
//     {
//         //把小写全部转化成大写字符串
//         std::string strDropTypes = paramJsonNode["ParameterAcceptDropTypes"].asString();
//         for(string::iterator iter=strDropTypes.begin(); iter!=strDropTypes.end(); ++iter)
//         {
//             if(islower(int(*iter)))  *iter = char(toupper(char(*iter)));
//         }
//         //设置ParameterAccepDropTypes
//         std::vector<std::string> vecAcceptDropTypes;
//         SplitByChar(strDropTypes,';',vecAcceptDropTypes);
//         for(size_t i=0; i<vecAcceptDropTypes.size(); ++i)
//         {
//         	if(!vecAcceptDropTypes[i].empty())
//         	{
//         		parameterItem.AddAcceptDropType(parameterItem.GetAcceptDropTypeMap()[vecAcceptDropTypes[i]]);
//         	}
//         }
//    }
//     if(paramJsonNode["ParameterInputMetaData"].isString())
//     {
//         parameterItem.SetInputMetaData(paramJsonNode["ParameterInputMetaData"].asString());
//     }
//     if(paramJsonNode["ParameterInputData"].isString())
//     {
//         parameterItem.SetInputData(paramJsonNode["ParameterInputData"].asString());
//     }
//     if(paramJsonNode["ParameterSet"].isString() && paramJsonNode["ParameterSet"].asString()!="")//对于Meta.json中将参数分类置为空的参数项，采用缺省分类"General"
//         parameterItem.SetCategory(paramJsonNode["ParameterSet"].asString());
//     if(paramJsonNode["UpLimit"].isString())
//         parameterItem.SetMax(paramJsonNode["UpLimit"].asString());
//     if(paramJsonNode["LowerLimit"].isString())
//         parameterItem.SetMin(paramJsonNode["LowerLimit"].asString());
//     if(paramJsonNode["Optional"].isString())
//     {
//     	bool bOptional = false;
//     	std::string strOptional = paramJsonNode["Optional"].asString();
//     	if(strOptional=="TRUE" || strOptional=="True" || strOptional=="true" || strOptional=="1")
//     	{
//     		bOptional = true;
//     	}
//         parameterItem.SetIsNessary(!bOptional);
//     }
//     else
//     {
//         if(paramJsonNode["Optional"].isBool())
//             parameterItem.SetIsNessary(!(paramJsonNode["Optional"].asBool()));
//     }

//     if(paramJsonNode["ParameterDesc"].isString())
//         parameterItem.SetDescription(paramJsonNode["ParameterDesc"].asString());

//     if(paramJsonNode["InOut"].isString())
//             parameterItem.SetInOut(paramJsonNode["InOut"].asString());
//     if(paramJsonNode["DataType"].isString())
//             parameterItem.SetDataType(paramJsonNode["DataType"].asString());
//     if(paramJsonNode["DisplayValue"].isString())
//             parameterItem.SetDisplayValue(paramJsonNode["DisplayValue"].asString());


//     Json::Value vParams = paramJsonNode["Params"];
//     if(!vParams.isNull())
//     {
//         for(unsigned int i=0; i<vParams.size(); i++)
//         {
//             _LoadFromJson(vParams[i],dynamic_cast<CCompositeParameterItem*>(pItem),bAmendID);
//         }
//     }
//     pParentItem->AddParameterItem(parameterItem,bAmendID);

//     delete pItem;
//     pItem = NULL;
// }

// void CModuleParameter::_SaveToJson(Json::Value& paramJsonNode, CParameterItem* pItem)
// {
//     if(pItem == NULL)
//     {
//     	std::stringstream errorMsg;
// 		errorMsg <<"\n\t "<< __FILE__ << ":" << __LINE__<< "\t the error information:" << std::endl
// 			<< "\t CModuleParameter _SaveToJson() save json error!"<< std::endl
// 			<< "\t The pItem is NULL"<<std::endl
// 			<< "\t Please ask Workflow team  for help!"<<std::endl;
// 		pai::log::Error(errorMsg.str());
// 		throw pai::error::runtime_error(errorMsg.str());
//     }
//     pai::module::ParameterType eParameterType = pItem->GetType();
//     std::string strParameterType = MapValueToKey<std::string,pai::module::ParameterType,std::map<std::string,pai::module::ParameterType> >(pItem->GetTypeMap(),eParameterType);
//     paramJsonNode["ParameterType"] = strParameterType;
//     paramJsonNode["Default"] = pItem->GetDefault();
//     paramJsonNode["ParameterID"] = pItem->GetId();
//     paramJsonNode["ParameterName"] = pItem->GetName().toStdString();
//     paramJsonNode["Value"] = pItem->GetStringValue();
//     std::string strParameterInputType = MapValueToKey<std::string,pai::module::ParameterInputType,std::map<std::string,pai::module::ParameterInputType> >(pItem->GetInputTypeMap(),pItem->GetInputType());
//     paramJsonNode["ParameterInputType"] = strParameterInputType;

//     std::vector<AcceptDropType> vecAcceptDropTypes = pItem->GetAcceptDropTypes();
//     std::string strAcceptDropTypes("");
//     std::map<std::string,AcceptDropType> allAcceptDropTypes = pItem->GetAcceptDropTypeMap();
//     for(size_t i=0; i<vecAcceptDropTypes.size(); ++i )
//     {
//     	strAcceptDropTypes += MapValueToKey<std::string,AcceptDropType,std::map<std::string,AcceptDropType> >(allAcceptDropTypes,vecAcceptDropTypes[i]);
//     	strAcceptDropTypes += ";";
//     }
//     paramJsonNode["ParameterAcceptDropTypes"] = strAcceptDropTypes;

//     paramJsonNode["ParameterInputType"] = strParameterInputType;
//     paramJsonNode["ParameterInputMetaData"] = pItem->GetInputMetaData();
//     paramJsonNode["ParameterInputData"] = pItem->GetInputData();
//     paramJsonNode["ParameterSet"] = pItem->GetCategory();
//     paramJsonNode["UpLimit"] = pItem->GetMax();
//     paramJsonNode["LowerLimit"] = pItem->GetMin();
//     paramJsonNode["Optional"] = pItem->IsNessary()?"false":"true";
//     paramJsonNode["ParameterDesc"] = pItem->GetDescription();
//     paramJsonNode["InOut"] = pItem->GetInOut();
//     paramJsonNode["DataType"] = pItem->GetDataType();
//     paramJsonNode["DisplayValue"] = pItem->GetDisplayValue();

//     if(eParameterType == ARRAY || eParameterType == CUSTOM)
//     {
//         Json::Value vParams;

//         CCompositeParameterItem* pCompositeItem = dynamic_cast<CCompositeParameterItem*>(pItem);
//         if(pCompositeItem == NULL)
//         {
//         	std::stringstream errorMsg;
// 			errorMsg <<"\n\t "<< __FILE__ << ":" << __LINE__<< "\t the error information:" << std::endl
// 				<< "\t CModuleParameter _SaveToJson() save json error!"<< std::endl
// 				<< "\t The pCompositeItem is NULL"<<std::endl
// 				<< "\t Please ask Workflow team  for help!"<<std::endl;
// 			pai::log::Error(errorMsg.str());
// 			throw pai::error::runtime_error(errorMsg.str());
//         }
//         for(int i=0; i<pCompositeItem->GetChildCount(); i++)
//         {
//             Json::Value vParam;
//             _SaveToJson(vParam,pCompositeItem->GetParameterItem(i));
//             vParams.append(vParam);
//         }

//         paramJsonNode["Params"] = vParams;
//     }
// }

// void CModuleParameter::Print()
// {
//     Json::Value root;
//     this->SaveToJson(root);
//     string str = root.toStyledString();
//     cout << str << endl;
// }

bool CModuleParameter::IsReady(ParameterCompleteIndex& completeIndex) const
{
	return m_rootParameterItem.IsReady(completeIndex);
}

void CModuleParameter::SetImportPath(std::string importPath)
{
	m_importPath = importPath;
}


}
}