#ifndef CCSCOLUMN_H
#define CCSCOLUMN_H

#include "QColor"
#include "qglobal.h"
#include "ccsiteminterface.h"
#include "ccsreport_global.h"
#include "common_types.h"

namespace CCS_Report {
class CCSBaseItemInterface;
class CCSItemInterface;
class CCSItemInterfacePrivate;
class CCSColumnPrivate;
class ReportFunPara;
class CCS_COMPASSREPORT_EXPORT  CCSColumn:public CCSItemInterface
{
    Q_OBJECT
    Q_PROPERTY(int width READ width WRITE SetWidth)   //列宽
    Q_PROPERTY(bool dynamic READ dynamic WRITE SetDynamic)   //是否为动态列,缺省为否
    Q_PROPERTY(bool colfill READ colfill WRITE SetColFill)   //铺满列
    Q_PROPERTY(bool breakrow READ breakrow WRITE SetBreakRow)   //折行起始
    Q_PROPERTY(bool breakflag READ breakflag WRITE SetBreakFlag)   //折行标识，针对动态列
    Q_PROPERTY(bool colrepeatbreak READ colrepeatbreak WRITE SetColRepeatBreak)   //如果有折行，是否重复此列

public:
//列宽类型， 按百分比 还是 绝对宽度
    enum WidthType
    {
        Percent,
        Absolute
    };
    CCSColumn(QObject * parent = 0);
     ~CCSColumn();
    virtual CCSBaseItemInterface * createInstance(QObject * parent) const=0;
    virtual CCSBaseItemInterface * clone(bool withChildren = true, bool init = true) const=0;
    virtual void exeFunction(ReportFunPara& arg)=0;

    int width() const;
    void SetWidth(const int &width);
    bool dynamic() const;
    void SetDynamic(const bool &bdyanamic);
    bool colfill() const;
    void SetColFill(const bool &bflag);
    bool breakrow() const;
    void SetBreakRow(const bool &bflag);
    bool breakflag() const;
    void SetBreakFlag(const bool &bflag);
    bool colrepeatbreak() const;
    void SetColRepeatBreak(const bool &bflag);
    CCS_Report::CCSBaseItemInterface* cell();
    QList<CCS_Report::CCSBaseItemInterface*> cells() const;
//    CCSColumn* Clone() const;
//    CCSColumn* ShallowCopy() const;
    void SetText(const QString& text,int iPos=0);
    virtual void SetValue(const QString &text,int iPos=0){}


protected:
    Q_DECLARE_PRIVATE(CCSColumn)
    CCSColumn(CCSColumnPrivate *dd, QObject * parent);
    virtual CCSBaseItemInterface * itemClone() const=0;

};
class CCSColumnPrivate:public CCSItemInterfacePrivate
{
public:
      CCSColumnPrivate()
        :CCSItemInterfacePrivate(),
        m_iWidth(100),
        m_bColDynamic(false),
        m_bColFill(true),
        m_bBreakRow(false),
        m_bBreakFlag(true),
        m_bColRepeatBreak(false)
      {}
      CCSColumnPrivate(const CCSColumnPrivate& p)
        :CCSItemInterfacePrivate(p),
        m_iWidth(p.m_iWidth),
        m_bColDynamic(p.m_bColDynamic),
        m_bColFill(p.m_bColFill),
        m_bBreakRow(p.m_bBreakRow),
        m_bBreakFlag(p.m_bBreakFlag),
        m_bColRepeatBreak(p.m_bColRepeatBreak)
      {}
      virtual ~CCSColumnPrivate(){}

    int m_iWidth; //设置列宽，按百分比进行设置 对于有动态列，且有折行，则为每个列的宽度；如果没有折行，则为总宽度，然后根据动态数据进行平分
    bool m_bColDynamic; //是否有动态列
    bool m_bColFill; //当动态列小于折行且不够列宽时，是否铺满（仅针对动态列不折行的情况下）
    bool m_bBreakFlag; //动态列当记录数过多时是否需要折行
    bool m_bBreakRow;  //折行起点标志
    bool m_bColRepeatBreak; //当折行时，列是否重复，针对动态列
};
/*********************************************************************************/
class CCSColumnHeaderPrivate;
class CCS_COMPASSREPORT_EXPORT CCSColumnHeader:public CCSColumn
{
    Q_OBJECT

public:

    CCSColumnHeader(QObject * parent = 0);
     ~CCSColumnHeader();
    virtual CCSBaseItemInterface * createInstance(QObject * parent) const;
    virtual CCSBaseItemInterface * clone(bool withChildren = true, bool init = true) const;
    virtual void SetValue(const QString &text,int iPos=0){}
    virtual void exeFunction(ReportFunPara& arg);
    
    /// <summary>
    /// 判断列头中是否有动态列，且返回对应的表字段名称
    /// </summary>
    /// <returns></returns>
    void HandleDynamicField(QString& strField);
    /// <summary>
    /// 判断此列是否有动态列
    /// </summary>
    /// <returns></returns>
    bool HasDynamic();
    bool repeatheader() const;
    void SetRepeatHeader(const int &icount);
    /// <summary>
    /// 解析列头中静态表字段
    /// </summary>
    /// <param name="groupkey"></param>
    ReportFunPara ParseColumn(CCSGroup& groupkey);
    /// <summary>
    /// 解析动态列头中表字段
    /// </summary>
    /// <param name="groupkey"></param>
    void ParseDynamic(int iColIndex,QList<QString> listDynaContent, CCSGroup& groupkey, QList<int>  listWidths);
    /// <summary>
    /// 根据是否动态和折行等信息重新计算列宽
    /// </summary>
    void ReCalDynamicWidth(int iColIndex,int count,QList<int>  listWidths);

    CCSColumnHeader* Clone() const;
    CCSColumnHeader* ShallowCopy() const;
    /// <summary>
    /// 重新设置列中的单元格列索引号
    /// </summary>
    /// <param name="iAdd">增量索引号</param>
    void  SetColumnHeaderIndex(int iAdd);
protected:
    Q_DECLARE_PRIVATE(CCSColumnHeader)
    CCSColumnHeader(CCSColumnHeaderPrivate *dd, QObject * parent);
    virtual CCSBaseItemInterface * itemClone() const;


};
class CCSColumnHeaderPrivate:public CCSColumnPrivate
{
public:
      CCSColumnHeaderPrivate()
        :CCSColumnPrivate(),
        m_iRepeatCount(1)
      {}
      CCSColumnHeaderPrivate(const CCSColumnHeaderPrivate& p)
        :CCSColumnPrivate(p),
        m_iRepeatCount(p.m_iRepeatCount)
      {}
      virtual ~CCSColumnHeaderPrivate(){}

    int m_iRepeatCount;
};
/*********************************************************************************/
class CCSColumnBottomPrivate;
class CCS_COMPASSREPORT_EXPORT CCSColumnBottom:public CCSColumn
{
    Q_OBJECT

public:

    CCSColumnBottom(QObject * parent = 0);
     ~CCSColumnBottom();
    virtual CCSBaseItemInterface * createInstance(QObject * parent) const;
    virtual CCSBaseItemInterface * clone(bool withChildren = true, bool init = true) const;


    CCSColumnBottom* Clone() const;
    CCSColumnBottom* ShallowCopy() const;
    void SetText(const QString& text,int iPos=0);
    virtual void SetValue(const QString &text,int iPos=0){}
    virtual void exeFunction(ReportFunPara& arg);

protected:
    Q_DECLARE_PRIVATE(CCSColumnBottom)
    CCSColumnBottom(CCSColumnBottomPrivate *dd, QObject * parent);
    virtual CCSBaseItemInterface * itemClone() const;

};
class CCSColumnBottomPrivate:public CCSColumnPrivate
{
public:
      CCSColumnBottomPrivate()
        :CCSColumnPrivate()
      {}
      CCSColumnBottomPrivate(const CCSColumnBottomPrivate& p)
        :CCSColumnPrivate(p)
      {}
      virtual ~CCSColumnBottomPrivate(){}


};
/*********************************************************************************/
class CCSColumnContentPrivate;
class  CCS_COMPASSREPORT_EXPORT CCSColumnContent:public CCSColumn
{
    Q_OBJECT
    Q_PROPERTY(bool keycolumn READ keycolumn WRITE SetKeycolumn)   //关键字段列
    Q_PROPERTY(bool mergerow READ mergerow WRITE SetMergerow)   //是否为动态列,缺省为否

public:
    QString m_ColField; //当为动态列时，列的Key值
public:
//列宽类型， 按百分比 还是 绝对宽度
     CCSColumnContent(QObject * parent = 0);
     ~CCSColumnContent();
    virtual CCSBaseItemInterface * createInstance(QObject * parent) const;
    virtual CCSBaseItemInterface * clone(bool withChildren = true, bool init = true) const;
    virtual void SetValue(const QString &text,int iPos=0){}
    virtual void exeFunction(ReportFunPara& arg);
    bool keycolumn() const;
    void SetKeycolumn(const bool& bflag);
    bool mergerow() const;
    void SetMergerow(const bool& bflag);

//    bool GetNoRecord() const {return m_bNoRecord;}
//    void SetNoRecord(const bool &record){m_bNoRecord = record;}
    QString GetColField() const {return m_ColField;}
    void SetColField(const QString &field) {m_ColField = field;}
    void SetColField1(const char* gbk) 
    {
        QString field = QString::fromLocal8Bit(gbk);
        m_ColField = field;
    }
//    bool GetIsMerge() const {return m_bMerge;}
//    void SetIsMerge(const bool &bMerge){ m_bMerge = bMerge;}

    CCSColumnContent* Clone() const;
    CCSColumnContent* ShallowCopy() const;

    /// <summary>
    /// 解析动态内容表字段
    /// </summary>
    /// <param name="groupkey"></param>
    QList<QString> ParseDynamicTableContent(QMap<QString, QMap<QString, QString>> datasetDyn);
    bool IsMerge()
    {
        return  keycolumn() && mergerow(); //当相邻行两个相等时，是否合并
    }
protected:
    Q_DECLARE_PRIVATE(CCSColumnContent)
    CCSColumnContent(CCSColumnContentPrivate *dd, QObject * parent);
    virtual CCSBaseItemInterface * itemClone() const;

private:

   

};
class CCSColumnContentPrivate:public CCSColumnPrivate
{
public:
    CCSColumnContentPrivate()
        :CCSColumnPrivate(),
            m_bNoRecord(true),
            m_bKey(false),
            m_bMerge(false)
    {}
    CCSColumnContentPrivate(const CCSColumnContentPrivate& p)
        :CCSColumnPrivate(p),
            m_bNoRecord(p.m_bNoRecord),
            m_bKey(p.m_bKey),
            m_bMerge(p.m_bMerge)
    {}
    virtual ~CCSColumnContentPrivate(){}

    bool m_bNoRecord;
    bool m_bMerge; //当相邻行两个相等时，是否合并
    bool m_bKey; //是否为关键列
};
}
#endif // CCSCOLUMN_H