#include "LayerTreeGroupNode.h"
#include "LayerTreeLayerNode.h"

LayerTreeGroup::LayerTreeGroup(const QString& name, QObject* parent)
    : LayerTreeNode(name, parent)
{
}

LayerTreeGroup* LayerTreeGroup::insertGroup(int index, const QString& name)
{
    auto* group = new LayerTreeGroup(name);
    insertChildNode(index, group);
    return group;
}

LayerTreeGroup* LayerTreeGroup::addGroup(const QString& name)
{
    return insertGroup(childCount(), name);
}

LayerTreeLayer* LayerTreeGroup::insertLayer(int index, LayerTreeLayer* layer)
{
    if (!layer) return nullptr;
    insertChildNode(index, layer);
    return layer;
}

LayerTreeLayer* LayerTreeGroup::addLayer(LayerTreeLayer* layer)
{
    return insertLayer(childCount(), layer);
}

void LayerTreeGroup::insertChildNode(int index, LayerTreeNode* node)
{
    insertChild(index, node);
}

void LayerTreeGroup::addChildNode(LayerTreeNode* node)
{
    appendChild(node);
}

LayerTreeNode* LayerTreeGroup::removeChildNode(LayerTreeNode* node)
{
    if (!node) return nullptr;
    int row = -1;
    for (int i = 0; i < childCount(); ++i)
    {
        if (childAt(i) == node)
        {
            row = i;
            break;
        }
    }
    if (row < 0) return nullptr;
    removeChild(row, 1, false);
    return node;
}

LayerTreeLayer* LayerTreeGroup::findLayer(const QString& name) const
{
    const auto layers = findLayers();
    for (auto* l : layers)
    {
        if (l->name() == name)
            return l;
    }
    return nullptr;
}

QList<LayerTreeLayer*> LayerTreeGroup::findLayers() const
{
    QList<LayerTreeLayer*> result;
    for (int i = 0; i < childCount(); ++i)
    {
        LayerTreeNode* child = childAt(i);
        if (LayerTreeNode::isLayer(child))
        {
            result.append(static_cast<LayerTreeLayer*>(child));
        }
        else if (LayerTreeNode::isGroup(child))
        {
            result.append(static_cast<LayerTreeGroup*>(child)->findLayers());
        }
    }
    return result;
}

QList<LayerTreeGroup*> LayerTreeGroup::findGroups() const
{
    QList<LayerTreeGroup*> result;
    for (int i = 0; i < childCount(); ++i)
    {
        LayerTreeNode* child = childAt(i);
        if (LayerTreeNode::isGroup(child))
        {
            auto* g = static_cast<LayerTreeGroup*>(child);
            result.append(g);
            result.append(g->findGroups());
        }
    }
    return result;
}