using System;
using System.ComponentModel;
using Engine.Renderer;
using Engine.EntitySystem;
using Engine.MapSystem;
using Engine.MathEx;

namespace ProjectEntities
{
    public class PowerUpEffectType : DynamicType
    {

        public enum PowerEffect
        {
            Pulse,
            Grow,
            Shrink,
        }
        public enum ScaleOnlyAxis
        {
            X = 1,
            Y = 2,
            Z = 4,
            XY = 3,
            XZ = 5,
            YZ = 6,
            All = 7
        }

        [FieldSerialize]
        public ScaleOnlyAxis axis = ScaleOnlyAxis.All;

        [DefaultValue(ScaleOnlyAxis.All)]
        public ScaleOnlyAxis Scale_Axis
        {
            get { return axis; }
            set { axis = value; }
        }

        [FieldSerialize]
        public PowerEffect effect = PowerEffect.Pulse;

        [DefaultValue(PowerEffect.Pulse)]
        public PowerEffect EffectType
        {
            get { return effect; }
            set { effect = value; }
        }

        [FieldSerialize]
        Vec2 scalerange = new Vec2(.1f, 1.4f);

        [Description("Диапазон масштабирования объекта сетки, может быть от 0,1 до максимума с плавающей точкой: устанавливает размер")]
        [DefaultValue(typeof(Vec2), "1 1.4")]
        public Vec2 ScaleRange
        {
            get { return scalerange; }
            set { scalerange = value; }
        }

        [FieldSerialize]
        float scaletimer = .33f;
        [Description("Время, необходимое для смены кадров рендера")]
        [DefaultValue(typeof(float), ".33")]
        public float ScaleTimer
        {
            get { return scaletimer; }
            set { scaletimer = value; }
        }

        [FieldSerialize]
        float scaleIncrement= .1f;
        [Description("Расстояние шкалы на секунду")]
        [DefaultValue(typeof(float), ".1")]
        public float ScaleIncrement
        {
            get { return scaleIncrement; }
            set { scaleIncrement= value; }
        }

        [FieldSerialize]
        bool renderineditor = false;
        [Description("Визуализация в редакторе")]
        [DefaultValue(false)]
        public bool RenderInEditor
        {
            get { return renderineditor; }
            set { renderineditor = value; }
        }

    }

    public class PowerUpEffect : Dynamic
    {

        PowerUpEffectType _type = null; public new PowerUpEffectType Type { get { return _type; } }

        static MapObjectAttachedMesh attachedobject = null;

        protected override void OnPostCreate(bool loaded)
        {
            base.OnPostCreate(loaded);

            OnTick();

            //To find the first attached mesh
            foreach (MapObjectAttachedObject attachedObject in AttachedObjects)
            {
                MapObjectAttachedMesh attachedMesh = attachedObject as MapObjectAttachedMesh;
                if (attachedMesh != null)
                {
                    attachedobject = attachedMesh;

                    break;
                }
            }
        }

         float scaletimerXX = 0f;
         bool inoutdirection = true;


        private Vec3 TickScale(Vec3 scaling, bool inOutDirection)
        {
            var multiplier = inOutDirection ? 1f : -1f;
            multiplier *= RendererWorld.Instance.FrameRenderTimeStep;
            //X
            if ((Type.Scale_Axis & PowerUpEffectType.ScaleOnlyAxis.X) == PowerUpEffectType.ScaleOnlyAxis.X)
            {
                scaling.X += Type.ScaleIncrement * multiplier;
            }
            //Y
            if ((Type.Scale_Axis & PowerUpEffectType.ScaleOnlyAxis.Y) == PowerUpEffectType.ScaleOnlyAxis.Y)
            {
                scaling.Y += Type.ScaleIncrement * multiplier;
            }
            //Z
            if ((Type.Scale_Axis & PowerUpEffectType.ScaleOnlyAxis.Z) == PowerUpEffectType.ScaleOnlyAxis.Z)
            {
                scaling.Z += Type.ScaleIncrement * multiplier;
            }
            return scaling;
        }

        private bool CheckAddtoScale(Vec3 scaling)
        {
            bool OnIsBiggerThanMaxScale = false;
            if ((Type.Scale_Axis & PowerUpEffectType.ScaleOnlyAxis.X) == PowerUpEffectType.ScaleOnlyAxis.X)
            {
                if (scaling.X >= Type.ScaleRange.Y)
                    OnIsBiggerThanMaxScale = true;
            }
            //Y
            if ((Type.Scale_Axis & PowerUpEffectType.ScaleOnlyAxis.Y) == PowerUpEffectType.ScaleOnlyAxis.Y)
            {
                if (scaling.Y >= Type.ScaleRange.Y)
                    OnIsBiggerThanMaxScale = true;
            }
            //Z
            if ((Type.Scale_Axis & PowerUpEffectType.ScaleOnlyAxis.Z) == PowerUpEffectType.ScaleOnlyAxis.Z)
            {
                if (scaling.Z >= Type.ScaleRange.Y)
                    OnIsBiggerThanMaxScale = true;
            }
            return OnIsBiggerThanMaxScale;
        }

        private bool CheckSubtractfromScale(Vec3 scaling)
        {
            bool OnIsSmallerThanMinScale = false;
            if ((Type.Scale_Axis & PowerUpEffectType.ScaleOnlyAxis.X) == PowerUpEffectType.ScaleOnlyAxis.X)
            {
                if (scaling.X <= Type.ScaleRange.X)
                    OnIsSmallerThanMinScale = true;
            }
            //Y
            if ((Type.Scale_Axis & PowerUpEffectType.ScaleOnlyAxis.Y) == PowerUpEffectType.ScaleOnlyAxis.Y)
            {
                if (scaling.Y <= Type.ScaleRange.X)
                    OnIsSmallerThanMinScale = true;
            }
            //Z
            if ((Type.Scale_Axis & PowerUpEffectType.ScaleOnlyAxis.Z) == PowerUpEffectType.ScaleOnlyAxis.Z)
            {
                if (scaling.Z <= Type.ScaleRange.X)
                    OnIsSmallerThanMinScale = true;
            }
            return OnIsSmallerThanMinScale;
        }

        protected override void OnRenderFrame()
        {
            base.OnRenderFrame();
            if (attachedobject == null)
                return;
            if (EntitySystemWorld.Instance.IsEditor() && !Type.RenderInEditor)
                return;

            Vec3 scaling = attachedobject.ScaleOffset;


            scaletimerXX += RendererWorld.Instance.FrameRenderTimeStep;

            if (scaletimerXX < this.Type.ScaleTimer)
                return;

            if (Type.EffectType == PowerUpEffectType.PowerEffect.Pulse)
            {
                scaletimerXX = 0f; //RESET TIMER EVENT
                if (inoutdirection)
                {
                    scaling = TickScale(scaling, inoutdirection);
                    if (CheckAddtoScale(scaling))
                        inoutdirection = false;
                }
                else if (!inoutdirection)
                {
                    scaling = TickScale(scaling, inoutdirection);
                    if (CheckSubtractfromScale(scaling))
                        inoutdirection = true;
                }
            }
            else if (Type.EffectType == PowerUpEffectType.PowerEffect.Grow)
            {
                scaletimerXX = 0f; //RESET TIMER EVENT
                if (CheckAddtoScale(scaling))
                {
                    scaling.X = Type.ScaleRange.X;
                    scaling.Y = Type.ScaleRange.X;
                    scaling.Z = Type.ScaleRange.X;
                }
                else
                {
                    scaling = TickScale(scaling, true);
                }

            }
            else if (Type.EffectType == PowerUpEffectType.PowerEffect.Shrink)
            {
                scaletimerXX = 0f; //RESET TIMER EVENT
                if (CheckSubtractfromScale(scaling))
                {
                    scaling.X = Type.ScaleRange.Y;
                    scaling.Y = Type.ScaleRange.Y;
                    scaling.Z = Type.ScaleRange.Y;
                }
                else
                {
                    scaling = TickScale(scaling, false);
                }

            }
                attachedobject.ScaleOffset = scaling;

        }
    }
}