using StgSharp.Control;
using System;
using System.Runtime.InteropServices;

namespace StgSharp.Math
{

    /*
    [StructLayout(LayoutKind.Explicit, Size = 12, Pack = 16)]
    public struct Vec3d : IEquatable<Vec3d>
    {
        [FieldOffset(0)]
        public float X;
        [FieldOffset(4)]
        public float Y;
        [FieldOffset(8)]
        public float Z;

        public Vec3d(float x, float y, float z)
        {
            X = x;
            Y = y;
            Z = z;
        }

        bool IEquatable<Vec3d>.Equals(Vec3d other)
        {
            if (this.GetHashCode() != other.GetHashCode())
            {
                return false;
            }
            else
            {
                return this.X == other.X
                    && this.Y == other.Y
                    && this.Z == other.Z;
            }
        }

        public override bool Equals(object obj)
        {
            if (obj == null)
            {
                return false;
            }
            else if (obj.GetType() != typeof(Vec3d))
            {
                return false;
            }
            else
            {
                return this.Equals((Vec3d)obj);
            }
        }

        public override int GetHashCode()
        {
            return HashCode.Combine(X, Y, Z);
        }

        public override string ToString()
        {
            return $"{X}\t{Y}\t{Z}";
        }

        public string ToString(string sample)
        {
            return $"{X.ToString(sample)}\t{Y.ToString(sample)}\t{Z.ToString(sample)}";
        }

        public static bool operator ==(Vec3d vec1, Vec3d vec2)
        {
            return vec1.X == vec2.X
                && vec1.Y == vec2.Y
                && vec1.Z == vec2.Z;
        }

        public static bool operator !=(Vec3d vec1, Vec3d vec2)
        {
            return !(vec1.X == vec2.X
                && vec1.Y == vec2.Y
                && vec1.Z == vec2.Z);
        }

        public static Vec3d operator +(Vec3d vec1, Vec3d vec2)
        {
            return new Vec3d(
                vec1.X + vec2.X,
                vec1.Y + vec2.Y,
                vec1.Z + vec2.Z
                );
        }

        public static Vec3d operator -(Vec3d vec1, Vec3d vec2)
        {
            return new Vec3d(
                vec1.X - vec2.X,
                vec1.Y - vec2.Y,
                vec1.Z - vec2.Z
                );
        }

        public static float operator *(Vec3d vec1, Vec3d vec2)
        {
            return
                vec1.X * vec2.X
                + vec1.Y + vec2.Y
                + vec1.Z + vec2.Z;
        }

        public static Vec3d operator *(Vec3d vec, float x)
        {
            return new Vec3d(
                vec.X * x,
                vec.Y * x,
                vec.Z * x
                );
        }

        public static Vec3d operator *(float x, Vec3d vec)
        {
            return new Vec3d(
                vec.X * x,
                vec.Y * x,
                vec.Z * x
                );
        }

        public static Vec3d operator /(Vec3d vec, float x)
        {
            return new Vec3d(
                vec.X / x,
                vec.Y / x,
                vec.Z / x
                );
        }

        public static implicit operator float[](Vec3d vec)
        {
            return new float[3] { vec.X, vec.Y, vec.Y };
        }

        public static implicit operator Vec3d(float[] floatArray)
        {
            return new Vec3d(floatArray[0], floatArray[1], floatArray[2]);
        }
    }

    /**/


    public class Vec3d
    {
        public static Vec3d defaultValue =
            new Vec3d(0, 0, 0);
         

        internal M128Map _map;
        internal IntPtr _m128Ptr;

        public unsafe float X
        {
            get { return ((M128*)_m128Ptr)->single_0; }
            set { ((M128*)_m128Ptr)->single_0 = value; }
        }

        public unsafe float Y
        {
            get { return ((M128*)_m128Ptr)->single_1; }
            set { ((M128*)_m128Ptr)->single_1 = value; }
        }

        public unsafe float Z
        {
            get { return ((M128*)_m128Ptr)->single_2; }
            set { ((M128*)_m128Ptr)->single_2 = value; }
        }


        internal Vec3d(IntPtr value)
        {
            if ((long)value == -1)
            {
                throw new Exception("Failed to creat M128 pointer");
            }
            else
            {
                _m128Ptr = value;
            }
        }

        public Vec3d(float x, float y, float z)
        {
            _m128Ptr = internalIO.load_internal(x,y,z,0);
        }

        internal Vec3d()
        {
            _m128Ptr = defaultValue._m128Ptr;
        }

        public static Vec3d operator +(Vec3d vec1, Vec3d vec2)
        {
            return new Vec3d(
                internalIO.addps_internal(vec1._m128Ptr, vec2._m128Ptr)
                );
        }

        public static Vec3d operator -(Vec3d vec1, Vec3d vec2)
        {
            return new Vec3d(
                internalIO.subps_internal(vec1._m128Ptr, vec2._m128Ptr)
                );
        }

        public static Vec3d operator *(Vec3d vec, float value)
        {
            return new Vec3d(
                internalIO.mulps_const_internal(vec._m128Ptr,value)
                );
        }

        public unsafe override string ToString()
        {
            return (*(M128*)_m128Ptr).ToString();
        }

        ~Vec3d()
        {
            if (_map == null)
            {
                if (_m128Ptr != defaultValue._m128Ptr)
                {
                    internalIO.deinitM128_internal(this._m128Ptr);
                }
                else
                {
                    _m128Ptr = IntPtr.Zero;
                }
            }
            else
            {

            }
        }

    }
}