// Copyright 2020 Mookie. All Rights Reserved.

#include "EBBullet.h"
#include "EBBarrel.h"
#include "EBUnitConversions.h"
#include "Engine/World.h"
#include "Engine/Engine.h"
#include "PhysicalMaterials/PhysicalMaterial.h"
#include "DrawDebugHelpers.h"

// Initialize static debug counter
int32 AEBBullet::DebugMessageCounter = 0;

void AEBBullet::CreateDebugImpactWidget(FVector Location, bool bRicochet, bool bPenetration, FVector ImpactVelocity, float PenetrationDepth, UPhysicalMaterial* Material)
{
	if (!DebugEnabled || !DebugImpact)
	{
		return;
	}

	UEBBarrel* Barrel = GetFiringBarrel();
	if (!Barrel || !Barrel->DebugImpactInfo)
	{
		return;
	}

	UWorld* World = GetWorld();
	if (!World)
	{
		return;
	}

	// Add to debug tracking
	DebugImpactLocations.Add(Location);
	DebugImpactTimes.Add(World->GetTimeSeconds());

	// Clean up old debug data
	float CurrentTime = World->GetTimeSeconds();
	for (int32 i = DebugImpactLocations.Num() - 1; i >= 0; i--)
	{
		if (CurrentTime - DebugImpactTimes[i] > ImpactDebugTime)
		{
			DebugImpactLocations.RemoveAt(i);
			DebugImpactTimes.RemoveAt(i);
		}
	}

	// Build comprehensive debug information
	FString ImpactType;
	FLinearColor ImpactColor;
	if (bRicochet)
	{
		ImpactType = TEXT("RICOCHET");
		ImpactColor = ImpactColorRicochet;
	}
	else if (bPenetration)
	{
		ImpactType = TEXT("PENETRATION");
		ImpactColor = ImpactColorPenetration;
	}
	else
	{
		ImpactType = TEXT("STOPPED");
		ImpactColor = ImpactColorStopped;
	}

	FString MaterialName = Material ? Material->GetName() : TEXT("Unknown");
	float VelocityCMPS = ImpactVelocity.Size();
	float VelocityMPS = FEBUnitConversions::CMPSToMPS(VelocityCMPS);
	float VelocityKMH = FEBUnitConversions::CMPSToKMH(VelocityCMPS);
	float KineticEnergy = FEBUnitConversions::CalculateKineticEnergyJoules(GetEffectiveMass(), VelocityMPS);

	FString DebugInfo = FString::Printf(TEXT(
		"Impact: %s | Material: %s | Velocity: %.1f m/s (%.1f km/h) | Mass: %.3f kg | Diameter: %.2f cm | Energy: %.1f J | Penetration: %.2f cm"
	), 
		*ImpactType,
		*MaterialName,
		VelocityMPS,
		VelocityKMH,
		GetEffectiveMass(),
		GetEffectiveDiameter(),
		KineticEnergy,
		PenetrationDepth
	);

	// Fix color conversion for display
	uint8 R = FMath::Clamp(FMath::RoundToInt(ImpactColor.R * 255.0f), 0, 255);
	uint8 G = FMath::Clamp(FMath::RoundToInt(ImpactColor.G * 255.0f), 0, 255);
	uint8 B = FMath::Clamp(FMath::RoundToInt(ImpactColor.B * 255.0f), 0, 255);
	FColor DisplayColor(R, G, B);

	// Display debug information
	if (UseOnScreenMessages && GEngine)
	{
		// Manage message count
		if (DebugMessageCounter > MaxOnScreenMessages)
		{
			DebugMessageCounter = 0;
		}
		
		GEngine->AddOnScreenDebugMessage(DebugMessageCounter++, ImpactDebugTime, 
			DisplayColor, DebugInfo);
	}

	if (UseWorldSpaceText)
	{
		DrawDebugString(World, Location + FVector(0, 0, 50), DebugInfo, nullptr, 
			DisplayColor, ImpactDebugTime, false, WorldTextScale);
	}
}

void AEBBullet::DrawTrajectoryDebug(FVector StartLocation, FVector EndLocation, FVector CurrentVelocity, float DeltaTime)
{
	if (!DebugEnabled || !DebugTrajectory)
	{
		return;
	}

	UWorld* World = GetWorld();
	if (!World)
	{
		return;
	}

	float CurrentTime = World->GetTimeSeconds();
	
	// Add trajectory point
	if (ShowTrail)
	{
		DebugTrajectoryPoints.Add(StartLocation);
		DebugTrajectoryTimes.Add(CurrentTime);
		
		// Clean up old trajectory points
		for (int32 i = DebugTrajectoryPoints.Num() - 1; i >= 0; i--)
		{
			if (CurrentTime - DebugTrajectoryTimes[i] > DebugTrailTime)
			{
				DebugTrajectoryPoints.RemoveAt(i);
				DebugTrajectoryTimes.RemoveAt(i);
			}
		}
		
		// Draw trajectory trail
		if (DebugTrajectoryPoints.Num() > 1)
		{
			for (int32 i = 1; i < DebugTrajectoryPoints.Num(); i++)
			{
				float Alpha = FMath::Clamp((CurrentTime - DebugTrajectoryTimes[i]) / DebugTrailTime, 0.0f, 1.0f);
				float VelocityNormalized = FMath::Clamp(CurrentVelocity.Size() / 100000.0f, 0.0f, 1.0f); // Normalize to ~1000m/s
				
				FLinearColor TrailColor = FMath::Lerp(DebugTrailColorSlow, DebugTrailColorFast, VelocityNormalized);
				TrailColor.A = 1.0f - Alpha;
				
				// Fix color conversion - ensure valid range [0-255]
				uint8 R = FMath::Clamp(FMath::RoundToInt(TrailColor.R * 255.0f), 0, 255);
				uint8 G = FMath::Clamp(FMath::RoundToInt(TrailColor.G * 255.0f), 0, 255);
				uint8 B = FMath::Clamp(FMath::RoundToInt(TrailColor.B * 255.0f), 0, 255);
				uint8 A = FMath::Clamp(FMath::RoundToInt(TrailColor.A * 255.0f), 0, 255);
				
				float LineThickness = DebugTrailWidth > 0 ? DebugTrailWidth : 1.0f;
				DrawDebugLine(World, DebugTrajectoryPoints[i-1], DebugTrajectoryPoints[i], 
					FColor(R, G, B, A), false, -1, 0, LineThickness);
			}
		}
	}
	
	// Show velocity vectors
	if (ShowVelocityVectors)
	{
		FVector VelocityVector = CurrentVelocity * VelocityVectorScale;
		DrawDebugDirectionalArrow(World, StartLocation, StartLocation + VelocityVector, 
			50.0f, FColor::Blue, false, DebugTrailTime, 0, 2.0f);
		
		// Add velocity magnitude text
		FString VelocityText = FString::Printf(TEXT("%.1f m/s"), 
			FEBUnitConversions::CMPSToMPS(CurrentVelocity.Size()));
		DrawDebugString(World, StartLocation + FVector(0, 0, 30), VelocityText, nullptr, 
			FColor::Blue, DebugTrailTime, false, WorldTextScale);
	}
	
	// Show path prediction
	if (ShowPathPrediction && PathPredictionSteps > 0)
	{
		FVector PredictLocation = StartLocation;
		FVector PredictVelocity = CurrentVelocity;
		float PredictDeltaTime = DeltaTime * 5.0f; // Predict further ahead
		
		for (int32 i = 0; i < PathPredictionSteps; i++)
		{
			FVector NextLocation = PredictLocation + PredictVelocity * PredictDeltaTime;
			
			// Apply gravity and drag prediction (simplified)
			FVector GravityForce = OverrideGravity ? Gravity : FVector(0, 0, -980);
			PredictVelocity += GravityForce * PredictDeltaTime;
			
			DrawDebugLine(World, PredictLocation, NextLocation, FColor::Yellow, false, 
				DebugTrailTime, 0, 1.0f);
			DrawDebugSphere(World, NextLocation, 2.0f, 8, FColor::Yellow, false, DebugTrailTime);
			
			PredictLocation = NextLocation;
		}
	}
}

void AEBBullet::DrawXRayTrajectory(FVector EntryPoint, FVector ExitPoint, FVector PenetrationDirection, float PenetrationDepth, UPhysicalMaterial* Material)
{
	if (!DebugEnabled || !DebugTrajectory || !ShowXRayTrajectory)
	{
		return;
	}

	UWorld* World = GetWorld();
	if (!World)
	{
		return;
	}

	// Draw entry point marker
	uint8 XR = FMath::Clamp(FMath::RoundToInt(XRayTrajectoryColor.R * 255.0f), 0, 255);
	uint8 XG = FMath::Clamp(FMath::RoundToInt(XRayTrajectoryColor.G * 255.0f), 0, 255);
	uint8 XB = FMath::Clamp(FMath::RoundToInt(XRayTrajectoryColor.B * 255.0f), 0, 255);
	uint8 XA = FMath::Clamp(FMath::RoundToInt(XRayTrajectoryColor.A * 255.0f), 0, 255);
	FColor XRayColor(XR, XG, XB, XA);

	DrawDebugSphere(World, EntryPoint, 3.0f, 8, XRayColor, false, DebugTrailTime);
	
	// Draw internal trajectory path (X-ray view)
	FVector InternalTrajectory = EntryPoint + PenetrationDirection * PenetrationDepth;
	
	// Draw dashed line to represent path through material
	int32 DashCount = FMath::Max(1, FMath::RoundToInt(PenetrationDepth / 5.0f)); // Dash every 5cm
	for (int32 i = 0; i < DashCount; i++)
	{
		float StartRatio = (float)i / DashCount;
		float EndRatio = FMath::Min(1.0f, (float)(i + 0.7f) / DashCount); // 70% dash, 30% gap
		
		FVector DashStart = FMath::Lerp(EntryPoint, InternalTrajectory, StartRatio);
		FVector DashEnd = FMath::Lerp(EntryPoint, InternalTrajectory, EndRatio);
		
		DrawDebugLine(World, DashStart, DashEnd, XRayColor, false, DebugTrailTime, 0, 2.0f);
	}
	
	// Draw exit point if it exists
	if (!ExitPoint.IsNearlyZero() && !EntryPoint.Equals(ExitPoint, 1.0f))
	{
		uint8 PR = FMath::Clamp(FMath::RoundToInt(PenetrationTrajectoryColor.R * 255.0f), 0, 255);
		uint8 PG = FMath::Clamp(FMath::RoundToInt(PenetrationTrajectoryColor.G * 255.0f), 0, 255);
		uint8 PB = FMath::Clamp(FMath::RoundToInt(PenetrationTrajectoryColor.B * 255.0f), 0, 255);
		uint8 PA = FMath::Clamp(FMath::RoundToInt(PenetrationTrajectoryColor.A * 255.0f), 0, 255);
		FColor PenetrationColor(PR, PG, PB, PA);
		
		DrawDebugSphere(World, ExitPoint, 3.0f, 8, PenetrationColor, false, DebugTrailTime);
		
		// Draw penetration path from calculated internal point to actual exit
		DrawDebugLine(World, InternalTrajectory, ExitPoint, PenetrationColor, false, DebugTrailTime, 0, 2.0f);
	}
	
	// Add material and penetration info
	if (Material && UseWorldSpaceText)
	{
		FString MaterialInfo = FString::Printf(TEXT("Material: %s\nPenetration: %.1f cm\nPath Length: %.1f cm"), 
			*Material->GetName(), 
			PenetrationDepth,
			FVector::Dist(EntryPoint, ExitPoint));
		
		DrawDebugString(World, EntryPoint + FVector(0, 0, 25), MaterialInfo, nullptr, 
			XRayColor, DebugTrailTime, false, WorldTextScale);
	}
}

void AEBBullet::DrawImpactDebug(FVector ImpactLocation, FVector ImpactVelocity, FVector ImpactNormal, bool bRicochet, bool bPenetration, float PenetrationDepth, UPhysicalMaterial* Material)
{
	if (!DebugEnabled || !DebugImpact)
	{
		return;
	}

	UWorld* World = GetWorld();
	if (!World)
	{
		return;
	}

	// Choose color based on impact type
	FLinearColor ImpactColor;
	if (bRicochet)
	{
		ImpactColor = ImpactColorRicochet;
	}
	else if (bPenetration)
	{
		ImpactColor = ImpactColorPenetration;
	}
	else
	{
		ImpactColor = ImpactColorStopped;
	}

	// Fix color conversion
	uint8 R = FMath::Clamp(FMath::RoundToInt(ImpactColor.R * 255.0f), 0, 255);
	uint8 G = FMath::Clamp(FMath::RoundToInt(ImpactColor.G * 255.0f), 0, 255);
	uint8 B = FMath::Clamp(FMath::RoundToInt(ImpactColor.B * 255.0f), 0, 255);
	FColor DebugColor(R, G, B);

	// Show impact points
	if (ShowImpactPoints)
	{
		DrawDebugSphere(World, ImpactLocation, ImpactPointSize, 12, DebugColor, false, ImpactDebugTime);
	}

	// Show impact normals
	if (ShowImpactNormals)
	{
		DrawDebugDirectionalArrow(World, ImpactLocation, ImpactLocation + ImpactNormal * 50.0f, 
			20.0f, DebugColor, false, ImpactDebugTime, 0, 2.0f);
	}

	// Show penetration depth
	if (ShowPenetrationDepth && bPenetration)
	{
		FVector PenetrationVector = -ImpactNormal * PenetrationDepth;
		DrawDebugLine(World, ImpactLocation, ImpactLocation + PenetrationVector, 
			FColor::Green, false, ImpactDebugTime, 0, 3.0f);
		
		FString PenetrationText = FString::Printf(TEXT("Pen: %.1f cm"), PenetrationDepth);
		DrawDebugString(World, ImpactLocation + PenetrationVector + FVector(0, 0, 20), 
			PenetrationText, nullptr, FColor::Green, ImpactDebugTime, false, WorldTextScale);
	}

	// Show ricochet angles
	if (ShowRicochetAngles && bRicochet)
	{
		FVector ReflectedVelocity = ImpactVelocity - 2 * FVector::DotProduct(ImpactVelocity, ImpactNormal) * ImpactNormal;
		DrawDebugDirectionalArrow(World, ImpactLocation, ImpactLocation + ReflectedVelocity.GetSafeNormal() * 75.0f, 
			30.0f, FColor::Yellow, false, ImpactDebugTime, 0, 2.0f);
		
		float RicochetAngle = FMath::Acos(FVector::DotProduct(-ImpactVelocity.GetSafeNormal(), ImpactNormal));
		FString AngleText = FString::Printf(TEXT("Angle: %.1f°"), FMath::RadiansToDegrees(RicochetAngle));
		DrawDebugString(World, ImpactLocation + FVector(0, 0, 40), AngleText, nullptr, 
			FColor::Yellow, ImpactDebugTime, false, WorldTextScale);
	}

	// Show material information
	if (ShowMaterialInfo && Material)
	{
		FString MaterialInfo = FString::Printf(TEXT("Material: %s"), *Material->GetName());
		DrawDebugString(World, ImpactLocation + FVector(0, 0, 60), MaterialInfo, nullptr, 
			DebugColor, ImpactDebugTime, false, WorldTextScale);
	}
}

void AEBBullet::DrawPhysicsDebug(FVector Location, FVector DragForce, FVector GravityForce, FVector WindForce, float AirDensity, float SpeedOfSound)
{
	if (!DebugEnabled || !DebugPhysics)
	{
		return;
	}

	UWorld* World = GetWorld();
	if (!World)
	{
		return;
	}

	// Show drag forces
	if (ShowDragForces && !DragForce.IsNearlyZero())
	{
		FVector DragVector = DragForce * ForceVectorScale;
		DrawDebugDirectionalArrow(World, Location, Location + DragVector, 
			10.0f, FColor::Red, false, PhysicsDebugTime, 0, 1.5f);
		
		FString DragText = FString::Printf(TEXT("Drag: %.1f N"), DragForce.Size());
		DrawDebugString(World, Location + DragVector + FVector(0, 0, 10), DragText, nullptr, 
			FColor::Red, PhysicsDebugTime, false, WorldTextScale);
	}

	// Show gravity effect
	if (ShowGravityEffect && !GravityForce.IsNearlyZero())
	{
		FVector GravityVector = GravityForce * ForceVectorScale;
		DrawDebugDirectionalArrow(World, Location, Location + GravityVector, 
			10.0f, FColor::Purple, false, PhysicsDebugTime, 0, 1.5f);
		
		FString GravityText = FString::Printf(TEXT("Gravity: %.1f N"), GravityForce.Size());
		DrawDebugString(World, Location + GravityVector + FVector(0, 0, 10), GravityText, nullptr, 
			FColor::Purple, PhysicsDebugTime, false, WorldTextScale);
	}

	// Show wind effect
	if (ShowWindEffect && !WindForce.IsNearlyZero())
	{
		FVector WindVector = WindForce * ForceVectorScale;
		DrawDebugDirectionalArrow(World, Location, Location + WindVector, 
			10.0f, FColor::Cyan, false, PhysicsDebugTime, 0, 1.5f);
		
		FString WindText = FString::Printf(TEXT("Wind: %.1f N"), WindForce.Size());
		DrawDebugString(World, Location + WindVector + FVector(0, 0, 10), WindText, nullptr, 
			FColor::Cyan, PhysicsDebugTime, false, WorldTextScale);
	}

	// Show atmospheric data
	if (ShowAtmosphericData)
	{
		FString AtmosphericInfo = FString::Printf(TEXT(
			"Air Density: %.3f kg/m³\nSpeed of Sound: %.1f m/s\nAltitude: %.1f m"
		), 
			AirDensity, 
			FEBUnitConversions::CMPSToMPS(SpeedOfSound),
			FEBUnitConversions::CMToM(GetAltitude(World, Location))
		);
		
		DrawDebugString(World, Location + FVector(0, 0, 80), AtmosphericInfo, nullptr, 
			FColor::White, PhysicsDebugTime, false, WorldTextScale);
	}
}

void AEBBullet::DrawBallisticsDebug(FVector Location, FVector BulletVelocity, float KineticEnergy, float DragCoefficient, float MachNumber)
{
	if (!DebugEnabled || !DebugBallistics)
	{
		return;
	}

	UWorld* World = GetWorld();
	if (!World)
	{
		return;
	}

	// Show energy calculations
	if (ShowEnergyCalculations)
	{
		FString EnergyInfo = FString::Printf(TEXT(
			"Kinetic Energy: %.1f J\nMomentum: %.3f kg⋅m/s\nPower: %.1f W"
		), 
			KineticEnergy,
			GetEffectiveMass() * FEBUnitConversions::CMPSToMPS(BulletVelocity.Size()),
			KineticEnergy * BulletVelocity.Size() / 100.0f // Simplified power calculation
		);
		
		DrawDebugString(World, Location + FVector(0, 0, 100), EnergyInfo, nullptr, 
			FColor::Orange, BallisticsDebugTime, false, WorldTextScale);
	}

	// Show mathematical comparison
	if (ShowMathematicalComparison && UseMathematicalPhysics)
	{
		FString MathInfo = FString::Printf(TEXT(
			"Mathematical Mode: ON\nDrag Coefficient: %.3f\nMach Number: %.2f"
		), 
			DragCoefficient,
			MachNumber
		);
		
		DrawDebugString(World, Location + FVector(0, 0, 120), MathInfo, nullptr, 
			FColor::Green, BallisticsDebugTime, false, WorldTextScale);
	}

	// Show ballistic coefficient
	if (ShowBallisticCoefficient)
	{
		float BallisticCoefficient = GetEffectiveMass() / (DragCoefficient * GetEffectiveDiameter() * GetEffectiveDiameter());
		FString BCInfo = FString::Printf(TEXT("Ballistic Coefficient: %.3f"), BallisticCoefficient);
		
		DrawDebugString(World, Location + FVector(0, 0, 140), BCInfo, nullptr, 
			FColor::Magenta, BallisticsDebugTime, false, WorldTextScale);
	}
}

void AEBBullet::DrawSpallDebug(FVector ImpactLocation, FVector ImpactVelocity, FVector ImpactNormal, TArray<FVector> FragmentVelocities)
{
	if (!DebugEnabled || !DebugSpalling)
	{
		return;
	}

	UWorld* World = GetWorld();
	if (!World)
	{
		return;
	}

	// Fix color conversion for spall colors
	uint8 PR = FMath::Clamp(FMath::RoundToInt(SpallColorPrimary.R * 255.0f), 0, 255);
	uint8 PG = FMath::Clamp(FMath::RoundToInt(SpallColorPrimary.G * 255.0f), 0, 255);
	uint8 PB = FMath::Clamp(FMath::RoundToInt(SpallColorPrimary.B * 255.0f), 0, 255);
	FColor PrimaryColor(PR, PG, PB);
	
	uint8 FR = FMath::Clamp(FMath::RoundToInt(SpallColorFragment.R * 255.0f), 0, 255);
	uint8 FG = FMath::Clamp(FMath::RoundToInt(SpallColorFragment.G * 255.0f), 0, 255);
	uint8 FB = FMath::Clamp(FMath::RoundToInt(SpallColorFragment.B * 255.0f), 0, 255);
	FColor FragmentColor(FR, FG, FB);

	// Show spall generation
	if (ShowSpallGeneration)
	{
		DrawDebugSphere(World, ImpactLocation, 8.0f, 16, PrimaryColor, false, SpallDebugTime);
		
		FString SpallInfo = FString::Printf(TEXT("Spall Generated: %d fragments"), FragmentVelocities.Num());
		DrawDebugString(World, ImpactLocation + FVector(0, 0, 70), SpallInfo, nullptr, 
			PrimaryColor, SpallDebugTime, false, WorldTextScale);
	}

	// Show fragment trajectories
	if (ShowFragmentTrajectories)
	{
		for (int32 i = 0; i < FragmentVelocities.Num(); i++)
		{
			FVector FragmentDirection = FragmentVelocities[i].GetSafeNormal();
			FVector FragmentEndpoint = ImpactLocation + FragmentDirection * 100.0f;
			
			DrawDebugDirectionalArrow(World, ImpactLocation, FragmentEndpoint, 
				15.0f, FragmentColor, false, SpallDebugTime, 0, 1.0f);
		}
	}

	// Show spall cones
	if (ShowSpallCones && FragmentVelocities.Num() > 0)
	{
		// Calculate cone parameters
		FVector ConeDirection = ImpactNormal;
		float ConeAngle = FMath::DegreesToRadians(45.0f); // 45 degree cone
		float ConeLength = 80.0f;
		
		// Draw cone outline
		int32 ConeSides = 8;
		TArray<FVector> ConePoints;
		
		for (int32 i = 0; i < ConeSides; i++)
		{
			float Angle = (2.0f * PI * i) / ConeSides;
			FVector RadialDirection = FVector(FMath::Cos(Angle), FMath::Sin(Angle), 0);
			FVector ConePoint = ImpactLocation + ConeDirection * ConeLength + RadialDirection * FMath::Tan(ConeAngle) * ConeLength;
			ConePoints.Add(ConePoint);
			
			// Draw lines from impact point to cone edge
			DrawDebugLine(World, ImpactLocation, ConePoint, PrimaryColor, false, SpallDebugTime, 0, 0.5f);
		}
		
		// Draw cone base
		for (int32 i = 0; i < ConeSides; i++)
		{
			int32 NextIndex = (i + 1) % ConeSides;
			DrawDebugLine(World, ConePoints[i], ConePoints[NextIndex], PrimaryColor, false, SpallDebugTime, 0, 0.5f);
		}
	}
}

void AEBBullet::DrawPerformanceDebug(FVector Location, int32 TraceCount, float FrameTime, int32 PooledBullets)
{
	if (!DebugEnabled || !DebugPerformance)
	{
		return;
	}

	UWorld* World = GetWorld();
	if (!World)
	{
		return;
	}

	FString PerformanceInfo;

	// Show trace count
	if (ShowTraceCount)
	{
		PerformanceInfo += FString::Printf(TEXT("Traces: %d\n"), TraceCount);
	}

	// Show frame timing
	if (ShowFrameTiming)
	{
		float FPS = FrameTime > 0 ? 1.0f / FrameTime : 0.0f;
		PerformanceInfo += FString::Printf(TEXT("Frame Time: %.2f ms (%.1f FPS)\n"), FrameTime * 1000.0f, FPS);
	}

	// Show pooling stats
	if (ShowPoolingStats && EnablePooling)
	{
		PerformanceInfo += FString::Printf(TEXT("Pooled Bullets: %d/%d\n"), PooledBullets, MaxPoolSize);
	}

	if (!PerformanceInfo.IsEmpty())
	{
		DrawDebugString(World, Location + FVector(0, 0, 160), PerformanceInfo, nullptr, 
			FColor::Cyan, PerformanceDebugTime, false, WorldTextScale);
	}
}

void AEBBullet::ClearDebugDisplay()
{
	DebugTrajectoryPoints.Empty();
	DebugTrajectoryTimes.Empty();
	DebugImpactLocations.Empty();
	DebugImpactTimes.Empty();
	DebugTraceCounter = 0;
	DebugMessageCounter = 0;
}

void AEBBullet::ToggleDebugCategory(const FString& CategoryName, bool bEnabled)
{
	if (CategoryName == TEXT("Trajectory"))
	{
		DebugTrajectory = bEnabled;
	}
	else if (CategoryName == TEXT("Impact"))
	{
		DebugImpact = bEnabled;
	}
	else if (CategoryName == TEXT("Physics"))
	{
		DebugPhysics = bEnabled;
	}
	else if (CategoryName == TEXT("Performance"))
	{
		DebugPerformance = bEnabled;
	}
	else if (CategoryName == TEXT("Ballistics"))
	{
		DebugBallistics = bEnabled;
	}
	else if (CategoryName == TEXT("Spalling"))
	{
		DebugSpalling = bEnabled;
	}
	else if (CategoryName == TEXT("Pooling"))
	{
		DebugPooling = bEnabled;
	}
}

FString AEBBullet::GetDebugInfoString() const
{
	return FString::Printf(TEXT(
		"Bullet Debug Info:\n"
		"Enabled: %s\n"
		"Trajectory: %s | Impact: %s | Physics: %s\n"
		"Performance: %s | Ballistics: %s | Spalling: %s\n"
		"Trace Count: %d | Active Trajectory Points: %d\n"
		"Active Impact Points: %d"
	),
		DebugEnabled ? TEXT("Yes") : TEXT("No"),
		DebugTrajectory ? TEXT("On") : TEXT("Off"),
		DebugImpact ? TEXT("On") : TEXT("Off"),
		DebugPhysics ? TEXT("On") : TEXT("Off"),
		DebugPerformance ? TEXT("On") : TEXT("Off"),
		DebugBallistics ? TEXT("On") : TEXT("Off"),
		DebugSpalling ? TEXT("On") : TEXT("Off"),
		DebugTraceCounter,
		DebugTrajectoryPoints.Num(),
		DebugImpactLocations.Num()
	);
}