#include "LayerEdit.h"
#include "../ManagementContext/LayerManagmentContext.h"

LayerEdit::~LayerEdit()
{
}

LayerEdit::LayerEdit(std::string act, uint32_t layerID)
{
    this->action = act;
    this->layerID = layerID;

    LayerNode* layer = LayerManagementContext::FromId(layerID);
    this->beforeBlendMode = layer->BlendMode;
    this->beforeOpacity = layer->Opacity;
    this->beforeVisible = layer->Visible;
    this->beforeLocked = layer->Locked;
    this->beforeAlphaLocked = layer->AlphaLocked;
    this->beforeClipped = layer->Clipped;
    this->beforeName = layer->Name;
    this->nowBlendMode = layer->BlendMode;
    this->nowOpacity = layer->Opacity;
    this->nowVisible = layer->Visible;
    this->nowLocked = layer->Locked;
    this->nowAlphaLocked = layer->AlphaLocked;
    this->nowClipped = layer->Clipped;
    this->nowName = layer->Name;
}

void LayerEdit::SetOldBlendmode(Blendmode blendmode)
{
    beforeBlendMode = blendmode;
}

void LayerEdit::SetOldOpacity(double opacity)
{
    beforeOpacity = opacity;
}

void LayerEdit::SetOldVisible(bool visible)
{
    beforeVisible = visible;
}

void LayerEdit::SetOldLocked(bool locked)
{
    beforeLocked = locked;
}

void LayerEdit::SetOldAlphaLocked(bool alphaLocked)
{
    beforeAlphaLocked = alphaLocked;
}

void LayerEdit::SetOldClipped(bool clipped)
{
    beforeClipped = clipped;
}

void LayerEdit::SetOldName(std::string name)
{
    beforeName = name;
}

void LayerEdit::SetBlendmode(Blendmode blendmode)
{
    nowBlendMode = blendmode;
}

void LayerEdit::SetOpacity(double opacity)
{
    nowOpacity = opacity;
}

void LayerEdit::SetVisible(bool visible)
{
    nowVisible = visible;
}

void LayerEdit::SetLocked(bool locked)
{
    nowLocked = locked;
}

void LayerEdit::SetAlphaLocked(bool alphaLocked)
{
    nowAlphaLocked = alphaLocked;
}

void LayerEdit::SetClipped(bool clipped)
{
    nowClipped = clipped;
}

void LayerEdit::SetName(std::string name)
{
    nowName = name;
}


void LayerEdit::Execute()
{
    LayerNode* layer = LayerManagementContext::FromId(layerID);
    layer->BlendMode = nowBlendMode;
    layer->Opacity = nowOpacity;
    layer->Visible = nowVisible;
    layer->Locked = nowLocked;
    layer->AlphaLocked = nowAlphaLocked;
    layer->Clipped = nowClipped;
    layer->Name = nowName;
    timestamp = std::chrono::system_clock::now();
}

void LayerEdit::Undo()
{
    LayerNode* layer = LayerManagementContext::FromId(layerID);
    layer->BlendMode = beforeBlendMode;
    layer->Opacity = beforeOpacity;
    layer->Visible = beforeVisible;
    layer->Locked = beforeLocked;
    layer->AlphaLocked = beforeAlphaLocked;
    layer->Clipped = beforeClipped;
    layer->Name = beforeName;
}

json LayerEdit::SerializeArgs()
{
    json j = json::object(); // only now needs serialization, since rest can be reconstructed, action is not essential
    j["layerID"] = layerID;
    if (nowBlendMode != beforeBlendMode) {
        j["blendMode"] = nowBlendMode;
    }
    if (nowOpacity != beforeOpacity) {
        j["opacity"] = nowOpacity;
    }
    if (nowVisible != beforeVisible) {
        j["visible"] = nowVisible;
    }
    if (nowLocked != beforeLocked) {
        j["locked"] = nowLocked;
    }
    if (nowAlphaLocked != beforeAlphaLocked) {
        j["alphaLocked"] = nowAlphaLocked;
    }
    if (nowClipped != beforeClipped) {
        j["clipped"] = nowClipped;
    }
    if (nowName != beforeName) {
        j["name"] = nowName;
    }
    return j;
}

std::string LayerEdit::GetTitle()
{
    return action;
}

const char* LayerEdit::GetIdentity() const
{
    return "layerEdit";
}