/*
 * ParameterProperty.cpp
 *
 *  Created on: 2011-9-19
 *      Author: dev
 */
#include <cassert>
#include <QtDebug>
#include "ParameterProperty.h"
#include "ModuleParameter.h"
// #include "ModuleParameterUtil.h"
#include "GeometryUtils.h"
using namespace std;
using namespace pai::module;
using namespace pai::graphics2d;

ParameterProperty::ParameterProperty(pai::module::CParameterItem *parameterItem,const QString &categoryname)
	:m_parameterItem(parameterItem), m_categoryName(categoryname), m_strError(""),m_parent(NULL)
{

}
void ParameterProperty::SetCategoryName(QString categoryName)
{
	m_categoryName=categoryName;
}
ParameterProperty::~ParameterProperty()
{
	qDeleteAll(m_child.begin(),m_child.end());
	m_child.clear();
}

void ParameterProperty::SetWorkflowID(QUuid workflowID)
{
	m_workflowID = workflowID;
}

QUuid ParameterProperty::GetWorkflowID()
{
	return m_workflowID;
}

bool ParameterProperty::IsRoot() const
{
	return (m_categoryName=="") && (m_parameterItem==NULL);
}

bool ParameterProperty::IsCategory() const
{
	return (m_categoryName!=""); //&& (m_parameterItem==NULL);
}

bool ParameterProperty::IsParameterItem() const
{
	return (m_categoryName=="") && (m_parameterItem!=NULL);
}

void ParameterProperty::AddChild(ParameterProperty *parameterItem,int pos)
{
	if(parameterItem == NULL)
	{
		return;
	}

	parameterItem->m_parent=this;
	parameterItem->SetWorkflowID(GetWorkflowID());
	if(pos>-1) {
		m_child.insert(pos,parameterItem);
	}
	else m_child.append(parameterItem);
}

ParameterProperty* ParameterProperty::AddChild(pai::module::CParameterItem *paramItem,const QString & categoryname,int pos)
{
    if(!Contains(ParameterProperty(paramItem,categoryname)))
    {
        ParameterProperty *param = new ParameterProperty(paramItem,categoryname);
        this->AddChild(param,pos);
        return param;
    }
    return NULL;
}

ParameterProperty* ParameterProperty::GetChild(int index)
{
	if(index<0 || index >m_child.count())
	{
		return NULL;
	}
	return m_child.at(index);
}

int ParameterProperty::GetRow() const
{
	if(m_parent==NULL)
	{
		return -1;
	}
	return m_parent->m_child.indexOf(const_cast<ParameterProperty*>(this));
}
std::string ParameterProperty::GetParameterItemID()  const
{
	if(IsParameterItem() && m_parameterItem)
	{
	    return m_parameterItem->GetId();
	}
	return "";
}
QString ParameterProperty::GetDisplayName() const
{
	QString cs;
	if(this->IsCategory())
		return m_categoryName;
	if(this->IsParameterItem())
	{
		cs=m_parameterItem->GetName();
	}
	return cs;
}
QString ParameterProperty::GetDisplayValue() const
{
	QString cs;
	if(this->IsParameterItem() && m_parameterItem)
	{
        if(m_parameterItem->GetInputType()==HDFSFILEBROWSER || m_parameterItem->GetInputType() == HDFSFILEEDITOR)
        {
            cs=QString::fromStdString(m_parameterItem->GetDefault());
        }
		cs=QString::fromStdString(m_parameterItem->GetStringValue());
	}
	return cs;
}
pai::module::ParameterType ParameterProperty::GetType() const
{
	if(this->IsParameterItem() && m_parameterItem)
	{
		return m_parameterItem->GetType();
	}
    return pai::module::ParmType_STRING;

}

pai::module::ParameterInputType ParameterProperty::GetInputType() const
{
    if(this->IsParameterItem())
    {
        return m_parameterItem->GetInputType();
    }
    return pai::module::NONEINPUT;

}

QList<QUuid> ParameterProperty::GetAcceptDropTypes() const
{
    // if(IsParameterItem())
    // {
    // 	return pai::ModuleParameterUtil::GetAcceptDropTypes(m_parameterItem);
    // }
	QList<QUuid> lstEmpty;
	return lstEmpty;
}

pai::module::CParameterItem *ParameterProperty::GetParamItem() const
{
	return m_parameterItem;
}
void ParameterProperty::SetParameterItem(pai::module::CParameterItem * pParameterItem)
{
    assert(pParameterItem!=NULL && pParameterItem->GetType() == pai::module::ParmType_ARRAY);
    m_parameterItem = pParameterItem;
}

QString ParameterProperty::GetErrorMessage() const
{
	return m_strError;
}

void ParameterProperty::SetErrorMessage(const QString& strErrMsg)
{
    if (IsParameterItem())
    {
        //前台对于空的必填项的错误信息做一个过滤ToDo
        //如果是必填项但值是空，则忽略错误；或者如果设置错误信息为空，则需要更新界面，常见于ClearAllErrorMessage。
        ParameterType paramType = m_parameterItem->GetType();
        if (!(m_parameterItem->IsNessary() && m_parameterItem->GetStringValue().empty()
                && (ParmType_ARRAY != paramType && ParmType_CUSTOM != paramType)) || strErrMsg.isEmpty())
        {
            m_strError = strErrMsg;
            emit signalSetErrorMessage(m_strError);
        }
    }
}

bool ParameterProperty::IsError() const
{
	return m_strError!="";
}

ParameterProperty * ParameterProperty::GetParameterPropertyWithValidInputType(const std::string& strParameterItemID)
{
    ParameterProperty *pDefaultParameterProperty = GetParameterProperty(strParameterItemID);
    if(pDefaultParameterProperty != NULL )
    {
        return pDefaultParameterProperty;
    }
    std::string strID(strParameterItemID);
    if((strID.rfind(".")!=std::string::npos) || (']' == *strID.rbegin()))
    {
       size_t nPos;
       if(']' == *strID.rbegin())//说明是数组的数组子项
       {
           nPos = strID.rfind('[');
       }
       else
       {
           nPos = strID.rfind('.');
       }
       strID.replace(nPos,strID.length()-nPos,"");//取得父参数项的ID
       return GetParameterPropertyWithValidInputType(strID);
    }
    return NULL;
}

ParameterProperty * ParameterProperty::GetParameterProperty(const std::string& strParameterItemID)
{
    if((m_parameterItem!=NULL && m_parameterItem->GetId() == strParameterItemID) || (m_categoryName.toStdString() == strParameterItemID))
    {
        return this;
    }

    foreach(ParameterProperty * pChild,m_child)
    {
        ParameterProperty * pResult=pChild->GetParameterProperty(strParameterItemID);
        if(pResult!=NULL)
        {
            return pResult;
        }
    }
    return NULL;
}
ParameterProperty * ParameterProperty::GetParameterPropertyByInputData(const std::string& strParameterItemInputData)
{
    if(m_parameterItem!=NULL && m_parameterItem->GetInputData().find(strParameterItemInputData)!=string::npos)
    {
        return this;
    }

    foreach(ParameterProperty * pChild,m_child)
    {
        if(pChild == NULL)
        {
            continue;
        }

        ParameterProperty * pResult=pChild->GetParameterPropertyByInputData(strParameterItemInputData);
        if(pResult!=NULL)
        {
            return pResult;
        }
    }
    return NULL;
}

void ParameterProperty::ClearAllErrorMessage()
{
    foreach(ParameterProperty * pChild,m_child)
    {
        if(pChild)
        {
            pChild->ClearAllErrorMessage();
        }
    }
    SetErrorMessage("");
    emit signalFinishValidation();
}

bool ParameterProperty::operator ==(const ParameterProperty& srcParameterProperty) const
{
    return (m_parameterItem == srcParameterProperty.m_parameterItem) && (m_categoryName == srcParameterProperty.m_categoryName);
}
bool ParameterProperty::operator !=(const ParameterProperty& srcParameterProperty) const
{
    return !(*this == srcParameterProperty);
}
bool ParameterProperty::ContainFILEBROWSERItem()
{
    if(this->GetInputType() == HDFSFILEBROWSER)
    {
        return true;
    }
    foreach(ParameterProperty * pChild,m_child)
    {
        if((pChild != NULL) && (pChild->ContainFILEBROWSERItem()))
        {
            return true;
        }
    }
    return false;
}
bool ParameterProperty::ContainsOverWriteItem()
{
    if(this->GetInputType() == CHECKBOX)
    {
        if (std::string::npos != m_parameterItem->GetId().find(".outputoverwrite"))
        {
            return true;
        }
    }
    foreach(ParameterProperty * pChild,m_child)
    {
        if((pChild != NULL) && (pChild->ContainsOverWriteItem()))
        {
            return true;
        }
    }
    return false;
}
bool ParameterProperty::Contains(const ParameterProperty& parameterProperty) const
{
    if(*this == parameterProperty)
    {
        return true;
    }
    foreach(ParameterProperty * pChild,m_child)
    {
        if((pChild != NULL) && (pChild->Contains(parameterProperty)))
        {
            return true;
        }
    }
    return false;
}

int ParameterProperty::RemoveChild(const std::string& strParameterItemID)
{
    if(strParameterItemID == "")
    {
        return -1;
    }
    ParameterProperty* pParameterProperty = GetParameterProperty(strParameterItemID);
    if(pParameterProperty != NULL)
    {
        //TODO 这里没有递归，所以本函数仅适用于叶子节点
        ParameterProperty* pParent = pParameterProperty->GetParent();
        int nIndex = pParent->m_child.indexOf(pParameterProperty);
        pParent->m_child.removeAt(nIndex);
        delete pParameterProperty;
        pParameterProperty = NULL;
        return nIndex;
    }
    return -1;
}
void ParameterProperty::HideShowItemsIcon(bool hide)
{
	emit signalHideShowItemsIcon(hide);
}
void ParameterProperty::HandleDeleteButton()
{
    //对于含有"KeepOneRow"属性的Array节点处理删除按钮的出现与消失，如果Array孩子只剩一个就让相关节点隐藏删除按钮，如果Array孩子变为两个则使第一个孩子的相关节点出现删除按钮
    if(m_parameterItem != NULL
            && m_parameterItem->GetType() == pai::module::ParmType_ARRAY
            && m_parameterItem->GetInputData().find("KeepOneRow")!=std::string::npos)
    {
        CCompositeParameterItem* pArrayParameterItem = dynamic_cast<CCompositeParameterItem*>(m_parameterItem);
        if(pArrayParameterItem != NULL)
        {
            int nArrayChildCount = pArrayParameterItem->GetChildCount();
            if(nArrayChildCount==1 || nArrayChildCount==2)
            {
                ParameterProperty* pChildHasDeleteButton = GetParameterPropertyByInputData("HasDeleteButton");
                if(pChildHasDeleteButton != NULL)
                {
                    emit pChildHasDeleteButton->signalShouldShowDeleteButton((nArrayChildCount == 1)?false:true);
                }
            }
        }
    }
}