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

namespace StgSharp.Math
{

    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 static Vec3d operator /(Vec3d vec, float value)
        {
            return new Vec3d(
                internalIO.divps_const_internal(vec._m128Ptr,value)
                );
        }
        /**/
        public static float operator *(Vec3d vec1, Vec3d vec2)
        {
            //return VectorCalc.Multiple(vec1,vec2);

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

        public unsafe string ToString(string sample)
        {
            return $"{(*(M128*)_m128Ptr).single_0.ToString(sample)}\t"+
                $"{(*(M128*)_m128Ptr).single_1.ToString(sample)}\t"+
                $"{(*(M128*)_m128Ptr).single_2.ToString(sample)}\t"+
                $"{(*(M128*)_m128Ptr).single_3.ToString(sample)}\t";
        }

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

            }
        }

    }
}