/*
 *  The Mana Server
 *  Copyright (C) 2004-2010  The Mana World Development Team
 *
 *  This file is part of The Mana Server.
 *
 *  The Mana Server is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  any later version.
 *
 *  The Mana Server is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with The Mana Server.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "attribute.hpp"
#include "game-server/being.hpp"
#include "utils/logger.h"
#include <cassert>

AttributeModifiersEffect::AttributeModifiersEffect(AT_TY sType, AME_TY eType)
        : mMod(eType == AME_MULT ? 1 : 0), mSType(sType), mEType(eType)
{
    assert(eType == AME_MULT || eType == AME_ADD);
    assert(sType == TY_ST    || sType == TY_NST || sType == TY_NSTB);
    LOG_DEBUG("Layer created with eType " << eType << " and sType " << sType << ".");
}

AttributeModifiersEffect::~AttributeModifiersEffect()
{
    // ?
    /*mStates.clear();*/
    LOG_WARN("DELETION of attribute effect!");
}

bool AttributeModifiersEffect::add(unsigned short duration, double value, double prevLayerValue, int level)
{
    LOG_DEBUG("Adding modifier with value " << value <<
              " with a previous layer value of " << prevLayerValue << ". "
              "Current mod at this layer: " << mMod << ".");
    bool ret = false;
    mStates.push_back(new AttributeModifierState(duration, value, level));
    switch (mSType) {
    case TY_ST:
        switch (mEType) {
        case AME_ADD:
            if (value)
            {
                ret = true;
                mMod += value;
                mCacheVal = prevLayerValue + mMod;
            }
            break;
        case AME_MULT:
            if (value != 1)
            {
                ret = true;
                mMod *= value;
                mCacheVal = prevLayerValue * mMod;
            }
            break;
        default:
            LOG_FATAL("Attribute modifiers effect: unhandled type '"
                      << mEType << "' as a stackable!");
            assert(0);
            break;
        }
        break;
    case TY_NST:
        switch (mEType) {
        case AME_ADD:
            if (value > mMod)
            {
                ret = true;
                mMod = value;
                if (mMod > prevLayerValue)
                    mCacheVal = mMod;
            }
            break;
        default:
            LOG_FATAL("Attribute modifiers effect: unhandled type '"
                      << mEType << "' as a non-stackable!");
            assert(0);
        }
        // A multiplicative type would also be nonsensical
        break;
    case TY_NSTB:
        switch (mEType) {
        case AME_ADD:
        case AME_MULT:
            if (value > mMod)
            {
                ret = true;
                mMod = value;
                mCacheVal = mEType == AME_ADD ? prevLayerValue + mMod
                                              : prevLayerValue * mMod;
            }
            break;
        default:
            LOG_FATAL("Attribute modifiers effect: unhandled type '"
                      << mEType << "' as a non-stackable bonus!");
            assert(0);
        }
        break;
    default:
        LOG_FATAL("Attribute modifiers effect: unknown modifier type '"
                  << mSType << "'!");
        assert(0);
    }
    return ret;
}

bool durationCompare(const AttributeModifierState *lhs,
                     const AttributeModifierState *rhs)
{ return lhs->mDuration < rhs->mDuration; }

bool AttributeModifiersEffect::remove(double value, unsigned int id, bool fullCheck) {
    /* We need to find and check this entry exists, and erase the entry
       from the list too. */
    if (!fullCheck)
        mStates.sort(durationCompare); /* Search only through those with a duration of 0. */
    bool ret = false;
    for (std::list< AttributeModifierState * >::iterator it = mStates.begin();
         it != mStates.end() && (fullCheck || !(*it)->mDuration);
         ++it)
    {
        /* Check for a match */
        if ((*it)->mValue != value || (*it)->mId != id)
            continue;
        if (mSType == TY_ST)
            updateMod();
        delete *it;
        mStates.erase(it);
        if (!id)
            return true;
        else ret = true;
    }
    if (ret && mSType != TY_ST)
        updateMod();
    return ret;
}

void AttributeModifiersEffect::updateMod(double value)
{
    if (mSType == TY_ST)
    {
        if (mEType == AME_ADD)
            mMod -= value;
        else if (mEType == AME_MULT)
            mMod /= value;
        else LOG_ERROR("Attribute modifiers effect: unhandled type '"
                       << mEType << "' as a stackable in cache update!");
    }
    else if (mSType == TY_NST || mSType == TY_NSTB)
    {
        if (mMod == value)
        {
            mMod = 0;
            for (std::list< AttributeModifierState * >::const_iterator
                 it2 = mStates.begin(),
                 it2_end = mStates.end();
                it2 != it2_end;
                ++it2)
                if ((*it2)->mValue > mMod)
                    mMod = (*it2)->mValue;
        }
        else LOG_ERROR("Attribute modifiers effect: unhandled type '"
                       << mEType << "' as a non-stackable in cache update!");
    }
    else LOG_ERROR("Attribute modifiers effect: unknown modifier type '"
                   << mSType << "' in cache update!");
}

bool AttributeModifiersEffect::recalculateModifiedValue(double newPrevLayerValue)
 {
    double oldValue = mCacheVal;
    switch (mEType) {
        case AME_ADD:
            switch (mSType) {
            case TY_ST:
            case TY_NSTB:
                mCacheVal = newPrevLayerValue + mMod;
            break;
            case TY_NST:
                mCacheVal = newPrevLayerValue < mMod ? mMod : newPrevLayerValue;
            break;
            default:
            LOG_FATAL("Unknown stack type '" << mEType << "'!");
            assert(0);
        } break;
        case AME_MULT:
            mCacheVal = mSType == TY_ST ? newPrevLayerValue * mMod : newPrevLayerValue * mMod;
        break;
        default:
        LOG_FATAL("Unknown effect type '" << mEType << "'!");
        assert(0);
    }
    return oldValue != mCacheVal;
}

bool Attribute::add(unsigned short duration, double value, unsigned int layer, int level)
{
    assert(mMods.size() > layer);
    LOG_DEBUG("Adding modifier to attribute with duration " << duration <<
              ", value " << value << ", at layer " << layer << " with id "
              << level);
    if (mMods.at(layer)->add(duration, value,
                            (layer ? mMods.at(layer - 1)->getCachedModifiedValue()
                                   : mBase)
                            , level))
    {
        while (++layer < mMods.size())
        {
            if (!mMods.at(layer)->recalculateModifiedValue(
                       mMods.at(layer - 1)->getCachedModifiedValue()))
            {
                LOG_DEBUG("Modifier added, but modified value not changed.");
                return false;
            }
        }
        LOG_DEBUG("Modifier added. Base value: " << mBase << ", new modified "
                  "value: " << getModifiedAttribute() << ".");
        return true;
    }
    LOG_DEBUG("Failed to add modifier!");
    return false;
}

bool Attribute::remove(double value, unsigned int layer, int lvl, bool fullcheck)
{
    assert(mMods.size() > layer);
    if (mMods.at(layer)->remove(value, lvl, fullcheck))
    {
        while (++layer < mMods.size())
           if (!mMods.at(layer)->recalculateModifiedValue(
                         mMods.at(layer - 1)->getCachedModifiedValue()))
               return false;
        return true;
    }
    return false;
}

bool AttributeModifiersEffect::tick()
{
    bool ret = false;
    std::list<AttributeModifierState *>::iterator it = mStates.begin();
    while (it != mStates.end())
    {
        if ((*it)->tick())
        {
            double value = (*it)->mValue;
            LOG_DEBUG("Modifier of value " << value << " expiring!");
            delete *it;
            mStates.erase(it++);
            updateMod(value);
            ret = true;
        }
        ++it;
    }
    return ret;
}

Attribute::Attribute(const std::vector<struct AttributeInfoType> &type)
{
    LOG_DEBUG("Construction of new attribute with '" << type.size() << "' layers.");
    for (unsigned int i = 0; i < type.size(); ++i)
    {
        LOG_DEBUG("Adding layer with stack type " << type[i].sType << " and effect type " << type[i].eType << ".");
        mMods.push_back(new AttributeModifiersEffect(type[i].sType,
                                                 type[i].eType));
        LOG_DEBUG("Layer added.");
    }
}

Attribute::~Attribute()
{
    for (std::vector<AttributeModifiersEffect *>::iterator it = mMods.begin(),
         it_end = mMods.end(); it != it_end; ++it)
    {
        // ?
        //delete *it;
    }
}

bool Attribute::tick()
{
    bool ret = false;
    double prev = mBase;
    for (std::vector<AttributeModifiersEffect *>::iterator it = mMods.begin(),
        it_end = mMods.end(); it != it_end; ++it)
    {
        if ((*it)->tick())
        {
            LOG_DEBUG("Attribute layer " << mMods.begin() - it
                      << " has expiring modifiers.");
            ret = true;
        }
        if (ret)
            if (!(*it)->recalculateModifiedValue(prev)) ret = false;
        prev = (*it)->getCachedModifiedValue();
    }
    return ret;
}

void Attribute::clearMods()
{
    for (std::vector<AttributeModifiersEffect *>::iterator it = mMods.begin(),
        it_end = mMods.end(); it != it_end; ++it)
        (*it)->clearMods(mBase);
}

void Attribute::setBase(double base) {
    LOG_DEBUG("Setting base attribute from " << mBase << " to " << base << ".");
    double prev = mBase = base;
    std::vector<AttributeModifiersEffect *>::iterator it = mMods.begin();
    while (it != mMods.end())
        if ((*it)->recalculateModifiedValue(prev))
            prev = (*it++)->getCachedModifiedValue();
        else
            break;
}

void AttributeModifiersEffect::clearMods(double baseValue)
{
    mStates.clear();
    mCacheVal = baseValue;
    mMod = mEType == AME_ADD ? 0 : 1;
}