import { dataService } from "./DataService";
import { curveRoadPointService } from "./CurveRoadPointService";
import { curveEdgeService } from "./CurveEdgeService";
import { mathUtil } from "../Util/MathUtil.js";
import CurveRoad from "../Geometry/CurveRoad.js";
import VectorType from "../enum/VectorType";
import Constant from "../Constant";
import RoadService from "./RoadService";

export default class CurveRoadService extends RoadService {
  constructor() {
    super();
  }

  create(startId, endId, vectorId) {
    let curveRoad = new CurveRoad(startId, endId, vectorId);
    dataService.addCurveRoad(curveRoad);

    let startPoint = dataService.getCurveRoadPoint(startId);
    startPoint.setPointParent(curveRoad.vectorId);
    startPoint.setIndex(0);
    let endPoint = dataService.getCurveRoadPoint(endId);
    endPoint.setPointParent(curveRoad.vectorId);
    endPoint.setIndex(2);

    let edgePoints;
    if (curveRoad.way == Constant.oneWay) {
      edgePoints = mathUtil.RectangleVertex(
        startPoint,
        endPoint,
        curveRoad.singleRoadWidth
      );
    } else {
      edgePoints = mathUtil.RectangleVertex(
        startPoint,
        endPoint,
        curveRoad.leftWidth +
          curveRoad.rightWidth +
          curveRoad.midDivide.midDivideWidth
      );
    }

    let leftEdge = curveEdgeService.create(
      edgePoints.leftEdgeStart,
      edgePoints.leftEdgeEnd,
      null,
      vectorId
    );

    let rightEdge = curveEdgeService.create(
      edgePoints.rightEdgeStart,
      edgePoints.rightEdgeEnd,
      null,
      vectorId
    );

    curveRoad.setLeftEdge(leftEdge.vectorId);
    curveRoad.setRightEdge(rightEdge.vectorId);
    if (!vectorId) {
      leftEdge.setEdgeParent(curveRoad.vectorId);
      rightEdge.setEdgeParent(curveRoad.vectorId);
    }

    curveRoad.points.push(startPoint);
    curveRoad.points.push(endPoint);

    leftEdge.points.push(edgePoints.leftEdgeStart);
    leftEdge.points.push(edgePoints.leftEdgeEnd);

    rightEdge.points.push(edgePoints.rightEdgeStart);
    rightEdge.points.push(edgePoints.rightEdgeEnd);

    this.addCPoint(
      curveRoad,
      {
        x: (startPoint.x + endPoint.x) / 2,
        y: (startPoint.y + endPoint.y) / 2,
      },
      0
    );
    this.setLanes(curveRoad.vectorId);
    return curveRoad;
  }

  //不能加首尾，只能加中间
  //完全不处理车道，都放在setLanes上处理
  addCPoint(curveRoad, position, startIndex) {
    let point = curveRoadPointService.create(position);
    curveRoad.points.splice(startIndex + 1, 0, point);
    point.setPointParent(curveRoad.vectorId, startIndex);
    point.setIndex(startIndex + 1);
    for (let i = startIndex + 2; i < curveRoad.points.length; ++i) {
      curveRoad.points[i].setIndex(i);
    }

    let leftCount = curveRoad.leftDrivewayCount;
    let rightCount = curveRoad.rightDrivewayCount;
    let leftJoin = null;
    let rightJoin = null;
    const leftCurveEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);
    const rightCurveEdge = dataService.getCurveRoadEdge(curveRoad.rightEdgeId);
    let line1 = mathUtil.createLine1(
      curveRoad.points[startIndex],
      curveRoad.points[startIndex + 1]
    );
    let line2 = mathUtil.createLine1(
      curveRoad.points[startIndex + 1],
      curveRoad.points[startIndex + 2]
    );

    const leftLine = mathUtil.createLine1(
      leftCurveEdge.points[startIndex],
      leftCurveEdge.points[startIndex + 1]
    );
    let leftLine1 = mathUtil.createLine3(
      line1,
      leftCurveEdge.points[startIndex]
    );
    let leftLine2 = mathUtil.createLine3(
      line2,
      leftCurveEdge.points[startIndex + 1]
    );

    const rightLine = mathUtil.createLine1(
      rightCurveEdge.points[startIndex],
      rightCurveEdge.points[startIndex + 1]
    );
    let rightLine1 = mathUtil.createLine3(
      line1,
      rightCurveEdge.points[startIndex]
    );
    let rightLine2 = mathUtil.createLine3(
      line2,
      rightCurveEdge.points[startIndex + 1]
    );

    const line = mathUtil.createLine1(
      curveRoad.points[startIndex],
      curveRoad.points[startIndex + 2]
    );

    if (
      mathUtil.Angle(
        curveRoad.points[startIndex + 1],
        curveRoad.points[startIndex],
        curveRoad.points[startIndex + 2]
      ) > Constant.maxAngle
    ) {
      const join = mathUtil.getJoinLinePoint(position, line);
      let dx = position.x - join.x;
      let dy = position.y - join.y;

      leftJoin = mathUtil.getJoinLinePoint(position, leftLine);
      leftJoin.x += dx;
      leftJoin.y += dy;
      leftCurveEdge.points.splice(startIndex + 1, 0, leftJoin);
      curveEdgeService.setCurves(leftCurveEdge);

      rightJoin = mathUtil.getJoinLinePoint(position, rightLine);
      rightJoin.x += dx;
      rightJoin.y += dy;
      rightCurveEdge.points.splice(startIndex + 1, 0, rightJoin);
      curveEdgeService.setCurves(rightCurveEdge);
    } else {
      leftJoin = mathUtil.getIntersectionPoint(leftLine1, leftLine2);
      leftCurveEdge.points.splice(startIndex + 1, 0, leftJoin);
      curveEdgeService.setCurves(leftCurveEdge);

      rightJoin = mathUtil.getIntersectionPoint(rightLine1, rightLine2);
      rightCurveEdge.points.splice(startIndex + 1, 0, rightJoin);
      curveEdgeService.setCurves(rightCurveEdge);
    }
    this.setCurves(curveRoad);
  }

  subCPoint(curveRoad, index) {
    dataService.deleteCurveRoadPoint(curveRoad.points[index].vectorId);
    curveRoad.points.splice(index, 1);
    for (let i = index; i < curveRoad.points.length; ++i) {
      curveRoad.points[i].setIndex(i);
    }
    this.setCurves(curveRoad);

    const leftCurveEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);
    leftCurveEdge.points.splice(index, 1);
    curveEdgeService.setCurves(leftCurveEdge);

    const rightCurveEdge = dataService.getCurveRoadEdge(curveRoad.rightEdgeId);
    rightCurveEdge.points.splice(index, 1);
    curveEdgeService.setCurves(rightCurveEdge);
  }

  //单向车道
  setOneWayLanes(curveRoad) {
    let points = curveRoad.points;
    const leftEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);
    const rightEdge = dataService.getCurveRoadEdge(curveRoad.rightEdgeId);
    const leftEdgePoints = leftEdge.points;
    const rightEdgePoints = rightEdge.points;
    const singleRoadDrivewayCount = curveRoad.singleRoadDrivewayCount;

    let singleLanes = [];
    let singleLanesCurves = [];

    for (let i = 0; i < singleRoadDrivewayCount - 1; ++i) {
      for (let j = 0; j < points.length; ++j) {
        if (!singleLanes[i]) {
          singleLanes[i] = [];
        }

        const dx =
          (leftEdgePoints[j].x - rightEdgePoints[j].x) /
          singleRoadDrivewayCount;
        const dy =
          (leftEdgePoints[j].y - rightEdgePoints[j].y) /
          singleRoadDrivewayCount;

        singleLanes[i][j] = {};
        singleLanes[i][j].x = points[j].x + dx;
        singleLanes[i][j].y = points[j].y + dy;
      }
      singleLanesCurves[i] = mathUtil.getCurvesByPoints(singleLanes[i]);
    }
    curveRoad.singleLanes = singleLanes;
    curveRoad.singleLanesCurves = singleLanesCurves;
  }

  //双向车道
  setTwoWayLanes(curveRoad, dir) {
    let points = curveRoad.points;
    const leftEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);
    const rightEdge = dataService.getCurveRoadEdge(curveRoad.rightEdgeId);
    const leftEdgePoints = leftEdge.points;
    const rightEdgePoints = rightEdge.points;
    const leftCount = curveRoad.leftDrivewayCount;
    const rightCount = curveRoad.rightDrivewayCount;

    if (!curveRoad.midDivide) {
      curveRoad.midDivide = {
        leftMidDivide: [],
        leftMidDivideCurves: [],
        rightMidDivide: [],
        rightMidDivideCurves: [],
      };
    }
    let leftMidDivide = [];
    let rightMidDivide = [];
    let leftLanes = [];
    let leftLanesCurves = [];
    let rightLanes = [];
    let rightLanesCurves = [];

    if (dir == "left" || !dir) {
      for (let i = 0; i < leftCount - 1; ++i) {
        for (let j = 0; j < points.length; ++j) {
          if (!leftLanes[i]) {
            leftLanes[i] = [];
          }
          const leftRatio =
            curveRoad.leftWidth /
            (curveRoad.leftWidth + curveRoad.midDivide.midDivideWidth / 2);
          const leftdx =
            ((leftEdgePoints[j].x - points[j].x) * leftRatio) / leftCount;
          const leftdy =
            ((leftEdgePoints[j].y - points[j].y) * leftRatio) / leftCount;
          const middx = (leftEdgePoints[j].x - points[j].x) * (1 - leftRatio);
          const middy = (leftEdgePoints[j].y - points[j].y) * (1 - leftRatio);
          leftLanes[i][j] = {};
          leftLanes[i][j].x = points[j].x + middx + leftdx * (i + 1);
          leftLanes[i][j].y = points[j].y + middy + leftdy * (i + 1);
          if (!leftMidDivide[j]) {
            leftMidDivide[j] = {};
            leftMidDivide[j].x = points[j].x + middx;
            leftMidDivide[j].y = points[j].y + middy;
          }
        }
        leftLanesCurves[i] = mathUtil.getCurvesByPoints(leftLanes[i]);
      }

      if (leftMidDivide.length == 0) {
        for (let j = 0; j < points.length; ++j) {
          const leftRatio =
            curveRoad.leftWidth /
            (curveRoad.leftWidth + curveRoad.midDivide.midDivideWidth / 2);
          const middx = (leftEdgePoints[j].x - points[j].x) * (1 - leftRatio);
          const middy = (leftEdgePoints[j].y - points[j].y) * (1 - leftRatio);
          leftMidDivide[j] = {};
          leftMidDivide[j].x = points[j].x + middx;
          leftMidDivide[j].y = points[j].y + middy;
        }
      }
      curveRoad.midDivide.leftMidDivide = leftMidDivide;
      curveRoad.midDivide.leftMidDivideCurves =
        mathUtil.getCurvesByPoints(leftMidDivide);

      curveRoad.leftLanes = leftLanes;
      curveRoad.leftLanesCurves = leftLanesCurves;
    }

    if (dir == "right" || !dir) {
      for (let i = 0; i < rightCount - 1; ++i) {
        for (let j = 0; j < points.length; ++j) {
          if (!rightLanes[i]) {
            rightLanes[i] = [];
          }
          const rightRatio =
            curveRoad.rightWidth /
            (curveRoad.rightWidth + curveRoad.midDivide.midDivideWidth / 2);
          const rightdx =
            ((rightEdgePoints[j].x - points[j].x) * rightRatio) / rightCount;
          const rightdy =
            ((rightEdgePoints[j].y - points[j].y) * rightRatio) / rightCount;
          const middx = (rightEdgePoints[j].x - points[j].x) * (1 - rightRatio);
          const middy = (rightEdgePoints[j].y - points[j].y) * (1 - rightRatio);
          rightLanes[i][j] = {};
          rightLanes[i][j].x = points[j].x + middx + rightdx * (i + 1);
          rightLanes[i][j].y = points[j].y + middy + rightdy * (i + 1);
          if (!rightMidDivide[j]) {
            rightMidDivide[j] = {};
            rightMidDivide[j].x = points[j].x + middx;
            rightMidDivide[j].y = points[j].y + middy;
          }
        }
        rightLanesCurves[i] = mathUtil.getCurvesByPoints(rightLanes[i]);
      }
      if (rightMidDivide.length == 0) {
        for (let j = 0; j < points.length; ++j) {
          const rightRatio =
            curveRoad.rightWidth /
            (curveRoad.rightWidth + curveRoad.midDivide.midDivideWidth / 2);
          const middx = (rightEdgePoints[j].x - points[j].x) * (1 - rightRatio);
          const middy = (rightEdgePoints[j].y - points[j].y) * (1 - rightRatio);
          rightMidDivide[j] = {};
          rightMidDivide[j].x = points[j].x + middx;
          rightMidDivide[j].y = points[j].y + middy;
        }
      }
      curveRoad.midDivide.rightMidDivide = rightMidDivide;
      curveRoad.midDivide.rightMidDivideCurves =
        mathUtil.getCurvesByPoints(rightMidDivide);
      curveRoad.rightLanes = rightLanes;
      curveRoad.rightLanesCurves = rightLanesCurves;
    }
  }

  //车道
  //points的第一个元素是start，最后一个是end
  setLanes(curveRoadId, dir) {
    let curveRoad = dataService.getCurveRoad(curveRoadId);
    if (curveRoad.way == Constant.oneWay) {
      this.setOneWayLanes(curveRoad);
    } else if (curveRoad.way == Constant.twoWay) {
      this.setTwoWayLanes(curveRoad, dir);
    }
  }

  //删除或者减少车道
  updateForAddSubtractLanesCount(curveRoad, newCount, dir) {
    let curveEdge, oldCount, lanes;
    const leftCurveEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);
    const rightCurveEdge = dataService.getCurveRoadEdge(curveRoad.rightEdgeId);
    if (newCount < 0) {
      newCount = 0;
    }

    let ratio = null;
    if (curveRoad.way == Constant.twoWay) {
      if (dir == "left") {
        curveEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);
        oldCount = curveRoad.leftDrivewayCount;
        curveRoad.leftDrivewayCount = newCount;
        lanes = curveRoad.leftLanes;
        ratio =
          curveRoad.leftWidth /
          (curveRoad.leftWidth + curveRoad.midDivide.midDivideWidth / 2);
      } else if (dir == "right") {
        curveEdge = dataService.getCurveRoadEdge(curveRoad.rightEdgeId);
        oldCount = curveRoad.rightDrivewayCount;
        curveRoad.rightDrivewayCount = newCount;
        lanes = curveRoad.rightLanes;
        ratio =
          curveRoad.rightWidth /
          (curveRoad.rightWidth + curveRoad.midDivide.midDivideWidth / 2);
      }
    }

    if (newCount == oldCount) {
      return;
    } else if (newCount == 0) {
      this.mulToSinglelane(curveRoad);
      return;
    } else if (oldCount == 0) {
      this.singleToMullane(curveRoad);
      return;
    }

    if (curveRoad.way == Constant.twoWay) {
      for (let i = 0; i < curveRoad.points.length; ++i) {
        const middx =
          (curveEdge.points[i].x - curveRoad.points[i].x) * (1 - ratio);
        const middy =
          (curveEdge.points[i].y - curveRoad.points[i].y) * (1 - ratio);
        const dx =
          ((curveEdge.points[i].x - curveRoad.points[i].x) * ratio) / oldCount;
        curveEdge.points[i].x = curveRoad.points[i].x + middx + dx * newCount;
        const dy =
          ((curveEdge.points[i].y - curveRoad.points[i].y) * ratio) / oldCount;
        curveEdge.points[i].y = curveRoad.points[i].y + middy + dy * newCount;
      }

      mathUtil.clonePoint(curveEdge.start, curveEdge.points[0]);
      mathUtil.clonePoint(
        curveEdge.end,
        curveEdge.points[curveEdge.points.length - 1]
      );
      curveEdgeService.setCurves(curveEdge);
      const line = mathUtil.createLine1(
        curveRoad.points[0],
        curveRoad.points[1]
      );
      if (dir == "left") {
        const leftWidth =
          mathUtil.getDisForPoinLine(leftCurveEdge.start, line) -
          curveRoad.midDivide.midDivideWidth / 2;
        curveRoad.setWidth(leftWidth, "left");
      } else if (dir == "right") {
        const rightWidth =
          mathUtil.getDisForPoinLine(rightCurveEdge.start, line) -
          curveRoad.midDivide.midDivideWidth / 2;
        curveRoad.setWidth(rightWidth, "right");
      }
    } else if (curveRoad.way == Constant.oneWay) {
      oldCount = curveRoad.singleRoadDrivewayCount;
      for (let i = 0; i < curveRoad.points.length; ++i) {
        let dx =
          (leftCurveEdge.points[i].x - rightCurveEdge.points[i].x) / oldCount;
        let dy =
          (leftCurveEdge.points[i].y - rightCurveEdge.points[i].y) / oldCount;

        leftCurveEdge.points[i].x = curveRoad.points[i].x + (dx * newCount) / 2;
        leftCurveEdge.points[i].y = curveRoad.points[i].y + (dy * newCount) / 2;
        mathUtil.clonePoint(leftCurveEdge.start, leftCurveEdge.points[0]);
        mathUtil.clonePoint(
          leftCurveEdge.end,
          leftCurveEdge.points[leftCurveEdge.points.length - 1]
        );
        curveEdgeService.setCurves(leftCurveEdge);

        dx = -1 * dx;
        dy = -1 * dy;
        rightCurveEdge.points[i].x =
          curveRoad.points[i].x + (dx * newCount) / 2;
        rightCurveEdge.points[i].y =
          curveRoad.points[i].y + (dy * newCount) / 2;
        mathUtil.clonePoint(rightCurveEdge.start, rightCurveEdge.points[0]);
        mathUtil.clonePoint(
          rightCurveEdge.end,
          rightCurveEdge.points[rightCurveEdge.points.length - 1]
        );
        curveEdgeService.setCurves(rightCurveEdge);
      }

      const line = mathUtil.createLine1(
        curveRoad.leftCurveEdge.points[0],
        curveRoad.leftCurveEdge.points[1]
      );
      const singleRoadWidth = mathUtil.getDisForPoinLine(
        rightCurveEdge.start,
        line
      );
      curveRoad.setWidth(singleRoadWidth);
    }
    this.setLanes(curveRoad.vectorId, dir);
  }

  //单车道转多车道，默认是转换成左右两边各一个
  //不改变路的宽度
  singleToMullane(curveRoad) {}

  //多车道转单车道
  mulToSinglelane(curveRoad) {
    if (curveRoad.leftDrivewayCount > 0) {
      this.updateForAddSubtractLanesCount(curveRoad, 1, "left");
    }
    if (curveRoad.rightDrivewayCount > 0) {
      this.updateForAddSubtractLanesCount(curveRoad, 1, "right");
    }
    curveRoad.leftDrivewayCount = 0;
    curveRoad.rightDrivewayCount = 0;
    curveRoad.leftLanesCurves = [];
    curveRoad.rightLanesCurves = [];
    curveRoad.leftLanes = [];
    curveRoad.rightLanes = [];
  }

  updateForMovePoint(pointId, position) {
    let curvePoint = dataService.getCurveRoadPoint(pointId);
    let curveRoadId = curvePoint.getParent();
    let curveRoad = dataService.getCurveRoad(curveRoadId);
    const leftCurveEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);
    const rightCurveEdge = dataService.getCurveRoadEdge(curveRoad.rightEdgeId);
    let startPoint = dataService.getCurveRoadPoint(curveRoad.startId);
    let endPoint = dataService.getCurveRoadPoint(curveRoad.endId);
    let index = curvePoint.getIndex();
    mathUtil.clonePoint(curveRoad.points[index], position);
    if (index == 0) {
      mathUtil.clonePoint(startPoint, position);
    } else if (index == curveRoad.points.length - 1) {
      mathUtil.clonePoint(endPoint, position);
    }
    let edgePoints = null;
    if (curveRoad.way == Constant.oneWay) {
      edgePoints = mathUtil.getOffset(
        curveRoad.points,
        curveRoad.leftWidth + curveRoad.midDivide.midDivideWidth / 2,
        curveRoad.rightWidth + curveRoad.midDivide.midDivideWidth / 2
      );
    } else if (curveRoad.way == Constant.twoWay) {
      const line = mathUtil.createLine1(
        curveRoad.points[0],
        curveRoad.points[1]
      );
      const leftWidth = mathUtil.getDisForPoinLine(leftCurveEdge.start, line);
      const rightWidth = mathUtil.getDisForPoinLine(rightCurveEdge.start, line);
      edgePoints = mathUtil.getOffset(curveRoad.points, leftWidth, rightWidth);
    }

    leftCurveEdge.points = edgePoints.leftEdgePoints;
    leftCurveEdge.start = leftCurveEdge.points[0];
    leftCurveEdge.end = leftCurveEdge.points[leftCurveEdge.points.length - 1];

    rightCurveEdge.points = edgePoints.rightEdgePoints;
    rightCurveEdge.start = rightCurveEdge.points[0];
    rightCurveEdge.end =
      rightCurveEdge.points[rightCurveEdge.points.length - 1];

    curveEdgeService.setCurves(leftCurveEdge);
    curveEdgeService.setCurves(rightCurveEdge);
    this.setCurves(curveRoad);
    this.setLanes(curveRoadId);
  }

  //变宽或者变窄（车道数据不变）
  //单向的情况下，左右两边同时变宽或者变窄，即：dir无效
  updateForWidth(curveRoadId, newWidth, dir) {
    let curveRoad = dataService.getCurveRoad(curveRoadId);
    let leftCurveEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);
    let rightCurveEdge = dataService.getCurveRoadEdge(curveRoad.rightEdgeId);

    let ratio = null;
    let dx = null;
    let dy = null;
    //需要考虑中间带
    if (dir == "left") {
      ratio =
        (newWidth + curveRoad.midDivide.midDivideWidth / 2) /
        (curveRoad.leftWidth + curveRoad.midDivide.midDivideWidth / 2);
    } else if (dir == "right") {
      ratio =
        (newWidth + curveRoad.midDivide.midDivideWidth / 2) /
        (curveRoad.rightWidth + curveRoad.midDivide.midDivideWidth / 2);
    } else {
      if (curveRoad.way == Constant.oneWay) {
        ratio = newWidth / curveRoad.singleRoadWidth;
      }
    }

    for (let i = 0; i < curveRoad.points.length; ++i) {
      if (dir == "left") {
        dx = (leftCurveEdge.points[i].x - curveRoad.points[i].x) * ratio;
        leftCurveEdge.points[i].x = curveRoad.points[i].x + dx;
        dy = (leftCurveEdge.points[i].y - curveRoad.points[i].y) * ratio;
        leftCurveEdge.points[i].y = curveRoad.points[i].y + dy;
      } else if (dir == "right") {
        dx = (rightCurveEdge.points[i].x - curveRoad.points[i].x) * ratio;
        rightCurveEdge.points[i].x = curveRoad.points[i].x + dx;
        dy = (rightCurveEdge.points[i].y - curveRoad.points[i].y) * ratio;
        rightCurveEdge.points[i].y = curveRoad.points[i].y + dy;
      } else {
        if (curveRoad.way == Constant.oneWay) {
          dx = (leftCurveEdge.points[i].x - curveRoad.points[i].x) * ratio;
          leftCurveEdge.points[i].x = curveRoad.points[i].x + dx;
          dy = (leftCurveEdge.points[i].y - curveRoad.points[i].y) * ratio;
          leftCurveEdge.points[i].y = curveRoad.points[i].y + dy;
          dx = (rightCurveEdge.points[i].x - curveRoad.points[i].x) * ratio;
          rightCurveEdge.points[i].x = curveRoad.points[i].x + dx;
          dy = (rightCurveEdge.points[i].y - curveRoad.points[i].y) * ratio;
          rightCurveEdge.points[i].y = curveRoad.points[i].y + dy;
        } else if (curveRoad.way == Constant.twoWay) {
          ratio = newWidth / (curveRoad.leftWidth + curveRoad.rightWidth);
          ratio =
            (curveRoad.leftWidth * ratio +
              curveRoad.midDivide.midDivideWidth / 2) /
            (curveRoad.leftWidth + curveRoad.midDivide.midDivideWidth / 2);
          dx = (leftCurveEdge.points[i].x - curveRoad.points[i].x) * ratio;
          leftCurveEdge.points[i].x = curveRoad.points[i].x + dx;
          dy = (leftCurveEdge.points[i].y - curveRoad.points[i].y) * ratio;
          leftCurveEdge.points[i].y = curveRoad.points[i].y + dy;
          ratio = newWidth / (curveRoad.leftWidth + curveRoad.rightWidth);
          ratio =
            (curveRoad.rightWidth * ratio +
              curveRoad.midDivide.midDivideWidth / 2) /
            (curveRoad.rightWidth + curveRoad.midDivide.midDivideWidth / 2);
          dx = (rightCurveEdge.points[i].x - curveRoad.points[i].x) * ratio;
          rightCurveEdge.points[i].x = curveRoad.points[i].x + dx;
          dy = (rightCurveEdge.points[i].y - curveRoad.points[i].y) * ratio;
          rightCurveEdge.points[i].y = curveRoad.points[i].y + dy;
        }
      }
    }

    if (dir == "left") {
      curveEdgeService.setCurves(leftCurveEdge);
      curveRoad.setWidth(newWidth, dir);
    } else if (dir == "right") {
      curveEdgeService.setCurves(rightCurveEdge);
      curveRoad.setWidth(newWidth, dir);
    } else {
      curveEdgeService.setCurves(leftCurveEdge);
      curveEdgeService.setCurves(rightCurveEdge);
      if (curveRoad.way == Constant.oneWay) {
        curveRoad.setWidth(newWidth);
      } else if (curveRoad.way == Constant.twoWay) {
        curveRoad.setWidth(
          (newWidth * curveRoad.leftWidth) /
            (curveRoad.leftWidth + curveRoad.rightWidth),
          "left"
        );
        curveRoad.setWidth(
          (newWidth * curveRoad.rightWidth) /
            (curveRoad.leftWidth + curveRoad.rightWidth),
          "right"
        );
      }
    }
    this.setLanes(curveRoadId, dir);
  }

  setCurves(curveRoad) {
    curveRoad.curves = mathUtil.getCurvesByPoints(curveRoad.points);
  }

  unlock(curveRoadId) {
    let curveRoad = dataService.getCurveRoad(curveRoadId);
    let leftCurveEdge = dataService.getCurveRoadEdge(curveRoad.leftEdgeId);
    let rightCurveEdge = dataService.getCurveRoadEdge(curveRoad.rightEdgeId);
    let lanes = curveRoad.lanes;

    for (let i = 0; i < curveRoad.curves.length; ++i) {
      dataService.createCurveLine(curveRoad.curves[i]);
    }
    for (let i = 0; i < leftCurveEdge.curves.length; ++i) {
      dataService.createCurveLine(leftCurveEdge.curves[i]);
    }
    for (let i = 0; i < rightCurveEdge.curves.length; ++i) {
      dataService.createCurveLine(rightCurveEdge.curves[i]);
    }
    for (let i = 0; i < lanes.length; ++i) {
      for (let j = 0; j < lanes[i].curves.length; ++j) {
        dataService.createCurveLine(lanes[i].curves[j]);
      }
    }
    dataService.deleteCurveRoad(curveRoadId);
  }
}

const curveRoadService = new CurveRoadService();
export { curveRoadService };