using System;

using Svelto.ECS;
using Svelto.ECS.EntityStructs;
using RobocraftX.Common;
using RobocraftX.Blocks.Scaling;
using Unity.Mathematics;

using GamecraftModdingAPI.Blocks;
using GamecraftModdingAPI.Utility;

namespace GamecraftModdingAPI
{
    /// <summary>
    /// A single (perhaps scaled) block. Properties may return default values if the block is removed and then setting them is ignored.
    /// </summary>
    public class Block
    {
        private static readonly PlacementEngine PlacementEngine = new PlacementEngine();
        private static readonly MovementEngine MovementEngine = new MovementEngine();
        private static readonly RotationEngine RotationEngine = new RotationEngine();
        private static readonly RemovalEngine RemovalEngine = new RemovalEngine();
        private static readonly BlockEngine BlockEngine = new BlockEngine();

        /// <summary>
        /// Place a new block at the given position. If scaled, position means the center of the block. The default block size is 0.2 in terms of position.
        /// Place blocks next to each other to connect them.
        /// The placed block will be a complete block with a placement grid and collision which will be saved along with the game.
        /// </summary>
        /// <param name="block">The block's type</param>
        /// <param name="color">The block's color</param>
        /// <param name="darkness">The block color's darkness (0-9) - 0 is default color</param>
        /// <param name="position">The block's position in the grid - default block size is 0.2</param>
        /// <param name="rotation">The block's rotation in degrees</param>
        /// <param name="uscale">The block's uniform scale - default scale is 1 (with 0.2 width)</param>
        /// <param name="scale">The block's non-uniform scale - 0 means <paramref name="uscale"/> is used</param>
        /// <param name="player">The player who placed the block</param>
        /// <returns>The placed block or null if failed</returns>
        public static Block PlaceNew(BlockIDs block, float3 position,
            float3 rotation = default, BlockColors color = BlockColors.Default, byte darkness = 0,
            int uscale = 1, float3 scale = default, Player player = null)
        {
            if (PlacementEngine.IsInGame && GameState.IsBuildMode())
            {
                try
                {
                    return new Block(PlacementEngine.PlaceBlock(block, color, darkness,
                        position, uscale, scale, player, rotation));
                }
                catch (Exception e)
                {
                    Logging.MetaDebugLog(e);
                }
            }

            return null;
        }

        /// <summary>
        /// Returns the most recently placed block.
        /// </summary>
        /// <returns>The block object</returns>
        public static Block GetLastPlacedBlock()
        {
            return new Block(BlockIdentifiers.LatestBlockID);
        }

        public Block(EGID id)
        {
            Id = id;
        }

        public Block(uint id)
        {
            Id = new EGID(id, CommonExclusiveGroups.OWNED_BLOCKS_GROUP);
        }
        
        public EGID Id { get; }

        /// <summary>
        /// The block's current position or zero if the block no longer exists.
        /// A block is 0.2 wide by default in terms of position.
        /// </summary>
        public float3 Position
        {
            get => Exists ? MovementEngine.GetPosition(Id.entityID) : float3.zero;
            set
            {
                if (Exists) MovementEngine.MoveBlock(Id.entityID, value);
            }
        }

        /// <summary>
        /// The block's current rotation in degrees or zero if the block doesn't exist.
        /// </summary>
        public float3 Rotation
        {
            get => Exists ? RotationEngine.GetRotation(Id.entityID) : float3.zero;
            set
            {
                if (Exists) RotationEngine.RotateBlock(Id.entityID, value);
            }
        }

        /// <summary>
        /// The block's non-uniform scale or zero if the block's invalid. Independent of the uniform scaling.
        /// </summary>
        public float3 Scale
        {
            get => BlockEngine.GetBlockInfo<ScalingEntityStruct>(Id)?.scale ?? float3.zero;
            set
            {
                var def = new ScalingEntityStruct();
                BlockEngine.GetBlockInfo(Id, ref def).scale = value;
            }
        }

        /// <summary>
        /// The block's uniform scale or zero if the block's invalid. Also sets the non-uniform scale.
        /// </summary>
        public int UniformScale
        {
            get => BlockEngine.GetBlockInfo<BlockPlacementScaleEntityStruct>(Id)?.desiredScaleFactor ?? 0;
            set
            {
                var def = new BlockPlacementScaleEntityStruct();
                ref var scaleStruct = ref BlockEngine.GetBlockInfo(Id, ref def);
                scaleStruct.blockPlacementHeight = scaleStruct.blockPlacementWidth =
                    scaleStruct.desiredScaleFactor = scaleStruct.snapGridScale = value;
                Scale = new float3(value, value, value);
            }
        }

        /// <summary>
        /// The block's type (ID). Returns BlockIDs.Invalid if the block doesn't exist anymore.
        /// </summary>
        public BlockIDs Type => (BlockIDs) (BlockEngine.GetBlockInfo<DBEntityStruct>(Id)?.DBID ?? ushort.MaxValue);

        /// <summary>
        /// The block's color. Returns BlockColors.Default if the block no longer exists.
        /// </summary>
        public BlockColor Color
        {
            get
            {
                byte index = BlockEngine.GetBlockInfo<ColourParameterEntityStruct>(Id)?.indexInPalette ?? byte.MaxValue;
                if (index == byte.MaxValue) return new BlockColor {Color = BlockColors.Default};
                return new BlockColor {Color = (BlockColors) (index % 10), Darkness = (byte) (index / 10)};
            }
            set
            {
                var def = new ColourParameterEntityStruct();
                ref var color = ref BlockEngine.GetBlockInfo(Id, ref def);
                color.indexInPalette = (byte) (value.Color + value.Darkness * 10);
                color.needsUpdate = true;
            }
        }

        /// <summary>
        /// Whether the block exists. The other properties will return a default value if the block doesn't exist.
        /// </summary>
        public bool Exists => BlockEngine.BlockExists(Id);

        /// <summary>
        /// Returns an array of blocks that are connected to this one. Returns an empty array if the block doesn't exist.
        /// </summary>
        public Block[] GetConnectedCubes() => BlockEngine.GetConnectedBlocks(Id);

        /// <summary>
        /// Removes this block.
        /// </summary>
        /// <returns>True if the block exists and could be removed.</returns>
        public bool Remove() => RemovalEngine.RemoveBlock(Id);

        public override string ToString()
        {
            return $"{nameof(Id)}: {Id}, {nameof(Position)}: {Position}, {nameof(Rotation)}: {Rotation}";
        }

        public static void Init()
        {
            GameEngineManager.AddGameEngine(PlacementEngine);
            GameEngineManager.AddGameEngine(MovementEngine);
            GameEngineManager.AddGameEngine(RotationEngine);
            GameEngineManager.AddGameEngine(RemovalEngine);
            GameEngineManager.AddGameEngine(BlockEngine);
        }
    }
}