/*
 * TableParameterItemDelegate.cpp
 *
 *  Created on: 2012-3-22
 *      Author: dev
 */
#include <cassert>
#include <iostream>
#include <sstream>
#include "TableParameterItemDelegate.h"
#include "Utils.h"
using namespace pai::module;
using namespace pai::utils;

std::string& pai_trim(std::string& s)
{
	int nSize = int(s.size());
	if(nSize == 0)
	{
		return s;
	}
	int nSPos = 0, nEPos = nSize - 1, i;
	for(i = 0; i < nSize; ++i) {
		if(!isspace(s[size_t(i)]))
		{
			nSPos = i ;
			break;
		}
	}
	for(i = nSize -1 ; i >= 0 ; --i) {
		if(!isspace(s[size_t(i)]))
		{
			nEPos = i;
			break;
		}
	}
	if (nEPos <= nSPos && isspace(s[size_t(nSPos)]))
	{
		s = "";
	}
	else
	{
		s = std::string(s, size_t(nSPos), size_t(nEPos - nSPos + 1));
	}
    return s;
}

CTableParameterItemDelegate::CTableParameterItemDelegate(CParameterItem* pTableParameterItem)
:m_pRootItem(NULL),m_vecColumnMetaData()
{
    m_pRootItem = dynamic_cast<CCompositeParameterItem*>(pTableParameterItem);
    assert(m_pRootItem != NULL && m_pRootItem->IsArray() && m_pRootItem->GetInputType() == pai::module::EDITABLEDGRID);//所谓表格就是一个不定行数的由行数据组成的数组
    RetreiveTableMetaData();
}

CTableParameterItemDelegate::~CTableParameterItemDelegate()
{

}
int CTableParameterItemDelegate::GetColumnIndexByColumnName(const std::string& strColumnName) const
{
   // int iColumnCount = static_cast<int>(m_vecColumnMetaData.size());
	std::vector<SColumnMetaData>::size_type iColumnCount = m_vecColumnMetaData.size();
    for(std::vector<SColumnMetaData>::size_type i=0;i<iColumnCount; ++i)
    {
        if(m_vecColumnMetaData[i].strColumnName == strColumnName)
        {
            return int(i);
        }
    }
    return -1;
}

void CTableParameterItemDelegate::RetreiveTableMetaData()
{
    m_vecColumnMetaData.clear();

    std::string strInputMetaData = m_pRootItem->GetInputMetaData();
    std::vector<std::string> lstInputMetaData;
    SplitByChar(strInputMetaData,CommonSplitChar,lstInputMetaData);
    if (lstInputMetaData.size() < iColumnControlDataSection)//要求最少有四部分
    {
        std::cout << "The parameter item " <<  m_pRootItem->GetName().toStdString() << " has a bad format for it's InputMetaData!" << std::endl;
        return;
    }
    std::string strColumnNames = lstInputMetaData[iColumnNameSection];//要求列名字的集合是第一段
    std::vector<std::string>  lstColumnNames;
    SplitByChar(strColumnNames,ColumnSplitChar,lstColumnNames);
    std::string strColumnTypes = lstInputMetaData[iColumnTypeSection];//要求列类型的集合是第二段
    std::vector<std::string> lstColumnTypes;
    SplitByChar(strColumnTypes,ColumnSplitChar,lstColumnTypes);
    std::string strColumnWidgets = lstInputMetaData[iColumnWidgetSection];//要求列控件类型的集合是第三段
    std::vector<std::string> lstColumnWidgets;
    SplitByChar(strColumnWidgets,ColumnSplitChar,lstColumnWidgets);
    std::string strColumnWidgetDatas = lstInputMetaData[iColumnWidgetMetaDataSection];//要求列控件元数据的集合是第四段
    std::vector<std::string> lstColumnWidgetDatas;
    SplitByChar(strColumnWidgetDatas,ColumnSplitChar,lstColumnWidgetDatas);

    if (lstColumnTypes.size() != lstColumnNames.size() || lstColumnWidgets.size() != lstColumnNames.size()
            || lstColumnWidgetDatas.size() < lstColumnNames.size())//要求各部分的个数统一划齐
    {
        std::cout <<"The parameter item " << m_pRootItem->GetName().toStdString() << " has a bad format for it's InputMetaData!" << std::endl;
        return;
    }

    std::vector<std::string> lstColumnWidgetStates;
    if (lstInputMetaData.size() > iColumnControlDataSection)
    {
        std::string strColumnWidgetStates = lstInputMetaData[iColumnControlDataSection];//要求列控件状态的集合是第五段
        SplitByChar(strColumnWidgetStates,ColumnSplitChar,lstColumnWidgetStates);
    }
    std::vector<std::string> lstColumnDefaultValues;
    if (lstInputMetaData.size() > iColumnDefaultTextSection)
    {
        std::string strColumnDefaultValues = lstInputMetaData[iColumnDefaultTextSection];//要求列控件缺省值的集合是第六段
        SplitByChar(strColumnDefaultValues,ColumnSplitChar,lstColumnDefaultValues);
    }

    for (unsigned int i = 0; i < lstColumnNames.size(); ++i)
    {
        SColumnMetaData columnMetaData;
        columnMetaData.strColumnName = lstColumnNames[i];
        columnMetaData.strColumnType = lstColumnTypes[i];
        columnMetaData.strColumnWidget = lstColumnWidgets[i];
        columnMetaData.strColumnWidgetMetaData = lstColumnWidgetDatas[i];
        if (lstInputMetaData.size() > iColumnControlDataSection)
        {
            columnMetaData.strColumnWidgetState = lstColumnWidgetStates[i];
        }
        if (lstInputMetaData.size() > iColumnDefaultTextSection)
        {
            columnMetaData.strColumnDefaultValue = lstColumnDefaultValues[i];
        }
        m_vecColumnMetaData.push_back(columnMetaData);
    }

}

CCompositeParameterItem* CTableParameterItemDelegate::AddRow()
{
    CCompositeParameterItem rowItem;
    rowItem.SetType(pai::module::ParmType_CUSTOM);
    rowItem.SetInputType(pai::module::NONEINPUT);
    rowItem.SetId("");
    rowItem.SetName(QString(""));

    for (unsigned int i = 0; i < m_vecColumnMetaData.size(); ++i)
    {
        CParameterItem cellItem;
        cellItem.SetType(cellItem.GetTypeMap()[m_vecColumnMetaData[i].strColumnType]);
        cellItem.SetInputType(cellItem.GetInputTypeMap()[m_vecColumnMetaData[i].strColumnWidget]);
        cellItem.SetId(m_vecColumnMetaData[i].strColumnName);
        cellItem.SetName(m_vecColumnMetaData[i].strColumnName);
        cellItem.SetInputMetaData(m_vecColumnMetaData[i].strColumnWidgetMetaData);
        cellItem.SetInputData(m_vecColumnMetaData[i].strColumnWidgetState);
        if (cellItem.GetInputType() == pai::module::COMBOX)
        {
            std::string strInputMetaData = cellItem.GetInputMetaData();

            std::vector<std::string> lstComboboxTexts;
            SplitByChar(strInputMetaData,ItemSplitChar,lstComboboxTexts);
            if (lstComboboxTexts.size() > 0)
            {
                cellItem.SetDefault(lstComboboxTexts[0]);
                if (cellItem.GetType() == pai::module::ParmType_BOOL || cellItem.GetType() == pai::module::ParmType_INT)
                {
                    cellItem.SetValue<int> (0);
                }
                else
                {
                    cellItem.SetStringValue(lstComboboxTexts[0]);
                    cellItem.SetDefault(lstComboboxTexts[0]);
                }
            }
        }
        if(pai_trim(m_vecColumnMetaData[i].strColumnDefaultValue) != "")
        {
            cellItem.SetDefault(m_vecColumnMetaData[i].strColumnDefaultValue);
            cellItem.SetStringValue(m_vecColumnMetaData[i].strColumnDefaultValue);
        }
        rowItem.AddParameterItem(cellItem);
    }
    m_pRootItem->AddParameterItem(rowItem);

    return dynamic_cast<CCompositeParameterItem*>(m_pRootItem->GetParameterItem(m_pRootItem->GetChildCount()-1));
}
bool CTableParameterItemDelegate::DeleteRow(int iRow)
{
    if(iRow<0 || iRow>=GetRowCount())
    {
        return false;
    }
    CParameterItem* pRowParameterItem = m_pRootItem->GetParameterItem(iRow);
    if(pRowParameterItem != NULL)
    {
        m_pRootItem->RemoveParameterItem(pRowParameterItem->GetId());
        return true;
    }
    return false;
}
CParameterItem* CTableParameterItemDelegate::GetCellParameterItem(int iRow,int iColumn) const
{
    if(iRow<0 || iRow>=GetRowCount() || iColumn<0 || iColumn>=GetColumnCount())
    {
        return NULL;
    }
    CParameterItem* pRowParameterItem = m_pRootItem->GetParameterItem(iRow);
    if(pRowParameterItem != NULL)
    {
        CCompositeParameterItem* pCompositeRowItem = dynamic_cast<CCompositeParameterItem*>(pRowParameterItem);
        if(pCompositeRowItem != NULL)
        {
            return pCompositeRowItem->GetParameterItem(iColumn);
        }
    }
    return NULL;
}

CParameterItem* CTableParameterItemDelegate::GetCellParameterItem(int iRow,const std::string& strColumnName) const
{
   return  GetCellParameterItem(iRow,GetColumnIndexByColumnName(strColumnName));
}

std::string CTableParameterItemDelegate::GetCellID(int iRow,int iColumn) const
{
    CParameterItem* pCellItem = GetCellParameterItem(iRow,iColumn);
    if(pCellItem != NULL)
    {
        return pCellItem->GetId();
    }
    return "";
}

int CTableParameterItemDelegate::GetRowCount() const
{
    return m_pRootItem->GetChildCount();
}
int CTableParameterItemDelegate::GetColumnCount() const
{
    return int(m_vecColumnMetaData.size());
}
std::string CTableParameterItemDelegate::GetColumnName(int iColumn) const
{
    if(iColumn<0 || iColumn>=GetColumnCount())
    {
        return "";
    }
    return m_vecColumnMetaData[size_t(iColumn)].strColumnName;
}
pai::module::ParameterType CTableParameterItemDelegate::GetColumnType(int iColumn) const
{
    if(iColumn<0 || iColumn>=GetColumnCount())
    {
        return ParmType_CUSTOM;
    }
    return m_pRootItem->GetTypeMap()[m_vecColumnMetaData[size_t(iColumn)].strColumnType];
}
ParameterInputType CTableParameterItemDelegate::GetColumnInputType(int iColumn) const
{
    if(iColumn<0 || iColumn>=GetColumnCount())
    {
        return NONEINPUT;
    }
    return m_pRootItem->GetInputTypeMap()[m_vecColumnMetaData[size_t(iColumn)].strColumnWidget];
}
std::string CTableParameterItemDelegate::GetColumnWidgetControlData(int iColumn) const
{
    if(iColumn<0 || iColumn>=GetColumnCount())
    {
        return "";
    }
    return m_vecColumnMetaData[size_t(iColumn)].strColumnWidgetState;
}
std::string CTableParameterItemDelegate::GetColumnWidgetMetaData(int iColumn) const
{
    if(iColumn<0 || iColumn>=GetColumnCount())
    {
        return "";
    }
    return m_vecColumnMetaData[size_t(iColumn)].strColumnWidgetMetaData;
}
std::string CTableParameterItemDelegate::GetColumnWidgetDefaultText(int iColumn) const
{
    if(iColumn<0 || iColumn>=GetColumnCount())
    {
        return "";
    }
    return m_vecColumnMetaData[static_cast<long unsigned>(iColumn)].strColumnDefaultValue;
}