/*
 * 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/>.
 */

#ifndef TRINITY_SPAWNDATA_H
#define TRINITY_SPAWNDATA_H

#include "DBCEnums.h"
#include "Optional.h"
#include "Position.h"
#include <array>
#include <vector>

class AreaTrigger;
class Creature;
class GameObject;
class Pool;
struct PoolTemplate;

// EnumUtils: DESCRIBE THIS
enum SpawnObjectType
{
    SPAWN_TYPE_CREATURE = 0,   // TITLE Creature
    SPAWN_TYPE_GAMEOBJECT = 1, // TITLE Gameobject
    SPAWN_TYPE_AREATRIGGER = 2,// TITLE AreaTrigger
    NUM_SPAWN_TYPES_WITH_DATA, // SKIP
    NUM_SPAWN_TYPES = NUM_SPAWN_TYPES_WITH_DATA // SKIP
};

enum SpawnObjectTypeMask
{
    SPAWN_TYPEMASK_CREATURE = (1 << SPAWN_TYPE_CREATURE),
    SPAWN_TYPEMASK_GAMEOBJECT = (1 << SPAWN_TYPE_GAMEOBJECT),
    SPAWN_TYPEMASK_AREATRIGGER = (1 << SPAWN_TYPE_AREATRIGGER),

    SPAWN_TYPEMASK_WITH_DATA = (1 << NUM_SPAWN_TYPES_WITH_DATA)-1,
    SPAWN_TYPEMASK_ALL = (1 << NUM_SPAWN_TYPES)-1
};

enum SpawnGroupFlags
{
    SPAWNGROUP_FLAG_NONE                            = 0x00,
    SPAWNGROUP_FLAG_SYSTEM                          = 0x01,
    SPAWNGROUP_FLAG_COMPATIBILITY_MODE              = 0x02,
    SPAWNGROUP_FLAG_MANUAL_SPAWN                    = 0x04,
    SPAWNGROUP_FLAG_DYNAMIC_SPAWN_RATE              = 0x08,
    SPAWNGROUP_FLAG_ESCORTQUESTNPC                  = 0x10,
    SPAWNGROUP_FLAG_DESPAWN_ON_CONDITION_FAILURE    = 0x20,

    SPAWNGROUP_FLAGS_ALL = (SPAWNGROUP_FLAG_SYSTEM | SPAWNGROUP_FLAG_COMPATIBILITY_MODE | SPAWNGROUP_FLAG_MANUAL_SPAWN
                            | SPAWNGROUP_FLAG_DYNAMIC_SPAWN_RATE | SPAWNGROUP_FLAG_ESCORTQUESTNPC | SPAWNGROUP_FLAG_DESPAWN_ON_CONDITION_FAILURE)
};

struct SpawnGroupTemplateData
{
    uint32 groupId;
    std::string name;
    uint32 mapId;
    SpawnGroupFlags flags;
};

struct SpawnTrackingTemplateData
{
    uint32 SpawnTrackingId;
    uint32 MapId;
    uint32 PhaseId;
    uint32 PhaseGroup;
    uint8 PhaseUseFlags;
};

struct SpawnTrackingStateData
{
    bool Visible = true;
    Optional<uint32> StateSpellVisualId;
    Optional<uint16> StateAnimId;
    Optional<uint16> StateAnimKitId;
    std::vector<uint32> StateWorldEffects;
};

enum class SpawnTrackingState : uint8
{
    None        = 0,
    Active      = 1,
    Complete    = 2,
    Max
};

namespace Trinity { namespace Impl {
    template <typename T>
    struct SpawnObjectTypeForImpl { static_assert(!std::is_same<T,T>::value, "This type does not have an associated spawn type!"); };
    template <> struct SpawnObjectTypeForImpl<Creature> { static constexpr SpawnObjectType value = SPAWN_TYPE_CREATURE; };
    template <> struct SpawnObjectTypeForImpl<GameObject> { static constexpr SpawnObjectType value = SPAWN_TYPE_GAMEOBJECT; };
    template <> struct SpawnObjectTypeForImpl<AreaTrigger> { static constexpr SpawnObjectType value = SPAWN_TYPE_AREATRIGGER; };
}}

struct SpawnData;
struct SpawnMetadata
{
    static constexpr bool TypeInMask(SpawnObjectType type, SpawnObjectTypeMask mask) { return ((1 << type) & mask); }
    static constexpr bool TypeHasData(SpawnObjectType type) { return (type < NUM_SPAWN_TYPES_WITH_DATA); }
    static constexpr bool TypeIsValid(SpawnObjectType type) { return (type < NUM_SPAWN_TYPES); }
    template <typename T>
    static constexpr SpawnObjectType TypeFor = Trinity::Impl::SpawnObjectTypeForImpl<T>::value;

    SpawnData const* ToSpawnData() const { return TypeHasData(type) ? reinterpret_cast<SpawnData const*>(this) : nullptr; }

    SpawnObjectType const type;
    uint64 spawnId = 0;
    uint32 mapId = MAPID_INVALID;
    bool dbData = true;
    SpawnGroupTemplateData const* spawnGroupData = nullptr;
    SpawnTrackingTemplateData const* spawnTrackingData = nullptr;
    std::vector<uint32> spawnTrackingQuestObjectives;
    std::array<SpawnTrackingStateData, size_t(SpawnTrackingState::Max)> spawnTrackingStates;

    protected:
    SpawnMetadata(SpawnObjectType t) : type(t) {}
};

struct SpawnData : public SpawnMetadata
{
    uint32 id = 0; // entry in respective _template table
    Position spawnPoint;
    uint8 phaseUseFlags = 0;
    uint32 phaseId = 0;
    uint32 phaseGroup = 0;
    int32 terrainSwapMap = -1;
    uint32 poolId = 0;
    int32 spawntimesecs = 0;
    std::vector<Difficulty> spawnDifficulties;
    uint32 scriptId = 0;
    std::string StringId;

    protected:
    SpawnData(SpawnObjectType t) : SpawnMetadata(t) {}
};

enum LinkedRespawnType
{
    LINKED_RESPAWN_CREATURE_TO_CREATURE  = 0,
    LINKED_RESPAWN_CREATURE_TO_GO        = 1, // Creature is dependant on GameObject
    LINKED_RESPAWN_GO_TO_GO              = 2,
    LINKED_RESPAWN_GO_TO_CREATURE        = 3, // GameObject is dependant on Creature
};

#endif