#include "DoodlePch.h"

namespace JusDoodle {

DoodleSession::DoodleSession(int sessId, QObject *parent)
    : QObject(parent)
    , _doodleSess(NULL)
    , _doodleWindow(NULL)
    , _sessId(sessId)
    , _isCall(true)
{
}

DoodleSession::~DoodleSession()
{
    if (_doodleSess)
    {
        Mtc_DoodleDeleteSession(_doodleSess);
        _doodleSess = NULL;
    }
    delete _doodleWindow;
}

bool DoodleSession::init()
{
    _doodleSess = Mtc_DoodleCreateSession();
    if (!_doodleSess)
    {
        DOODLE_LOG_ERROR("create session", NULL);
        return false;
    }

    return true;
}

bool DoodleSession::start(int pageCount)
{
    if (!_doodleSess)
    {
        DOODLE_LOG_ERROR("invalid session", NULL);
        return false;
    }

    // check page count
    if (pageCount <= 0) pageCount = 1;
    Mtc_DoodleSessionSetPageCount(_doodleSess, pageCount);

    if (!_doodleWindow)
    {
        initWindow(pageCount);

        if (Version >= 2.0)
        {
            // create attribute
            Json::Value attr = Json::Value();
            attr[MtcDoodleActionTypeKey] = Json::Value(EN_MTC_DOODLE_ACTION_START);
            attr[MtcDoodlePageCountKey] = Json::Value(pageCount);

            // create action
            MTC_ACT action = Mtc_DoodleCreateAction();
            Mtc_DoodleSetActionAttr(action, attr.toStyledString().c_str());

            // send start action
            if (_isCall)
                Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME,
                Mtc_DoodlePrintAction(action));
            Mtc_DoodleDeleteAction(action);
        }
        else
        {
            QString attr = QString::number(pageCount);
            if (_isCall)
                Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME_START,
                    attr.toUtf8().data());
        }
    }

    _doodleWindow->show();

    return true;
}

void DoodleSession::stop()
{
    if (!_doodleSess)
    {
        DOODLE_LOG_ERROR("invalid session", NULL);
        return;
    }

    if (_doodleWindow) _doodleWindow->hide();
    return;
    if (Version >= 2.0)
    {
        // create attribute
        Json::Value attr = Json::Value();
        attr[MtcDoodleActionTypeKey] = Json::Value(EN_MTC_DOODLE_ACTION_STOP);

        // create action
        MTC_ACT action = Mtc_DoodleCreateAction();
        Mtc_DoodleSetActionAttr(action, attr.toStyledString().c_str());

        // send start action
        if (_isCall)
            Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME,
                Mtc_DoodlePrintAction(action));
        Mtc_DoodleDeleteAction(action);
    }
    else
    {
        if (_isCall)
            Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME_STOP, "stop");
    }
}

void DoodleSession::setBackgroundImages(const QStringList &imagePaths)
{
    if (!_doodleSess)
    {
        DOODLE_LOG_ERROR("invalid session", NULL);
        return;
    }

    MTC_IMG img;
    for (int i = 0; i < imagePaths.size(); i++)
    {
        img = Mtc_DoodleCreateImage();
        Json::Value attr = Json::Value();
        attr[MtcDoodlePageIdKey] = Json::Value(i);
        attr[MtcDoodleImageUriKey] = Json::Value(imagePaths.at(i).toUtf8().data());
        Mtc_DoodleSetImageAttr(img, attr.toStyledString().c_str());
        Mtc_DoodleSessionAddImage(_doodleSess, img);
        Mtc_DoodleDeleteImage(img);
    }

    if (_doodleWindow)
        _doodleWindow->setBackgroundImages(imagePaths);

    qDebug()<<"DoodleSession:"<<imagePaths;
}

void DoodleSession::recvData(const QString &name, const QString &data)
{
    if (!_doodleSess)
    {
        DOODLE_LOG_ERROR("invalid session", NULL);
        return;
    }

    if (name == DOODLE_DATA_NAME_START)
    {
        if (!_doodleWindow)
            initWindow(data.toInt());
//        _doodleWindow->show();
    }
    else if (name == DOODLE_DATA_NAME_STOP)
    {
//        if (_doodleWindow)
//            _doodleWindow->hide();
    }
    else if (name == DOODLE_DATA_NAME_SELECT)
    {
        if (_doodleWindow)
            _doodleWindow->actionSelectPage(data.toInt());
    }
    else if (name == DOODLE_DATA_NAME_ACTION
        || name == DOODLE_DATA_NAME_CLEAN
        || name == DOODLE_DATA_NAME)
    {
        // parse action
        qDebug()<<"data:"<<data;
        MTC_ACT action = Mtc_DoodleParseAction(data.toUtf8().data());
        if (!action)
        {
            DOODLE_LOG_ERROR("parse <%s>", data);
            return;
        }
        procAction(action);

        // save action
        Mtc_DoodleSessionAddAction(_doodleSess, ZFALSE, action);
        Mtc_DoodleDeleteAction(action);
    }
    qDebug("1data = %s\n",data.toLatin1().data());
}

// Process file received.
void DoodleSession::recvFile(const QString &name, const QString &path, int pageId)
{
    if (!_doodleSess)
    {
        DOODLE_LOG_ERROR("invalid session", NULL);
        return;
    }

    // format image attribute
    Json::Value attr = Json::Value();
    attr[MtcDoodlePageIdKey] = Json::Value(pageId);
    attr[MtcDoodleImageNameKey] = Json::Value(name.toUtf8().data());
    attr[MtcDoodlePageIdKey] = Json::Value(path.toUtf8().data());

    // create image
    MTC_IMG image = Mtc_DoodleCreateImage();
    Mtc_DoodleSetImageAttr(image, attr.toStyledString().c_str());
    Mtc_DoodleSessionAddImage(_doodleSess, image);
    Mtc_DoodleDeleteImage(image);

    if (_doodleWindow)
        _doodleWindow->setBackgroundImage(pageId, path);
}

void DoodleSession::onNotifyPageChanged(int pageId)
{
    MTC_ACT action = Mtc_DoodleCreateAction();
    if (!action)
    {
        DOODLE_LOG_ERROR("create action.", NULL);
        return;
    }

    if (Version >= 2.0)
    {
        // format data
        Json::Value info = Json::Value();
        info[MtcDoodleActionTypeKey] = Json::Value(EN_MTC_DOODLE_ACTION_SELECT_PAGE);
        info[MtcDoodlePageIdKey] = Json::Value(pageId);
        Mtc_DoodleSetActionAttr(action, info.toStyledString().c_str());
        const char *value = Mtc_DoodlePrintAction(action);

        if (_isCall && Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME, value) != ZOK)
            DOODLE_LOG_ERROR("send data", NULL);

        Mtc_DoodleSessionAddAction(_doodleSess, ZTRUE, action);
        Mtc_DoodleDeleteAction(action);
    }
    else
    {
        QString attr = QString::number(pageId);
        if (_isCall && Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME_SELECT,
                                              attr.toUtf8().data()) != ZOK)
            DOODLE_LOG_ERROR("send data", NULL);
    }
}

void DoodleSession::onNotifyClean(int pageId)
{
    MTC_ACT action = Mtc_DoodleCreateAction();
    if (!action)
    {
        DOODLE_LOG_ERROR("create action.", NULL);
        return;
    }

    // format data
    Json::Value info = Json::Value();
    info[MtcDoodleActionTypeKey] = Json::Value(EN_MTC_DOODLE_ACTION_CLEAN);
    info[MtcDoodlePageIdKey] = Json::Value(pageId);
    Mtc_DoodleSetActionAttr(action, info.toStyledString().c_str());
    const char *value = Mtc_DoodlePrintAction(action);

    if (Version >= 2.0)
    {
        if (_isCall && Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME, value) != ZOK)
            DOODLE_LOG_ERROR("send data", NULL);
    }
    else
    {
        if (_isCall && Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME_CLEAN, value) != ZOK)
            DOODLE_LOG_ERROR("send data", NULL);
    }

    Mtc_DoodleSessionAddAction(_doodleSess, ZTRUE, action);
    Mtc_DoodleDeleteAction(action);
}

void DoodleSession::onNotifyDrawPath(int pageId, const Path &path,
                      const QColor &color, double width)
{
    MTC_ACT action = Mtc_DoodleCreateAction();
    if (!action)
    {
        DOODLE_LOG_ERROR("create action.", NULL);
        return;
    }

    // get color
    int red, green, blue, alpha;
    color.getRgb(&red, &green, &blue, &alpha);
    unsigned __int64 rgba = (unsigned int)alpha;
    rgba = ((rgba << 8) | (unsigned int)red);
    rgba = ((rgba << 8) | (unsigned int)green);
    rgba = ((rgba << 8) | (unsigned int)blue);

    // format brush
    Json::Value brush = Json::Value();
    brush[MtcDoodleColorKey] = Json::Value(rgba);
    brush[MtcDoodleWidthKey] = Json::Value(width);

    // format attribute
    Json::Value info = Json::Value();
    info[MtcDoodleActionTypeKey] = Json::Value(EN_MTC_DOODLE_ACTION_DRAW);
    info[MtcDoodlePageIdKey] = Json::Value(pageId);
    info[MtcDoodleBrushKey] = brush;
    Mtc_DoodleSetActionAttr(action, info.toStyledString().c_str());

    // format path
    Path::const_iterator it;
    for (it = path.begin(); it != path.end(); it++)
    {
        Mtc_DoodleAddActionPositionX(action, it->_x, it->_y, it->_intvalMs);
    }

    const char *value = Mtc_DoodlePrintAction(action);

    if (Version >= 2.0)
    {
        if (_isCall && Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME, value) != ZOK)
            DOODLE_LOG_ERROR("send data", NULL);
    }
    else
    {
        if (_isCall && Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME_ACTION, value) != ZOK)
            DOODLE_LOG_ERROR("send data", NULL);
    }

    Mtc_DoodleSessionAddAction(_doodleSess, ZTRUE, action);
    Mtc_DoodleDeleteAction(action);
}

void DoodleSession::onNotifyErasePath(int pageId, const Path &path,
                       double width)
{
    MTC_ACT action = Mtc_DoodleCreateAction();
    if (!action)
    {
        DOODLE_LOG_ERROR("create action.", NULL);
        return;
    }

    // format brush
    Json::Value brush = Json::Value();
    brush[MtcDoodleWidthKey] = Json::Value(width);

    // format attribute
    Json::Value info = Json::Value();
    info[MtcDoodleActionTypeKey] = Json::Value(EN_MTC_DOODLE_ACTION_ERASE);
    info[MtcDoodlePageIdKey] = Json::Value(pageId);
    info[MtcDoodleBrushKey] = brush;
    Mtc_DoodleSetActionAttr(action, info.toStyledString().c_str());

    // format path
    Path::const_iterator it;
    for (it = path.begin(); it != path.end(); it++)
    {
        Mtc_DoodleAddActionPosition(action, it->_x, it->_y);
    }

    const char *value = Mtc_DoodlePrintAction(action);

    if (Version >= 2.0)
    {
        if (_isCall && Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME, value) != ZOK)
            DOODLE_LOG_ERROR("send data", NULL);
    }
    else
    {
        if (_isCall && Mtc_CallSendStreamData(_sessId, ZTRUE, DOODLE_DATA_NAME_ACTION, value) != ZOK)
            DOODLE_LOG_ERROR("send data", NULL);
    }

    Mtc_DoodleSessionAddAction(_doodleSess, ZTRUE, action);
    Mtc_DoodleDeleteAction(action);
}

void DoodleSession::readPath(MTC_ACT action, Path &path)
{
    Json::Reader reader;
    Json::Value pathInfo;
    double x, y;

    reader.parse(Mtc_DoodleGetActionPath(action), pathInfo, false);
    Json::ArrayIndex i;
    for (i = 0; i < pathInfo.size(); i++)
    {
        // [[interval, x, y]]
        x = pathInfo[i][1].asDouble();
        y = pathInfo[i][2].asDouble();

        qDebug()<<"x = "<<x<<"\n";
        qDebug()<<"y = "<<y<<"\n";
        path.push_back(Point(x, y));
    }
}

void DoodleSession::procAction(MTC_ACT action)
{
    Json::Reader reader;
    Json::Value info;
    reader.parse(Mtc_DoodleGetActionAttr(action), info, false);

    int type = info.get(MtcDoodleActionTypeKey, -1).asInt();
    int pageId = info.get(MtcDoodlePageIdKey, -1).asInt();

    Json::Value brush;
    unsigned int argb;
    double width;
    Path path;

    qDebug()<<"type = "<<type<<"\n";
    switch (type)
    {
    case EN_MTC_DOODLE_ACTION_DRAW:
        if (_doodleWindow)
        {
            // get color and width
            brush = info.get(MtcDoodleBrushKey, Json::Value());
            argb = brush.get(MtcDoodleColorKey, 0).asUInt();
            width = brush.get(MtcDoodleWidthKey, 0.0).asDouble();

            // read path
            readPath(action, path);

            _doodleWindow->actionDraw(pageId, argb, width, path);
        }
        break;
    case EN_MTC_DOODLE_ACTION_ERASE:
        if (_doodleWindow)
        {
            // get width
            brush = info.get(MtcDoodleBrushKey, Json::Value());
            width = brush.get(MtcDoodleWidthKey, 0.0).asDouble();

            // read path
            readPath(action, path);

            _doodleWindow->actionErase(pageId, width, path);
        }
        break;
    case EN_MTC_DOODLE_ACTION_CLEAN:
        if (_doodleWindow)
            _doodleWindow->actionClean(pageId);
        break;
    case EN_MTC_DOODLE_ACTION_UNDO:
        break;
    case EN_MTC_DOODLE_ACTION_SELECT_PAGE:
        if (_doodleWindow)
            _doodleWindow->actionSelectPage(pageId);
        break;
    case EN_MTC_DOODLE_ACTION_START:
        if (!_doodleWindow)
            initWindow(info.get(MtcDoodlePageCountKey, 1).asInt());
//        _doodleWindow->show();
        break;
    case EN_MTC_DOODLE_ACTION_STOP:
        if (_doodleWindow)
            _doodleWindow->close();
        break;
    }
}

void DoodleSession::initWindow(int pageCount)
{
    _doodleWindow = new DoodleWindow();
    _doodleWindow->init(pageCount);

    connect(_doodleWindow, SIGNAL(notifyClean(int)), SLOT(onNotifyClean(int)));
    connect(_doodleWindow, SIGNAL(notifyPageChanged(int)), SLOT(onNotifyPageChanged(int)));
    connect(_doodleWindow, SIGNAL(notifyDrawPath(int, const Path &, const QColor &, double)),
        SLOT(onNotifyDrawPath(int, const Path &, const QColor &, double)));
    connect(_doodleWindow, SIGNAL(notifyErasePath(int, const Path &, double)),
        SLOT(onNotifyErasePath(int, const Path &, double)));

    // set background images
    Json::Reader reader;
    Json::Value attr;
    QStringList imagePaths = QStringList();
    int i, count = Mtc_DoodleSessionGetImageCount(_doodleSess);
    for (i = 0; i < count; i++)
    {
        MTC_IMG img = Mtc_DoodleSessionEnumImage(_doodleSess, i);
        reader.parse(Mtc_DoodleGetImageAttr(img), attr, false);

        _doodleWindow->setBackgroundImage(attr.get(MtcDoodlePageIdKey, 0).asInt(),
            QString::fromUtf8(attr.get(MtcDoodleImageUriKey, "").asString().c_str()));
    }
//    _doodleWindow->show();
}


} // namespace JusDoodle