#pragma once

#include "CoreMinimal.h"
#include "MCPHandler.h"
#include "MCPAssetFinder.h"
#include "MCPUtils.h"
#include "Materials/Material.h"
#include "Materials/MaterialInterface.h"
#include "Materials/MaterialInstanceConstant.h"
#include "Materials/MaterialExpressionScalarParameter.h"
#include "Materials/MaterialExpressionVectorParameter.h"
#include "Materials/MaterialExpressionTextureSampleParameter2D.h"
#include "Materials/MaterialExpressionStaticSwitchParameter.h"
#include "Factories/MaterialInstanceConstantFactoryNew.h"
#include "AssetToolsModule.h"
#include "IAssetTools.h"
#include "Engine/Texture.h"
#include "UMCPHandler_CreateMaterialInstanceAsset.generated.h"


// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------

UCLASS()
class UMCPHandler_CreateMaterialInstanceAsset : public UObject, public IMCPHandler
{
	GENERATED_BODY()

public:
	UPROPERTY(meta=(Description="Name for the new Material Instance asset"))
	FString Name;

	UPROPERTY(meta=(Description="Package path where the asset will be created (must start with /Game)"))
	FString PackagePath;

	UPROPERTY(meta=(Description="Parent material name or path (Material or Material Instance)"))
	FString ParentMaterial;

	virtual FString GetDescription() const override
	{
		return TEXT("Create a new Material Instance Constant asset with a specified parent material.");
	}

	virtual void Handle(const FJsonObject* Json, FJsonObject* Result) override
	{
		// Validate packagePath starts with /Game
		if (!PackagePath.StartsWith(TEXT("/Game")))
		{
			return MCPUtils::MakeErrorJson(Result, TEXT("packagePath must start with '/Game'"));
		}

		// Check if asset already exists
		{
			MCPAssets<UMaterialInstanceConstant> ExistCheck;
			if (!ExistCheck.Exact(Name).Errors(Result).EAny().Info()) return;
		}

		// Load parent material — try as Material first, then as Material Instance
		UMaterialInterface* ParentMaterialObj = nullptr;
		{
			MCPAssets<UMaterial> MatAssets;
			if (MatAssets.Exact(ParentMaterial).ETwo().Load() && !MatAssets.Objects().IsEmpty())
			{
				ParentMaterialObj = MatAssets.Object();
			}
			else
			{
				MCPAssets<UMaterialInstanceConstant> MIAssets;
				if (MIAssets.Exact(ParentMaterial).ETwo().Load() && !MIAssets.Objects().IsEmpty())
				{
					ParentMaterialObj = MIAssets.Object();
				}
			}
		}

		if (!ParentMaterialObj)
		{
			// Also try LoadObject as a fallback with the raw path
			ParentMaterialObj = LoadObject<UMaterialInterface>(nullptr, *ParentMaterial);
		}

		if (!ParentMaterialObj)
		{
			return MCPUtils::MakeErrorJson(Result, FString::Printf(
				TEXT("Parent material '%s' not found. Provide a Material or Material Instance name/path."),
				*ParentMaterial));
		}

		UE_LOG(LogTemp, Display, TEXT("BlueprintMCP: Creating Material Instance '%s' in '%s' with parent '%s'"),
			*Name, *PackagePath, *ParentMaterialObj->GetName());

		// Create via factory + AssetTools
		IAssetTools& AssetTools = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools").Get();
		UMaterialInstanceConstantFactoryNew* Factory = NewObject<UMaterialInstanceConstantFactoryNew>();

		UObject* NewAsset = AssetTools.CreateAsset(Name, PackagePath, UMaterialInstanceConstant::StaticClass(), Factory);
		if (!NewAsset)
		{
			return MCPUtils::MakeErrorJson(Result, FString::Printf(TEXT("Failed to create Material Instance asset '%s' in '%s'"), *Name, *PackagePath));
		}

		UMaterialInstanceConstant* MI = Cast<UMaterialInstanceConstant>(NewAsset);
		if (!MI)
		{
			return MCPUtils::MakeErrorJson(Result, TEXT("Created asset is not a UMaterialInstanceConstant"));
		}

		// Set parent
		MI->PreEditChange(nullptr);
		MI->Parent = ParentMaterialObj;
		MI->PostEditChange();

		// Save
		bool bSaved = MCPUtils::SaveGenericPackage(MI);


		UE_LOG(LogTemp, Display, TEXT("BlueprintMCP: Created Material Instance '%s' with parent '%s' (saved: %s)"),
			*Name, *ParentMaterialObj->GetName(), bSaved ? TEXT("true") : TEXT("false"));

		Result->SetStringField(TEXT("path"), MI->GetPathName());
		Result->SetStringField(TEXT("parent"), ParentMaterialObj->GetPathName());
		Result->SetBoolField(TEXT("saved"), bSaved);
	}
};