export { Vector };

class Vector {

  public static addVectors(
    {
      vectorA
    , vectorB
    }: {
      vectorA: Vector
    , vectorB: Vector
    }
  ): Vector {
    Vector.checkSameNumberOfComponents(
      {
        vectorA: vectorA
      , vectorB: vectorB
      }
    );

    let numberOfComponents = vectorA.getNumberOfComponents();
    let aComponents = vectorA.getComponents();
    let bComponents = vectorB.getComponents();
    let cComponents = [];

    for (
      let i = 0;
      i < numberOfComponents;
      i++
    ) {
      cComponents[ i ] = (
        aComponents[ i ]
        + bComponents[ i ]
      );
    }

    let vectorC = new Vector(
      cComponents
    );

    return vectorC;
  }

  public static subtractVectors(
    {
      vectorA
    , vectorB
    }: {
      vectorA: Vector
    , vectorB: Vector
    }
  ): Vector {
    Vector.checkSameNumberOfComponents(
      {
        vectorA: vectorA
      , vectorB: vectorB
      }
    );

    let numberOfComponents = vectorA.getNumberOfComponents();
    let aComponents = vectorA.getComponents();
    let bComponents = vectorB.getComponents();
    let cComponents = [];

    for (
      let i = 0;
      i < numberOfComponents;
      i++
    ) {
      cComponents[ i ] = (
        aComponents[ i ]
        - bComponents[ i ]
      );
    }

    let vectorC = new Vector(
      cComponents
    );

    return vectorC;
  }

  public static multiplyVectors(
    {
      vectorA
    , vectorB
    }: {
      vectorA: Vector
    , vectorB: Vector
    }
  ): Vector {
    Vector.checkSameNumberOfComponents(
      {
        vectorA: vectorA
      , vectorB: vectorB
      }
    );

    let numberOfComponents = vectorA.getNumberOfComponents();
    let aComponents = vectorA.getComponents();
    let bComponents = vectorB.getComponents();
    let cComponents = [];

    for (
      let i = 0;
      i < numberOfComponents;
      i++
    ) {
      cComponents[ i ] = (
        aComponents[ i ]
        * bComponents[ i ]
      );
    }

    let vectorC = new Vector(
      cComponents
    );

    return vectorC;
  }

  public static divideVectors(
    {
      vectorA
    , vectorB
    }: {
      vectorA: Vector
    , vectorB: Vector
    }
  ): Vector {
    Vector.checkSameNumberOfComponents(
      {
        vectorA: vectorA
      , vectorB: vectorB
      }
    );

    let numberOfComponents = vectorA.getNumberOfComponents();
    let aComponents = vectorA.getComponents();
    let bComponents = vectorB.getComponents();
    let cComponents = [];

    for (
      let i = 0;
      i < numberOfComponents;
      i++
    ) {
      cComponents[ i ] = (
        aComponents[ i ]
        / bComponents[ i ]
      );
    }

    let vectorC = new Vector(
      cComponents
    );

    return vectorC;
  }

  public static dotProductOfVectors(
    {
      vectorA
    , vectorB
    }: {
      vectorA: Vector
    , vectorB: Vector
    }
  ): number {
    Vector.checkSameNumberOfComponents(
      {
        vectorA: vectorA
      , vectorB: vectorB
      }
    );

    let dotProduct = 0;
    let numberOfComponents = vectorA.getNumberOfComponents();
    let aComponents = vectorA.getComponents();
    let bComponents = vectorB.getComponents();

    for (
      let i = 0;
      i < numberOfComponents;
      i++
    ) {
      dotProduct = (
        dotProduct
        + (
          aComponents[ i ]
          * bComponents[ i ]
        )
      );
    }

    return dotProduct;
  }

  public static crossProductOfVectors(
    {
      vectorA
    , vectorB
    }: {
      vectorA: Vector
    , vectorB: Vector
    }
  ): number | Vector {
    Vector.checkSameNumberOfComponents(
      {
        vectorA: vectorA
      , vectorB: vectorB
      }
    );

    let numberOfComponents = vectorA.getNumberOfComponents();
    let aComponents = vectorA.getComponents();
    let bComponents = vectorB.getComponents();

    switch ( numberOfComponents ) {
      case 2 : {
        let Ax = aComponents[ 0 ];
        let Ay = aComponents[ 1 ];
        let Bx = bComponents[ 0 ];
        let By = bComponents[ 1 ];

        let crossProduct = (
          ( Ax * By )
          - ( Ay * Bx )
        );

        return crossProduct;
      }
      case 3: {
        let Ax = aComponents[ 0 ];
        let Ay = aComponents[ 1 ];
        let Az = aComponents[ 2 ];
        let Bx = bComponents[ 0 ];
        let By = bComponents[ 1 ];
        let Bz = bComponents[ 2 ];

        let components = [];

        components[ 0 ] = (
          ( Ay * Bz )
          - ( Az * By )
        );
        components[ 1 ] = (
          ( Az * Bx )
          - ( Ax * Bz )
        );
        components[ 2 ] = (
          ( Ax * By )
          - ( Ay * Bx )
        );

        let crossProduct = new Vector(
          components
        );

        return crossProduct;
      }
      default: {
        throw Error(
          'cross product only provided for 2 and 3'
        );
      }
    }
  }

  public static lerpBetweenVectors(
    {
      start
    , end
    , progress // ranges from 0.0 to 1.0
    }: {
      start: Vector
    , end: Vector
    , progress: number
    }
  ): Vector {
    Vector.checkSameNumberOfComponents(
      {
        vectorA: start
      , vectorB: end
      }
    );
    Vector.checkLerpProgress(
      progress
    );

    let delta = Vector.subtractVectors(
      {
        vectorA: end
      , vectorB: start
      }
    );
    delta = delta.multiplyByScalar(
      progress
    );

    let result = Vector.addVectors(
      {
        vectorA: start
      , vectorB: delta
      }
    );

    return result;
  }

  private static checkSameNumberOfComponents(
    {
      vectorA
    , vectorB
    }: {
      vectorA: Vector
    , vectorB: Vector
    }
  ): void {
    if (
      vectorA.getNumberOfComponents()
      !== vectorB.getNumberOfComponents()
    ) {
      throw Error(
        'vectors have different number of components'
      );
    }
  }
  private static checkLerpProgress(
    progress
  ): void {
    if (
      progress < 0 || progress > 1
    ) {
      throw Error(
        'progress out of valid range'
      );
    }
  }

  private readonly components: number[];
  private readonly numberOfComponents: number;
  private magnitude: number;
  private magnitudeSquared: number;

  public constructor(
    components: number[]
  ) {
    this.checkComponents(
      components
    );

    this.components = components;
    this.numberOfComponents = this.components.length;
  }

  public getNumberOfComponents(): number {
    return this.numberOfComponents;
  }

  public getComponents(): number[] {
    return this.components;
  }

  public getComponent(
    componentIndex: number
  ): number {
    this.checkComponentIndex(
      componentIndex
    );

    return this.components[ componentIndex ];
  }

  public setComponent(
    {
      componentIndex
    , value
    }: {
      componentIndex: number
    , value: number
    }
  ): Vector {
    this.checkComponentIndex(
      componentIndex
    );

    let numberOfComponents = this.getNumberOfComponents();
    let components = [];

    for (
      let i = 0;
      i < numberOfComponents;
      i++
    ) {
      if ( i === componentIndex ) {
        components[ i ] = value;
      }
      else {
        components[ i ] = this.components[ i ];
      }
    }

    let vector = new Vector(
      components
    );

    return vector;
  }

  public getMagnitude(): number {
    if (
      this.magnitude === undefined
    ) {
      this.calculateMagnitude();
    }

    return this.magnitude;
  }

  public getMagnitudeSquared(): number {
    if (
      this.magnitudeSquared === undefined
    ) {
      this.calculateMagnitudeSquared();
    }

    return this.magnitudeSquared;
  }

  // scalar operations
  public addScalar(
    scalar: number
  ): Vector {
    let numberOfComponents = this.getNumberOfComponents();
    let components = [];

    for (
      let i = 0;
      i < numberOfComponents;
      i++
    ) {
      components[ i ] = (
        this.components[ i ]
        + scalar
      );
    }

    let result = new Vector(
      components
    );

    return result;
  }
  public subtractScalar(
    scalar: number
  ): Vector {
    let numberOfComponents = this.getNumberOfComponents();
    let components = [];

    for (
      let i = 0;
      i < numberOfComponents;
      i++
    ) {
      components[ i ] = (
        this.components[ i ]
        - scalar
      );
    }

    let result = new Vector(
      components
    );

    return result;
  }
  public multiplyByScalar(
    scalar: number
  ): Vector {
    let numberOfComponents = this.getNumberOfComponents();
    let components = [];

    for (
      let i = 0;
      i < numberOfComponents;
      i++
    ) {
      components[ i ] = (
        this.components[ i ]
        * scalar
      );
    }

    let result = new Vector(
      components
    );

    return result;
  }
  public divideByScalar(
    scalar: number
  ): Vector {
    if ( scalar === 0 ) {
      throw Error( 'divide by zero' );
    }

    let numberOfComponents = this.getNumberOfComponents();
    let components = [];

    for (
      let i = 0;
      i < numberOfComponents;
      i++
    ) {
      components[ i ] = (
        this.components[ i ]
        / scalar
      );
    }

    let result = new Vector(
      components
    );

    return result;
  }

  // vector operations
  public addVector(
    vector: Vector
  ): Vector {
    let result = Vector.addVectors(
      {
        vectorA: this
      , vectorB: vector
      }
    );

    return result;
  }
  public subtractVector(
    vector: Vector
  ): Vector {
    let result = Vector.subtractVectors(
      {
        vectorA: this
      , vectorB: vector
      }
    );

    return result;
  }
  public multiplyVector(
    vector: Vector
  ): Vector {
    let result = Vector.multiplyVectors(
      {
        vectorA: this
      , vectorB: vector
      }
    );

    return result;
  }
  public divideVector(
    vector: Vector
  ): Vector {
    let result = Vector.divideVectors(
      {
        vectorA: this
      , vectorB: vector
      }
    );

    return result;
  }

  public normalize(): Vector {
    let magnitude = this.getMagnitude();

    switch ( magnitude ) {
      case 0: {
        throw Error(
          'magnitude of zero'
        );
      }
      case 1: {
        return this;
      }
      default: {
        let inverseMagnitude = 1 / magnitude;
        let result = this.multiplyByScalar(
          inverseMagnitude
        );

        return result;
      }
    } // switch
  }

  private calculateMagnitude(): void {
    this.magnitude = Math.sqrt(
      this.getMagnitudeSquared()
    );
  }
  private calculateMagnitudeSquared(): void {
    this.magnitudeSquared = Vector.dotProductOfVectors(
      {
        vectorA: this
      , vectorB: this
      }
    );
  }

  private checkComponents(
    components: number[]
  ): void {
    if (
      components.length < 2
    ) {
      throw Error(
        'number of components is less than the minimum of 2'
      );
    }
  }
  private checkComponentIndex(
    componentIndex: number
  ): void {
    if (
      componentIndex >= this.getNumberOfComponents()
      || componentIndex < 0
    ) {
      throw Error(
        'index out of bounds'
      );
    }
  }
}