// Fill out your copyright notice in the Description page of Project Settings.

#include "EleriDataAssetFactories.h"

#include "EleriAssetCategory.h"

#include "Engine/DataAsset.h"

#include "ProjectEleri/Ai/NpcScheduleAsset.h"
#include "ProjectEleri/Animation/AnimationDataAsset.h"
#include "ProjectEleri/Data/BazarSettingsDataAsset.h"
#include "ProjectEleri/Data/FaceExpressionDataAsset.h"
#include "ProjectEleri/Data/Minigames/PotionSortDataAsset.h"
#include "ProjectEleri/Data/NpcDataAsset.h"
#include "ProjectEleri/Data/WeatherPresetDataAsset.h"
#include "ProjectEleri/DialogueSystem/QuestDatabase.h"
#include "ProjectEleri/DialogueSystem/SpeechDataAsset.h"
#include "ProjectEleri/GameEventSystem/GameEventDataAsset.h"
#include "ProjectEleri/Items/DataAssets/ItemDataAsset.h"
#include "ProjectEleri/Items/ItemContainer.h"
#include "ProjectEleri/QuestSystem/QuestDataAsset.h"

#define LOCTEXT_NAMESPACE "EleriDataAssetFactories"

/*-----------------------------------------------------------------------------
	Shared behaviour
-----------------------------------------------------------------------------*/

UEleriDataAssetFactory::UEleriDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	// What these make is always a data asset, and the class is the only thing that separates one from
	// the next, so that is all a subclass has to set. bCreateNew is what admits a factory to the Add
	// menu, and bEditAfterNew is what opens the asset once it exists, which for a data asset means the
	// details panel a fresh one has to be filled in through.
	bCreateNew = true;
	bEditAfterNew = true;
	bEditorImport = false;
}

bool UEleriDataAssetFactory::ConfigureProperties()
{
	// Nothing to ask about. Each factory makes the one class it is named after, so the class picker the
	// engine would otherwise open here would be a dialog with a single entry in it.
	return true;
}

uint32 UEleriDataAssetFactory::GetMenuCategories() const
{
	return EleriAssetCategory::GetLegacyCategoryBit();
}

UObject* UEleriDataAssetFactory::FactoryCreateNew(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, UObject* Context, FFeedbackContext* Warn)
{
	// SupportedClass rather than InClass: the Content Browser runs whichever factory it was asked to,
	// and going through this factory's own member keeps the two from ever disagreeing.
	UClass* ClassToCreate = SupportedClass.Get();
	if (!ensureMsgf(ClassToCreate, TEXT("%s has no supported class, so there is nothing to create"), *GetName()))
	{
		return nullptr;
	}

	return NewObject<UDataAsset>(InParent, ClassToCreate, InName, Flags | RF_Transactional);
}

/*-----------------------------------------------------------------------------
	Items
-----------------------------------------------------------------------------*/

UEleriItemDataAssetFactory::UEleriItemDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UItemDataAsset::StaticClass();
}

FText UEleriItemDataAssetFactory::GetDisplayName() const
{
	return LOCTEXT("ItemFactoryName", "Item");
}

UEleriItemContainerFactory::UEleriItemContainerFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UItemContainer::StaticClass();
}

FText UEleriItemContainerFactory::GetDisplayName() const
{
	return LOCTEXT("ItemContainerFactoryName", "Item Container");
}

/*-----------------------------------------------------------------------------
	Quests and dialogue
-----------------------------------------------------------------------------*/

UEleriQuestDataAssetFactory::UEleriQuestDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UQuestDataAsset::StaticClass();
}

FText UEleriQuestDataAssetFactory::GetDisplayName() const
{
	return LOCTEXT("QuestFactoryName", "Quest");
}

UEleriQuestDatabaseFactory::UEleriQuestDatabaseFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UQuestDatabase::StaticClass();
}

FText UEleriQuestDatabaseFactory::GetDisplayName() const
{
	return LOCTEXT("QuestDatabaseFactoryName", "Quest Database");
}

UEleriSpeechDataAssetFactory::UEleriSpeechDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = USpeechDataAsset::StaticClass();
}

FText UEleriSpeechDataAssetFactory::GetDisplayName() const
{
	return LOCTEXT("SpeechFactoryName", "Speech");
}

/*-----------------------------------------------------------------------------
	World events and weather
-----------------------------------------------------------------------------*/

UEleriGameEventDataAssetFactory::UEleriGameEventDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UGameEventDataAsset::StaticClass();
}

FText UEleriGameEventDataAssetFactory::GetDisplayName() const
{
	return LOCTEXT("GameEventFactoryName", "Game Event");
}

UEleriWeatherPresetDataAssetFactory::UEleriWeatherPresetDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UWeatherPresetDataAsset::StaticClass();
}

FText UEleriWeatherPresetDataAssetFactory::GetDisplayName() const
{
	return LOCTEXT("WeatherPresetFactoryName", "Weather Preset");
}

/*-----------------------------------------------------------------------------
	Characters
-----------------------------------------------------------------------------*/

UEleriFaceExpressionDataAssetFactory::UEleriFaceExpressionDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UFaceExpressionDataAsset::StaticClass();
}

FText UEleriFaceExpressionDataAssetFactory::GetDisplayName() const
{
	return LOCTEXT("FaceExpressionFactoryName", "Face Expression");
}

UEleriNpcDataAssetFactory::UEleriNpcDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UNpcDataAsset::StaticClass();
}

FText UEleriNpcDataAssetFactory::GetDisplayName() const
{
	return LOCTEXT("NpcFactoryName", "NPC");
}

UEleriNpcScheduleAssetFactory::UEleriNpcScheduleAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UNpcScheduleAsset::StaticClass();
}

FText UEleriNpcScheduleAssetFactory::GetDisplayName() const
{
	return LOCTEXT("NpcScheduleFactoryName", "NPC Schedule");
}

/*-----------------------------------------------------------------------------
	Settings, animation and minigames
-----------------------------------------------------------------------------*/

UEleriBazarSettingsDataAssetFactory::UEleriBazarSettingsDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UBazarSettingsDataAsset::StaticClass();
}

FText UEleriBazarSettingsDataAssetFactory::GetDisplayName() const
{
	return LOCTEXT("BazarSettingsFactoryName", "Bazar Settings");
}

UEleriAnimationDataAssetFactory::UEleriAnimationDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	SupportedClass = UAnimationDataAsset::StaticClass();
}

FText UEleriAnimationDataAssetFactory::GetDisplayName() const
{
	return LOCTEXT("AnimationFactoryName", "Animation");
}

UEleriPotionSortDataAssetFactory::UEleriPotionSortDataAssetFactory(const FObjectInitializer& ObjectInitializer)
	: Super(ObjectInitializer)
{
	// The concrete minigame rather than the base class the definition sits on: the base exists to be
	// inherited from, so offering to make a bare one would only ever produce an asset with nothing in it.
	SupportedClass = UPotionSortDataAsset::StaticClass();
}

FText UEleriPotionSortDataAssetFactory::GetDisplayName() const
{
	return LOCTEXT("PotionSortFactoryName", "Potion Sort Minigame");
}

#undef LOCTEXT_NAMESPACE