using Unity.Entities;
using Unity.Mathematics;

// 컴포넌트는 순수 데이터만 저장하는 struct
public struct Spawner : IComponentData
{
    public Entity Prefab;        // 스폰할 프리팹 엔티티
    public float3 SpawnPosition; // 스폰 위치
    public float NextSpawnTime;  // 다음 스폰 시간
    public float SpawnRate;      // 스폰 간격
}

// 태그 컴포넌트: 데이터 없이 엔티티 분류용
public struct EnemyTag : IComponentData { }

using UnityEngine;
using Unity.Entities;

// Authoring: 에디터에서 값을 설정하는 MonoBehaviour
class SpawnerAuthoring : MonoBehaviour
{
    public GameObject Prefab;
    public float SpawnRate;
}

// Baker: Authoring 값을 ECS Component로 변환
class SpawnerBaker : Baker<SpawnerAuthoring>
{
    public override void Bake(SpawnerAuthoring authoring)
    {
        // 현재 엔티티 가져오기
        var entity = GetEntity(TransformUsageFlags.None);

        // ECS 컴포넌트를 엔티티에 추가
        AddComponent(entity, new Spawner
        {
            Prefab = GetEntity(authoring.Prefab, TransformUsageFlags.Dynamic),
            SpawnPosition = authoring.transform.position,
            NextSpawnTime = 0.0f,
            SpawnRate = authoring.SpawnRate
        });
    }
}

using Unity.Entities;
using Unity.Transforms;
using Unity.Burst;

[BurstCompile]
public partial struct SpawnerSystem : ISystem
{
    public void OnCreate(ref SystemState state) { }
    public void OnDestroy(ref SystemState state) { }

    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        // Spawner 컴포넌트를 가진 모든 엔티티 순회
        foreach (RefRW<Spawner> spawner in SystemAPI.Query<RefRW<Spawner>>())
        {
            // 스폰 시간 확인
            if (spawner.ValueRO.NextSpawnTime < SystemAPI.Time.ElapsedTime)
            {
                // 프리팹으로부터 새 엔티티 생성
                var newEntity = state.EntityManager.Instantiate(spawner.ValueRO.Prefab);

                // 위치 설정
                state.EntityManager.SetComponentData(newEntity,
                    LocalTransform.FromPosition(spawner.ValueRO.SpawnPosition));

                // 다음 스폰 시간 갱신
                spawner.ValueRW.NextSpawnTime =
                    (float)SystemAPI.Time.ElapsedTime + spawner.ValueRO.SpawnRate;
            }
        }
    }
}

// 오브젝트당 하나의 스크립트가 붙는 전통적 방식
// 1000발 = 1000번의 Update 호출 오버헤드
public class Bullet : MonoBehaviour
{
    public Vector3 velocity;
    public float lifetime = 3f;

    void Update()
    {
        transform.Translate(velocity * Time.deltaTime);
        lifetime -= Time.deltaTime;
        if (lifetime <= 0f)
            Destroy(gameObject);
    }
}

using Unity.Entities;
using Unity.Mathematics;

// 속도 컴포넌트
public struct Velocity : IComponentData
{
    public float3 Value;
}

// 수명 컴포넌트
public struct BulletLifetime : IComponentData
{
    public float RemainingTime;
}

// 총알 태그
public struct BulletTag : IComponentData { }

using Unity.Entities;
using Unity.Transforms;
using Unity.Burst;

[BurstCompile]
public partial struct BulletMovementSystem : ISystem
{
    public void OnCreate(ref SystemState state) { }
    public void OnDestroy(ref SystemState state) { }

    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        // IJobEntity로 멀티스레드 병렬 실행
        var moveJob = new MoveBulletJob
        {
            deltaTime = SystemAPI.Time.DeltaTime
        };
        state.Dependency = moveJob.ScheduleParallel(state.Dependency);
    }

    // Burst 컴파일 + 멀티코어 병렬 실행 Job
    [BurstCompile]
    private partial struct MoveBulletJob : IJobEntity
    {
        public float deltaTime;

        // Velocity를 가진 모든 엔티티에 대해 자동 병렬 실행
        public void Execute(ref LocalTransform transform, in Velocity velocity)
        {
            transform.Position += velocity.Value * deltaTime;
        }
    }
}

using Unity.Entities;
using Unity.Burst;

[BurstCompile]
public partial struct BulletLifetimeSystem : ISystem
{
    public void OnCreate(ref SystemState state) { }
    public void OnDestroy(ref SystemState state) { }

    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        // EntityCommandBuffer: 구조적 변경(생성/삭제)을 지연 실행
        var ecbSingleton = SystemAPI
            .GetSingleton<BeginSimulationEntityCommandBufferSystem.Singleton>();
        var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);

        // 수명 만료 총알 제거 Job
        var lifetimeJob = new DestroyExpiredBulletJob
        {
            deltaTime = SystemAPI.Time.DeltaTime,
            Ecb = ecb.AsParallelWriter()
        };
        state.Dependency = lifetimeJob.ScheduleParallel(state.Dependency);
    }

    [BurstCompile]
    private partial struct DestroyExpiredBulletJob : IJobEntity
    {
        public float deltaTime;
        public EntityCommandBuffer.ParallelWriter Ecb;

        public void Execute(
            [ChunkIndexInQuery] int chunkIndex,
            Entity entity,
            ref BulletLifetime lifetime)
        {
            // 남은 수명 감소
            lifetime.RemainingTime -= deltaTime;

            // 수명 만료시 삭제 명령 등록
            if (lifetime.RemainingTime <= 0f)
            {
                Ecb.DestroyEntity(chunkIndex, entity);
            }
        }
    }
}

using Unity.Entities;
using Unity.Transforms;
using Unity.Burst;

[BurstCompile]
public partial struct BulletSpawnerSystem : ISystem
{
    public void OnCreate(ref SystemState state) { }
    public void OnDestroy(ref SystemState state) { }

    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        // ECB로 메인 스레드 부하 없이 엔티티 생성
        var ecbSingleton = SystemAPI
            .GetSingleton<BeginSimulationEntityCommandBufferSystem.Singleton>();
        var ecb = ecbSingleton
            .CreateCommandBuffer(state.WorldUnmanaged).AsParallelWriter();

        // 스포너 Job 스케줄링
        new ProcessSpawnerJob
        {
            ElapsedTime = SystemAPI.Time.ElapsedTime,
            Ecb = ecb
        }.ScheduleParallel();
    }
}

[BurstCompile]
public partial struct ProcessSpawnerJob : IJobEntity
{
    public EntityCommandBuffer.ParallelWriter Ecb;
    public double ElapsedTime;

    private void Execute([ChunkIndexInQuery] int chunkIndex, ref Spawner spawner)
    {
        // 스폰 시간 확인
        if (spawner.NextSpawnTime < ElapsedTime)
        {
            // ECB를 통해 새 엔티티 생성
            var newEntity = Ecb.Instantiate(chunkIndex, spawner.Prefab);

            // 위치 설정
            Ecb.SetComponent(chunkIndex, newEntity,
                LocalTransform.FromPosition(spawner.SpawnPosition));

            // 다음 스폰 시간 갱신
            spawner.NextSpawnTime = (float)ElapsedTime + spawner.SpawnRate;
        }
    }
}