/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program 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 (at your
 * option) any later version.
 *
 * This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "PhaseShift.h"
#include "Containers.h"

PhaseShift::PhaseShift() = default;
PhaseShift::PhaseShift(PhaseShift const& right) = default;
PhaseShift::PhaseShift(PhaseShift&& right)  noexcept = default;
PhaseShift& PhaseShift::operator=(PhaseShift const& right) = default;
PhaseShift& PhaseShift::operator=(PhaseShift&& right) noexcept = default;
PhaseShift::~PhaseShift() = default;

bool PhaseShift::AddPhase(uint32 phaseId, PhaseFlags flags, std::vector<Condition> const* areaConditions, int32 references /*= 1*/)
{
    auto insertResult = Phases.emplace(phaseId, flags, nullptr);
    ModifyPhasesReferences(insertResult.first, references);
    if (areaConditions)
        insertResult.first->AreaConditions = areaConditions;

    return insertResult.second;
}

PhaseShift::EraseResult<PhaseShift::PhaseContainer> PhaseShift::RemovePhase(uint32 phaseId)
{
    auto itr = Phases.find(PhaseRef(phaseId, PhaseFlags::None, nullptr));
    if (itr != Phases.end())
    {
        ModifyPhasesReferences(itr, -1);
        if (!itr->References)
            return { Phases.erase(itr), true };
        return { itr, false };
    }
    return { Phases.end(), false };
}

bool PhaseShift::AddVisibleMapId(uint32 visibleMapId, TerrainSwapInfo const* visibleMapInfo, int32 references /*= 1*/)
{
    auto insertResult = VisibleMapIds.emplace(visibleMapId, VisibleMapIdRef{ 0, visibleMapInfo });
    insertResult.first->second.References += references;
    return insertResult.second;
}

PhaseShift::EraseResult<PhaseShift::VisibleMapIdContainer> PhaseShift::RemoveVisibleMapId(uint32 visibleMapId)
{
    auto itr = VisibleMapIds.find(visibleMapId);
    if (itr != VisibleMapIds.end())
    {
        if (!--itr->second.References)
            return { VisibleMapIds.erase(itr), true };
        return { itr, false };
    }
    return { VisibleMapIds.end(), false };
}

bool PhaseShift::AddUiMapPhaseId(uint32 uiMapPhaseId, int32 references /*= 1*/)
{
    auto insertResult = UiMapPhaseIds.emplace(uiMapPhaseId, UiMapPhaseIdRef{ 0 });
    insertResult.first->second.References += references;
    return insertResult.second;
}

PhaseShift::EraseResult<PhaseShift::UiMapPhaseIdContainer> PhaseShift::RemoveUiMapPhaseId(uint32 uiMapPhaseId)
{
    auto itr = UiMapPhaseIds.find(uiMapPhaseId);
    if (itr != UiMapPhaseIds.end())
    {
        if (!--itr->second.References)
            return { UiMapPhaseIds.erase(itr), true };
        return { itr, false };
    }
    return { UiMapPhaseIds.end(), false };
}

void PhaseShift::Clear()
{
    ClearPhases();
    VisibleMapIds.clear();
    UiMapPhaseIds.clear();
}

void PhaseShift::ClearPhases()
{
    Flags &= PhaseShiftFlags::AlwaysVisible | PhaseShiftFlags::Inverse;
    PersonalGuid.Clear();
    Phases.clear();
    NonCosmeticReferences = 0;
    CosmeticReferences = 0;
    PersonalReferences = 0;
    DefaultReferences = 0;
    UpdateUnphasedFlag();
}

bool PhaseShift::CanSee(PhaseShift const& other) const
{
    if (Flags.HasFlag(PhaseShiftFlags::Unphased) && other.Flags.HasFlag(PhaseShiftFlags::Unphased))
        return true;
    if (Flags.HasFlag(PhaseShiftFlags::AlwaysVisible) || other.Flags.HasFlag(PhaseShiftFlags::AlwaysVisible))
        return true;
    if (Flags.HasFlag(PhaseShiftFlags::Inverse) && other.Flags.HasFlag(PhaseShiftFlags::Inverse))
        return true;

    PhaseFlags excludePhasesWithFlag = PhaseFlags::None;
    if (Flags.HasFlag(PhaseShiftFlags::NoCosmetic) && other.Flags.HasFlag(PhaseShiftFlags::NoCosmetic))
        excludePhasesWithFlag = PhaseFlags::Cosmetic;

    if (!Flags.HasFlag(PhaseShiftFlags::Inverse) && !other.Flags.HasFlag(PhaseShiftFlags::Inverse))
    {
        ObjectGuid ownerGuid = PersonalGuid;
        ObjectGuid otherPersonalGuid = other.PersonalGuid;
        return Trinity::Containers::Intersects(Phases.begin(), Phases.end(), other.Phases.begin(), other.Phases.end(),
            [&ownerGuid, &otherPersonalGuid, excludePhasesWithFlag](PhaseRef const& myPhase, PhaseRef const& /*otherPhase*/)
        {
            return !myPhase.Flags.HasFlag(excludePhasesWithFlag) && (!myPhase.Flags.HasFlag(PhaseFlags::Personal) || ownerGuid == otherPersonalGuid);
        });
    }

    auto checkInversePhaseShift = [excludePhasesWithFlag](PhaseShift const& phaseShift, PhaseShift const& excludedPhaseShift)
    {
        if (phaseShift.Flags.HasFlag(PhaseShiftFlags::Unphased) && excludedPhaseShift.Flags.HasFlag(PhaseShiftFlags::InverseUnphased))
            return false;

        for (PhaseRef const& phase : phaseShift.Phases)
        {
            if (phase.Flags.HasFlag(excludePhasesWithFlag))
                continue;

            auto itr2 = std::find(excludedPhaseShift.Phases.begin(), excludedPhaseShift.Phases.end(), phase);
            if (itr2 != excludedPhaseShift.Phases.end() && !itr2->Flags.HasFlag(excludePhasesWithFlag))
                return false;
        }
        return true;
    };

    if (other.Flags.HasFlag(PhaseShiftFlags::Inverse))
        return checkInversePhaseShift(*this, other);

    return checkInversePhaseShift(other, *this);
}

void PhaseShift::ModifyPhasesReferences(PhaseContainer::iterator itr, int32 references)
{
    itr->References += references;

    if (!IsDbPhaseShift)
    {
        if (itr->Flags.HasFlag(PhaseFlags::Cosmetic))
            CosmeticReferences += references;
        else if (itr->Id != DEFAULT_PHASE)
            NonCosmeticReferences += references;
        else
            DefaultReferences += references;

        if (itr->Flags.HasFlag(PhaseFlags::Personal))
            PersonalReferences += references;

        if (CosmeticReferences)
            Flags |= PhaseShiftFlags::NoCosmetic;
        else
            Flags &= ~PhaseShiftFlags::NoCosmetic;

        UpdateUnphasedFlag();
        UpdatePersonalGuid();
    }
}

void PhaseShift::UpdateUnphasedFlag()
{
    EnumFlag<PhaseShiftFlags> unphasedFlag = !Flags.HasFlag(PhaseShiftFlags::Inverse) ? PhaseShiftFlags::Unphased : PhaseShiftFlags::InverseUnphased;
    Flags &= ~(!Flags.HasFlag(PhaseShiftFlags::Inverse) ? PhaseShiftFlags::InverseUnphased : PhaseShiftFlags::Unphased);
    if (NonCosmeticReferences && !DefaultReferences)
        Flags &= ~unphasedFlag;
    else
        Flags |= unphasedFlag;
}

void PhaseShift::UpdatePersonalGuid()
{
    if (!PersonalReferences)
        PersonalGuid.Clear();
}

bool PhaseShift::HasPersonalPhase() const
{
    for (PhaseRef const& phaseRef : GetPhases())
        if (phaseRef.IsPersonal())
            return true;
    return false;
}