package com.jiraiyah.jmath.vector

import javax.vecmath.Vector2d


import com.jiraiyah.jmath.algebra.{Min, Max}
import com.jiraiyah.jmath.algebra.scala.Numeric
import org.lwjgl.util.vector.Vector2f

import scala.actors.A

abstract class Vector2[@specialized(Int,Long,Float,Double) A](){
  var _x : Numeric[A]
  var _y : Numeric[A]
  def apply(x: Numeric, y: Numeric): Vector2[A] = {
    _x = x[Numeric]
    _y = y[Numeric]
    this
  }

  def this(v: Vector2) {
    this(v.getX, v.getY)
  }

  def getX[A] = _x[Numeric]

  def getY[A] = _y[Numeric]

  def getFloatX[T](implicit ev:Numeric[T]) = _x[Float]

  def getFloatY[T](implicit ev:Numeric[T]) = _y[Float]

  def getDoubleX[T](implicit ev:Numeric[T]) = _x[Double]

  def getDoubleY[T](implicit ev:Numeric[T]) = _y[Float]

  def getIntX[T](implicit ev:Numeric[T]) = _x[Int]

  def getIntY[T](implicit ev:Numeric[T]) = _y[Int]

  def getBigIntX[T](implicit ev:Numeric[T]) = _x[BigInt]

  def getBigIntY[T](implicit ev:Numeric[T]) = _y[BigInt]

  def getBigDecX[T](implicit ev:Numeric[T]) = _x[BigDecimal]

  def getBigDecY[T](implicit ev:Numeric[T]) = _y[BigDecimal]

  def getGlFloat[T](implicit T:Vector2) = new Vector2f(getFloatX,getFloatY)

  def getVecFloat[T](implicit T:Vector2) = new javax.vecmath.Vector2f(getFloatX,getFloatY)

  def getVecDouble[T](implicit T:Vector2) = new Vector2d(getDoubleX,getDoubleY)

  def getIntVector[T](implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getIntX
      override var _y: Numeric = getIntY
    }
  }

  def getFloatVector[T](implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getFloatX
      override var _y: Numeric = getFloatY
    }
  }

  def getDoubleVector[T](implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getDoubleX
      override var _y: Numeric = getDoubleY
    }
  }

  def getBigIntVector[T](implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getBigIntX
      override var _y: Numeric = getBigIntY
    }
  }

  def getBigDecVector[T](implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getBigDecX
      override var _y: Numeric = getBigDecY
    }
  }

  def setX[N:Numeric](x:N)(implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = x[Numeric]
      override var _y: Numeric = getY[Numeric]
    }
  }

  def setY[N:Numeric](y:N)(implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getX
      override var _y: Numeric = y[Numeric]
    }
  }

  def set[N:Numeric](x:N, y:N)(implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = x[Numeric]
      override var _y: Numeric = y[Numeric]
    }
  }

  def setToDouble[T]()(implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getDoubleX
      override var _y: Numeric = getDoubleY
    }
  }

  def setToFloat[T]()(implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getFloatX
      override var _y: Numeric = getFloatY
    }
  }

  def setToInteger[T]()(implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getIntX
      override var _y: Numeric = getIntY
    }
  }

  def setToBigInt[T]()(implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getBigIntX
      override var _y: Numeric = getBigIntY
    }
  }

  def setToBigDec[T]()(implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = getBigDecX
      override var _y: Numeric = getBigDecY
    }
  }

  def max[V:Vector2](other: Vector2[V])(implicit V:Vector2) = {
    new Vector2() {
      override var _x: Numeric = Max.get(getX,other.getX)
      override var _y: Numeric = Max.get(getY,other.getY)
    }
  }

  def min[T](other: Vector2)(implicit T:Vector2) = {
    new Vector2() {
      override var _x: Numeric = Min.get(getX,other.getX)
      override var _y: Numeric = Min.get(getY,other.getY)
    }
  }

  def *[N:Numeric](a: N)(implicit ev:Numeric) = {
    new Vector2() {
      override var _x: Numeric = ev.times(getX, a[A])[A]
      override var _y: Numeric = ev.times(getY, a[A])[A]
    }
  }

  def *[T](v: Vector2)(implicit ev:Numeric[A]) = {
    new Vector2() {
      override var _x: Numeric = ev.times(getX, v.getX)[A]
      override var _y: Numeric = ev.times(getY, v.getY)[A]
    }
  }

  def /[N:Numeric](a: N)(implicit ev:Numeric) = {
    if (a == 0L)
    {
      if (_x.isInstanceOf[Double] || _y.isInstanceOf[Double])
        Vector2.ZeroDouble
      else if (_x.isInstanceOf[Float] || _y.isInstanceOf[Float])
        Vector2.ZeroFloat
      else if (_x.isInstanceOf[Int] || _y.isInstanceOf[Int])
        Vector2.ZeroInt
      else if (_x.isInstanceOf[BigInt] || _y.isInstanceOf[BigInt])
        Vector2.ZeroBigInt
      else
        Vector2.ZeroBigDec
    }
    new Vector2() {
      override var _x: Numeric = ev.div(getX, a[A])[A]
      override var _y: Numeric = ev.div(getY, a[A])[A]
    }
  }

  def /(v: Vector2)(implicit ev:Numeric) = {
    if (v.getX == 0L || v.getY == 0L)
    {
      if (_x.isInstanceOf[Double] || _y.isInstanceOf[Double])
        Vector2.ZeroDouble
      else if (_x.isInstanceOf[Float] || _y.isInstanceOf[Float])
        Vector2.ZeroFloat
      else if (_x.isInstanceOf[Int] || _y.isInstanceOf[Int])
        Vector2.ZeroInt
      else if (_x.isInstanceOf[BigInt] || _y.isInstanceOf[BigInt])
        Vector2.ZeroBigInt
      else
        Vector2.ZeroBigDec
    }
    new Vector2() {
      override var _x: Numeric = ev.div(getX, v.getX)[A]
      override var _y: Numeric = ev.div(getY, v.getY)[A]
    }
  }

  def +[N:Numeric](a: N)(implicit ev:Numeric) = {
    new Vector2() {
      override var _x: Numeric = ev.plus(getX, a[A])[A]
      override var _y: Numeric = ev.plus(getY, a[A])[A]
    }
  }

  def +(v: Vector2)(implicit ev:Numeric) = {
    new Vector2() {
      override var _x: Numeric = ev.plus(getX, v.getX)[A]
      override var _y: Numeric = ev.plus(getY, v.getY)[A]
    }
  }

  def -[N:Numeric](a: N)(implicit ev:Numeric) = {
    new Vector2() {
      override var _x: Numeric = ev.minus(getX, a[A])[A]
      override var _y: Numeric = ev.minus(getY, a[A])[A]
    }
  }

  def -(v: Vector2)(implicit ev:Numeric) = {
    new Vector2() {
      override var _x: Numeric = ev.minus(getX, v.getX)[A]
      override var _y: Numeric = ev.minus(getY, v.getY)[A]
    }
  }
}

object Vector2{
  def OneInt = new Vector2() {
    override var _x: Numeric = 1[Numeric]
    override var _y: Numeric = 1[Numeric]
  }
  def ZeroInt = new Vector2() {
    override var _x: Numeric = 0[Numeric]
    override var _y: Numeric = 0[Numeric]
  }
  def UnitXInt = new Vector2() {
    override var _x: Numeric = 1[Numeric]
    override var _y: Numeric = 0[Numeric]
  }
  def UnitYInt = new Vector2() {
    override var _x: Numeric = 0[Numeric]
    override var _y: Numeric = 1[Numeric]
  }

  def OneBigInt = OneInt.getBigIntVector
  def ZeroBigInt = ZeroInt.getBigIntVector
  def UnitXBigInt = UnitXInt.getBigIntVector
  def UnitYBigInt = UnitYInt.getBigIntVector

  def OneBigDec = OneInt.getBigDecVector
  def ZeroBigDec = ZeroInt.getBigDecVector
  def UnitXBigDec = UnitXInt.getBigDecVector
  def UnitYBigDec = UnitYInt.getBigDecVector

  def OneFloat = OneInt.getFloatVector
  def ZeroFloat = ZeroInt.getFloatVector
  def UnitXFloat = UnitXInt.getFloatVector
  def UnitYFloat = UnitYInt.getFloatVector

  def OneDouble = OneInt.getDoubleVector
  def ZeroDouble = ZeroInt.getDoubleVector
  def UnitXDouble = UnitXInt.getDoubleVector
  def UnitYDouble = UnitYInt.getDoubleVector

  def test: Unit ={
    var a = ZeroInt
    a.setY(13f)
    a.setToFloat()
    var b = a.set(12,13).setToBigInt()
    a = a.setToInteger()
    a.max(OneDouble);
    a * 5f
    a * OneFloat
    a = a.setToInteger()
    a / 5
    a / OneFloat
    a + 0.4
    a - 0.45d
    a - ZeroDouble
  }
}