using SepCore.Components;
using SepCore.Entity;
using Unity.Mathematics;
using UnityEngine;

namespace SepCore.Simulation
{
    public sealed partial class SimulationWorld
    {
        #region Entity To Sim Data

        private static EnemySimData CreateEnemyInitialSimData(EnemyBase enemy, EnemyData enemyData)
        {
            Transform enemyTransform = enemy.CachedTransform;
            MovementComponent movementComponent = enemy.GetComponent<MovementComponent>();

            float speed = 0f;
            if (enemyData != null)
            {
                speed = enemyData.SpeedBase;
            }
            else if (movementComponent != null)
            {
                speed = movementComponent.Speed;
            }

            float attackRange = enemy.AttackRange > 0f
                ? enemy.AttackRange
                : EnemyAttackSim.DefaultAttackRange;

            return new EnemySimData
            {
                EntityId = enemy.Id,
                Position = enemyTransform.position,
                Forward = enemyTransform.forward,
                Rotation = enemyTransform.rotation,
                Speed = speed,
                AttackRange = attackRange,
                AvoidEnemyOverlap = movementComponent != null && movementComponent.AvoidEnemyOverlap,
                EnemyBodyRadius = movementComponent != null ? movementComponent.EnemyBodyRadius : 0.45f,
                SeparationIterations = movementComponent != null ? movementComponent.SeparationIterations : 2,
                State = EnemyBehaviorSim.StateIdle
            };
        }

        private static ProjectileSimData CreateProjectileInitialSimData(EntityBase projectileEntity, object userData)
        {
            Vector3 forward = projectileEntity.CachedTransform.forward;
            int ownerEntityId = 0;
            Vector3 velocity = Vector3.zero;
            float speed = 0f;
            float lifeTime = 0f;

            if (userData is EnemyProjectileData enemyProjectileData)
            {
                ownerEntityId = enemyProjectileData.OwnerEntityId;

                Vector3 direction = enemyProjectileData.Direction;
                direction.y = 0f;
                if (direction.sqrMagnitude > Mathf.Epsilon)
                {
                    direction.Normalize();
                    forward = direction;
                }
                else if (forward.sqrMagnitude > Mathf.Epsilon)
                {
                    forward = forward.normalized;
                }
                else
                {
                    forward = Vector3.forward;
                }

                speed = Mathf.Max(0f, enemyProjectileData.Speed);
                velocity = forward * speed;
                lifeTime = Mathf.Max(0f, enemyProjectileData.LifeTime);
            }

            return new ProjectileSimData
            {
                EntityId = projectileEntity.Id,
                OwnerEntityId = ownerEntityId,
                Position = projectileEntity.CachedTransform.position,
                Forward = forward,
                Velocity = velocity,
                LifeTime = lifeTime,
                Age = 0f,
                Active = true
            };
        }

        private static PickupSimData CreatePickupInitialSimData(EntityBase pickupEntity)
        {
            return new PickupSimData
            {
                EntityId = pickupEntity.Id,
                Position = pickupEntity.CachedTransform.position,
                PickupRadius = 0.35f
            };
        }

        #endregion

        #region Component Conversion

        private static float3 ToFloat3(Vector3 value)
        {
            return new float3(value.x, value.y, value.z);
        }

        private static Vector3 ToVector3(float3 value)
        {
            return new Vector3(value.x, value.y, value.z);
        }

        private static quaternion ToQuaternion(Quaternion value)
        {
            return new quaternion(value.x, value.y, value.z, value.w);
        }

        private static Quaternion ToQuaternion(quaternion value)
        {
            return new Quaternion(value.value.x, value.value.y, value.value.z, value.value.w);
        }

        #endregion
    }
}