import { GeometricObject } from "../../../core/models/objects/geometric-object";
import { IntersectionModel } from "../../intersection-component/models/intersection-model";
import { ELEMENTS_CLASS } from "../../../core/enums/elements-class-enum";
export class LineSegmentModel extends GeometricObject {
  constructor(pointA, pointB, label, id) {
    super(id);
    this.pointA = pointA;
    this.pointB = pointB;
    this.setLabel(label);
    super.setClass(ELEMENTS_CLASS.LINE_SEGMENT);
    this.definitions.push(this.pointA);
    this.definitions.push(this.pointB);
  }
  getStraight() {
    const aX = this.pointA.posX;
    const aY = this.pointA.posY;
    const bX = this.pointB.posX;
    const bY = this.pointB.posY;
    const a = bY - aY;
    const b = aX - bX;
    const c = a * aX + b * aY;
    return [a, b, c];
  }
  getDirection() {
    const aX = this.pointA.posX;
    const aY = this.pointA.posY;
    const bX = this.pointB.posX;
    const bY = this.pointB.posY;
    const a = bX - aX;
    const b = bY - aY;
    return [a, b];
  }
  getIntersection(geometricObject) {
    switch (geometricObject.elementClass) {
      case ELEMENTS_CLASS.LINE_SEGMENT:
        return this.getIntersectionByLine(geometricObject);
      case ELEMENTS_CLASS.CIRCUMFERENCE:
        return this.getIntersectionByCircumference(geometricObject);
      default:
        break;
    }
  }

  getIntersectionByLine(lineSegment) {
    const r = this.getStraight();
    const s = lineSegment.getStraight();
    const a1 = r[0];
    const b1 = r[1];
    const c1 = r[2];
    const a2 = s[0];
    const b2 = s[1];
    const c2 = s[2];
    const determinant = a1 * b2 - a2 * b1;
    if (determinant == 0) {
      return [
        new IntersectionModel(
          Number.MAX_SAFE_INTEGER,
          Number.MAX_SAFE_INTEGER,
          undefined,
          this,
          lineSegment
        )
      ];
    } else {
      const x = (b2 * c1 - b1 * c2) / determinant;
      const y = (a1 * c2 - a2 * c1) / determinant;
      return [new IntersectionModel(x, y, undefined, this, lineSegment)];
    }
  }

  getIntersectionByCircumference(circumference) {
    const r = this.getStraight();
    const s = circumference.getStraight();
    const a1 = r[0];
    const b1 = r[1];
    const c1 = r[2];
    const a2 = s[0];
    const b2 = s[1];
    const c2 = s[2];
    const determinant = a1 * b2 - a2 * b1;
    if (determinant == 0) {
      return [
        new IntersectionModel(
          Number.MAX_SAFE_INTEGER,
          Number.MAX_SAFE_INTEGER,
          undefined,
          this,
          circumference
        )
      ];
    } else {
      const x = (b2 * c1 - b1 * c2) / determinant;
      const y = (a1 * c2 - a2 * c1) / determinant;
      return [new IntersectionModel(x, y, undefined, this, circumference)];
    }
  }

  insideSegment(intersecX, intersecY) {
    const valuesR = this.getDirection();
    const dirX = valuesR[0];
    const dirY = valuesR[1];
    const cInterA = dirX * intersecX + dirY * intersecY;

    // comparaca cv do ponto A > cv da intersec =>  vazio
    const cRA = dirX * this.pointA.posX + dirY * this.pointA.posY;

    if (cInterA < cRA) {
      return false;
    }

    // comparaca cv do ponto B < cv da intersec =>  vazio
    const cRB = dirX * this.pointB.posX + dirY * this.pointB.posY;

    if (cInterA > cRB) {
      this.posX = Number.MAX_SAFE_INTEGER;
      this.posY = Number.MAX_SAFE_INTEGER;
      return false;
    }

    return true;
  }
  static do(map, list) {
    const id = map.get("id");
    const pointAId = map.get("param")[0];
    const pointBId = map.get("param")[1];
    const pointA = list.find(x => x.id === pointAId);
    const pointB = list.find(x => x.id === pointBId);
    const label = map.get("label")[0];
    return new LineSegmentModel(pointA, pointB, label, id);
  }
}