#include <QPainter>

#include "ZxSerializer.h"
#include "IxPtyPano.h"

#include "ZxSubAxisX.h"
#include "ZxSubAxisY.h"

#include "nmObjFaultTool.h"
#include "nmObjFault.h"

ZX_DEFINE_DYNAMIC(nObjFault, nmObjFault)

nmObjFault::nmObjFault()
{
    m_sObjTag = "nObjFault";
    nmObjFault::init("", nullptr, nullptr);
}

nmObjFault::nmObjFault(const QString& sName, \
                     ZxSubAxisX* pAxisX, \
                     ZxSubAxisY* pAxisY)
{
    m_sObjTag = "nObjFault";
    nmObjFault::init(sName, pAxisX, pAxisY);
}

nmObjFault::~nmObjFault()
{
}

void nmObjFault::init(const QString& sName, \
                     ZxSubAxisX* pAxisX, \
                     ZxSubAxisY* pAxisY)
{
    nmObjBase::init(sName, pAxisX, pAxisY);

    nmObjFault::initFlags();

    m_oPen = QPen(QBrush(QColor(0, 255, 164)), \
                  0.5, Qt::SolidLine);

    loadTempl();
}

void nmObjFault::initTools()
{
    m_pTool = new nmObjFaultTool();

    nmObjBase::initTools();
}

void nmObjFault::initFlags()
{
    setLockPos(false);
    setLockSize(false);
    setReadOnly(false);
}

bool nmObjFault::hitTest(const QPointF& pt)
{
    return nmObjBase::hitTest(pt);
}

bool nmObjFault::_runHitTest(const QPointF& pt, int& nOption, int& nSubIndex)
{
    if (!nmObjBase::_runHitTest(pt, nOption, nSubIndex))
    {
        return false;
    }

    nOption = -1;
    nSubIndex = 0;

    if (nullptr == m_pAxisX || nullptr == m_pAxisY)
    {
        return false;
    }

    QVector<QPointF> pts = getPosOf(m_vecPoints);

    // 点
    double r = 1.0;
    for (int i = 0; i < pts.count(); i++)
    {
        QPointF ptTopLeft = QPointF(pts[i].x() - r,
                                    pts[i].y() - r);
        QSizeF sz = QSizeF(r * 2.0, r * 2.0);

        QRectF rt = QRectF(ptTopLeft, sz);
        bool b = rt.contains(pt);
        if (b)
        {
            nOption = (int)OHO_Point;
            nSubIndex = i;
            return true;
        }
    }

    // 线
    for (int i = 0; i < pts.count()/* - 1*/; i++)
    {
        int n1 = i;
        int n2 = (i == pts.count() - 1 ? 0 : i + 1);
        if (_isNearLine(pt, pts[n1], pts[n2], 1.0 * 2))
        {
            nOption = (int)OHO_Bound;
            nSubIndex = i;
            return true;
        }
    }

    return false;
}

bool nmObjFault::runMove(const QPointF& pt1,
                        const QPointF& pt2)
{
    if (isLockPos())
    {
        return false;
    }

    if (nullptr == m_pAxisX || nullptr == m_pAxisY)
    {
        return false;
    }

    //emit sigRunMoveTo(pt1, pt2);

    int nCount = m_vecPoints.count();
    QVector<QPointF> vecPts = getPosOf(m_vecPoints); //屏幕值
    if (m_oHitOption == OHO_Point && m_nHitIndex >= 0)
    {
        vecPts[m_nHitIndex] = offsetPoint(vecPts[m_nHitIndex],
                                          pt1, pt2);
        return moveToPos(vecPts);
    }
    else if (m_oHitOption == OHO_Bound && m_nHitIndex >= 0)
    {
        for (int i = 0; i < nCount; i++)
        {
            vecPts[i] = offsetPoint(vecPts[i], pt1, pt2);
        }
        m_dOffsetX = pt2.x() - pt1.x();
        m_dOffsetY = pt2.y() - pt1.y();
        return moveToPos(vecPts);
    }
    else
    {
        return false;
    }

    return true;
}

void nmObjFault::fillPtyPano(IxPtyPano* sheet)
{
    nmObjBase::fillPtyPano(sheet);

    ZX_PROP("ObjFault.Pen", getPen, setPen);
//    ZX_PROP("ObjFault.BackgrdColor", getBackgrdColor, setBackgrdColor);
}

void nmObjFault::onSerialize(ZxSerializer* ser)
{
    nmObjBase::onSerialize(ser);

//    ser->write("BackgrdColor", m_clrBackgrd);
}

void nmObjFault::onDeserialize(ZxSerializer* ser)
{
    nmObjBase::onDeserialize(ser);

//    ser->read("BackgrdColor", m_clrBackgrd);
}

void nmObjFault::onSaveTempl(ZxSerializer* ser)
{
    nmObjBase::onSaveTempl(ser);

//    ser->write("BackgrdColor", m_clrBackgrd);
}

void nmObjFault::onLoadTempl(ZxSerializer* ser)
{
    nmObjBase::onLoadTempl(ser);

//    ser->read("BackgrdColor", m_clrBackgrd);
}

void nmObjFault::paintBack(QPainter* painter, const ZxPaintParam& param)
{
    if (nullptr == m_pAxisX || nullptr == m_pAxisY || \
            m_pAxisX->getRangeMin() == m_pAxisX->getRangeMax() || \
            m_pAxisY->getRangeMin() == m_pAxisY->getRangeMax())
    {
        return;
    }

    QVector<QPointF> pts = getPosOf(m_vecPoints);

    if (!pts.empty())
    {
        painter->save();

        QRectF rt = getOuterRect();
        painter->setClipRect(rt);

        QPen pen = m_oPen;
        if (isSelected()) //选中状态下
        {
            //pen = QPen(QBrush(Qt::red), 0.0f, Qt::DotLine);
            pen.setStyle(Qt::DotLine);
            painter->setPen(pen);
        }
        painter->setPen(pen);

        for (int i = 1; i < pts.count(); i++)
        {
            QPointF pt1 = pts[i - 1];
            QPointF pt2 = pts[i];
            QLineF oLine = QLineF(pt1, pt2);
            painter->drawLine(oLine);
        }

        if (isSelected()) //选中状态下
        {
            for (int i = 0; i < pts.count(); i++)
            {
                double w = 2.2;
                QPointF pt = pts[i];
                QRectF rect(pt.x() - w * 0.5, pt.y() - w * 0.5, w, w);
                {
                    painter->setPen(QColor(0, 0, 128));
                    painter->drawRect(rect);
                }
            }
        }

        // 绘制名称文字
        QRectF bound = getBounds();
        QFont ft = qApp->font();
        ft.setPointSize(8);
        painter->setFont(ft);
        painter->setPen(Qt::black);
        ZxDrawHelper::drawText(painter,
                               bound,
                               Qt::AlignCenter|Qt::AlignVCenter,
                               m_sName);


        painter->restore();

    }
}