/****************************************************************************
**
** Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
** Contact: http://www.qt-project.org/legal
**
** This file is part of the Qt Build Suite.
**
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia.  For licensing terms and
** conditions see http://qt.digia.com/licensing.  For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights.  These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
****************************************************************************/

#include "rulenode.h"

#include "artifact.h"
#include "buildgraph.h"
#include "buildgraphvisitor.h"
#include "productbuilddata.h"
#include "projectbuilddata.h"
#include "rulesapplicator.h"
#include "transformer.h"
#include <language/language.h>
#include <logging/logger.h>

namespace qbs {
namespace Internal {

RuleNode::RuleNode()
{
}

RuleNode::~RuleNode()
{
}

void RuleNode::accept(BuildGraphVisitor *visitor)
{
    if (visitor->visit(this))
        acceptChildren(visitor);
}

QString RuleNode::toString() const
{
    return QLatin1String("RULE ") + m_rule->toString();
}

/**
  * Removes the artifact and all the artifacts that depend exclusively on it.
  * Example: if you remove a cpp artifact then the obj artifact is removed but
  * not the resulting application (if there's more then one cpp artifact).
  */
void RuleNode::removeArtifactAndExclusiveDependents(Artifact *artifact,
        ArtifactSet *removedArtifacts, const Logger &logger)
{
    qDebug() << "REMOVE ARTIFACT" << artifact->toString();
    if (removedArtifacts)
        removedArtifacts->insert(artifact);
    TopLevelProject * const project = artifact->product->topLevelProject();
    foreach (BuildGraphNode *parentNode, artifact->parents) {
        Artifact *parent = dynamic_cast<Artifact *>(parentNode);
        if (!parent)
            continue;
        bool removeParent = false;
        disconnect(parent, artifact, logger);
        if (parent->children.isEmpty()) {
            removeParent = true;
        } else if (parent->transformer) {
            project->buildData->artifactsThatMustGetNewTransformers += parent;
            parent->transformer->inputs.remove(artifact);
            removeParent = parent->transformer->inputs.isEmpty();
        }
        if (removeParent)
            removeArtifactAndExclusiveDependents(parent, removedArtifacts, logger);
    }
    project->buildData->removeArtifact(artifact, logger);
}

void RuleNode::apply(const Logger &logger, ApplicationResult *result)
{
    bool hasAddedTags = false;
    bool hasRemovedTags = false;
    result->upToDate = false;

    // ### call this only for this rule
    product->topLevelProject()->buildData->updateNodesThatMustGetNewTransformer(logger);

    foreach (const FileTag &tag, m_rule->inputs) {
        if (product->buildData->addedArtifactsByFileTag(tag).count())
            hasAddedTags = true;
        if (product->buildData->removedArtifactsByFileTag(tag).count())
            hasRemovedTags = true;
        if (hasAddedTags && hasRemovedTags)
            break;
    }
    if (!hasAddedTags && !hasRemovedTags) {
        result->upToDate = true;
        return;
    }
    if (hasRemovedTags) {
        qDebug() << "@@hasRemovedTags" << m_rule->toString();
        ArtifactSet artifactsToRemove;
        foreach (const FileTag &tag, m_rule->inputs) {
            qDebug() << "@@@@tag" << tag.toString();
            foreach (Artifact *artifact, product->buildData->removedArtifactsByFileTag(tag)) {
                qDebug() << "@@@@@@artifact" << artifact->toString();
                foreach (Artifact *parent, ArtifactSet::fromNodeSet(artifact->parents)) {
                    qDebug() << "@@@@@@@@parent" << parent->toString();
                    if (!parent->transformer || parent->transformer->rule != m_rule
                            || !parent->transformer->inputs.contains(artifact)) {
                        // parent was not created by our rule.
                        continue;
                    }
                    removeArtifactAndExclusiveDependents(parent, &artifactsToRemove, logger);
                }
            }
        }
        // parents of removed artifacts must update their transformers
        foreach (Artifact *removedArtifact, artifactsToRemove) {
            foreach (BuildGraphNode *parentNode, removedArtifact->parents) {
                Artifact *parent = dynamic_cast<Artifact *>(parentNode);
                if (!parent)
                    continue;
                product->topLevelProject()->buildData->artifactsThatMustGetNewTransformers += parent;
            }
        }
        qDeleteAll(artifactsToRemove);
    }
    if (hasAddedTags) {
        // ### daemlicher Umweg ueber artifactsPerFileTag
        ArtifactsPerFileTagMap artifactsPerFileTag = product->buildData->addedArtifacts();
        RulesApplicator applicator(product, artifactsPerFileTag, logger);
        result->createdNodes = applicator.applyRuleInEvaluationContext(m_rule);
        product->buildData->setAddedArtifacts(artifactsPerFileTag);
    }
}

void RuleNode::load(PersistentPool &pool)
{
    BuildGraphNode::load(pool);
    m_rule = pool.idLoadS<Rule>();
}

void RuleNode::store(PersistentPool &pool) const
{
    BuildGraphNode::store(pool);
    pool.store(m_rule);
}

} // namespace Internal
} // namespace qbs