import { ASObject } from '@awayfl/avm2';

import { Point as AwayPoint } from '@awayjs/core';
import { SecurityDomain } from '../SecurityDomain';

export class Point extends ASObject {
	private _constructorCalled: boolean = true;
	private _adaptee: AwayPoint;

	// Called whenever the class is initialized.
	static classInitializer: any = null;

	// List of static symbols to link.
	static classSymbols: string [] = null; // ["interpolate", "distance", "polar"];

	// List of instance symbols to link.
	static instanceSymbols: string [] = null;

	public get adaptee(): AwayPoint {
		return this._adaptee;
	}

	/**
   * The horizontal coordinate of the point. The default value is 0.
   */
	public get x(): number {
		if (!this._constructorCalled) {
			console.warn('[Point] Read x before call constructor');
			return 0;
		}

		return this._adaptee._rawData[0];
	}

	public set x(value: number) {
		this._adaptee._rawData[0] = value;
	}

	/**
   * The vertical coordinate of the point. The default value is 0.
   */
	public get y(): number {
		if (!this._constructorCalled) {
			console.warn('[Point] Read y before call constructor');
			return 0;
		}

		return this._adaptee._rawData[1];
	}

	public set y(value: number) {
		this._adaptee._rawData[1] = value;
	}

	/**
   * The length of the line segment from(0,0) to this point.
   */
	public get length(): number {
		return this._adaptee.length;
	}

	/**
   * Creates a new point. If you pass no parameters to this method, a point is
   * created at(0,0).
   *
   * @param x The horizontal coordinate.
   * @param y The vertical coordinate.
   */
	constructor(xAdaptee: number | AwayPoint = 0, y: number = 0) {
		super();

		this._adaptee = (xAdaptee instanceof AwayPoint) ? xAdaptee : new AwayPoint(+xAdaptee, +y);
		this._constructorCalled = true;
	}

	/**
   * Determines a point between two specified points. The parameter
   * <code>f</code> determines where the new interpolated point is located
   * relative to the two end points specified by parameters <code>pt1</code>
   * and <code>pt2</code>. The closer the value of the parameter <code>f</code>
   * is to <code>1.0</code>, the closer the interpolated point is to the first
   * point(parameter <code>pt1</code>). The closer the value of the parameter
   * <code>f</code> is to 0, the closer the interpolated point is to the second
   * point(parameter <code>pt2</code>).
   *
   * @param pt1 The first point.
   * @param pt2 The second point.
   * @param f   The level of interpolation between the two points. Indicates
   *            where the new point will be, along the line between
   *            <code>pt1</code> and <code>pt2</code>. If <code>f</code>=1,
   *            <code>pt1</code> is returned; if <code>f</code>=0,
   *            <code>pt2</code> is returned.
   * @return The new, interpolated point.
   */
	public static interpolate(pt1: Point, pt2: Point, f: number): Point {
		return new (<SecurityDomain> this.sec).flash.geom.Point(AwayPoint.interpolate(pt1.adaptee, pt2.adaptee, f));
	}

	/**
   * Returns the distance between <code>pt1</code> and <code>pt2</code>.
   *
   * @param pt1 The first point.
   * @param pt2 The second point.
   * @return The distance between the first and second points.
   */
	public static distance(pt1: Point, pt2: Point): number {
		return AwayPoint.distance(pt1.adaptee, pt2.adaptee);
	}

	/**
   * Converts a pair of polar coordinates to a Cartesian point coordinate.
   *
   * @param len   The length coordinate of the polar pair.
   * @param angle The angle, in radians, of the polar pair.
   * @return The Cartesian point.
   */
	public static polar(len: number, angle: number): Point {
		return new (<SecurityDomain> this.sec).flash.geom.Point(AwayPoint.polar(+len, +angle));
	}

	/**
   * Creates a copy of this Point object.
   *
   * @return The new Point object.
   */
	public clone(): Point {
		return new (<SecurityDomain> this.sec).flash.geom.Point(this._adaptee.clone());
	}

	/**
   * Offsets the Point object by the specified amount. The value of
   * <code>dx</code> is added to the original value of <i>x</i> to create the
   * new <i>x</i> value. The value of <code>dy</code> is added to the original
   * value of <i>y</i> to create the new <i>y</i> value.
   *
   * @param dx The amount by which to offset the horizontal coordinate,
   *           <i>x</i>.
   * @param dy The amount by which to offset the vertical coordinate, <i>y</i>.
   */
	public offset(dx: number, dy: number): void {
		this._adaptee.offset(dx, dy);
	}

	/**
   * Determines whether two points are equal. Two points are equal if they have
   * the same <i>x</i> and <i>y</i> values.
   *
   * @param toCompare The point to be compared.
   * @return A value of <code>true</code> if the object is equal to this Point
   *         object; <code>false</code> if it is not equal.
   */
	public equals(toCompare: Point): boolean {
		return this._adaptee.equals(toCompare.adaptee);
	}

	/**
   * Subtracts the coordinates of another point from the coordinates of this
   * point to create a new point.
   *
   * @param v The point to be subtracted.
   * @return The new point.
   */
	public subtract(v: Point): Point {
		return new (<SecurityDomain> this.sec).flash.geom.Point(this._adaptee.subtract(v.adaptee));
	}

	/**
   * Adds the coordinates of another point to the coordinates of this point to
   * create a new point.
   *
   * @param v The point to be added.
   * @return The new point.
   */
	public add(v: Point): Point {
		return new (<SecurityDomain> this.sec).flash.geom.Point(this._adaptee.add(v.adaptee));
	}

	/**
   * Scales the line segment between(0,0) and the current point to a set
   * length.
   *
   * @param thickness The scaling value. For example, if the current point is
   *                 (0,5), and you normalize it to 1, the point returned is
   *                  at(0,1).
   */
	public normalize(thickness: number = 1): void {
		this._adaptee.normalize(+thickness);
	}

	public copyFrom(sourcePoint: Point): void {
		this._adaptee.copyFrom(sourcePoint.adaptee);
	}

	public setTo(x: number, y: number): void {
		this._adaptee.setTo(x, y);
	}

	public toString(): string {
		return '(x=' + this.x + ', y=' + this.y + ')';
	}
}