import { mathUtil } from "../Util/MathUtil";
import { dataService } from "../Service/DataService";
import { textService } from "../Service/TextService";
import Constant from "../Constant";

export default class HistoryUtil {
  constructor() {}

  isDifferentForPoints(point1, point2) {
    if (
      point1.x == point2.x &&
      point1.y == point2.y &&
      mathUtil.equalJSON(point1.parent, point1.parent) &&
      point1.category == point2.category &&
      point1.locationMode == point2.locationMode &&
      point1.linkedBasePointId == point2.linkedBasePointId &&
      point1.linkedTestPointId == point2.linkedTestPointId
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForLines(line1, line2) {
    if (
      line1.startId == line2.startId &&
      line1.endId == line2.endId &&
      line1.category == line2.category
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForCircles(circle1, circle2) {
    if (
      mathUtil.equalPoint(circle1.center, circle2.center) &&
      circle1.radius == circle2.radius &&
      circle1.color == circle2.color
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForTexts(text1, text2) {
    if (
      mathUtil.equalPoint(text1.center, text2.center) &&
      text1.value == text2.value
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForMagnifiers(magnifier1, magnifier2) {
    if (
      mathUtil.equalPoint(magnifier1.position, magnifier2.position) &&
      magnifier1.photoUrl == magnifier2.photoUrl
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForSVGs(svg1, svg2) {
    if (
      mathUtil.equalPoint(svg1.center, svg2.center) &&
      svg1.name == svg2.name
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForRoadPoints(roadPoint1, roadPoint2) {
    if (
      mathUtil.equalPoint(roadPoint1, roadPoint2) &&
      mathUtil.equalJSON(roadPoint1.parent, roadPoint2.parent)
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForRoadEdges(roadEdge1, roadEdge2) {
    if (
      mathUtil.equalPoint(roadEdge1.start, roadEdge2.start) &&
      mathUtil.equalPoint(roadEdge1.end, roadEdge2.end) &&
      roadEdge1.parent == roadEdge2.parent
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForRoads(road1, road2) {
    if (
      road1.startId == road2.startId &&
      road1.endId == road2.endId &&
      road1.leftEdgeId == road2.leftEdgeId &&
      road1.rightEdgeId == road2.rightEdgeId &&
      road1.way == road2.way
    ) {
      if (road1.way == Constant.oneWay) {
        if (
          road1.singleRoadWidth == road2.singleRoadWidth &&
          road1.singleRoadDrivewayCount == road2.singleRoadDrivewayCount
        ) {
          return false;
        } else {
          return true;
        }
      } else if (road1.way == Constant.twoWay) {
        if (
          road1.leftWidth == road2.leftWidth &&
          road1.rightWidth == road2.rightWidth &&
          road1.leftDrivewayCount == road2.leftDrivewayCount &&
          road1.rightDrivewayCount == road2.rightDrivewayCount &&
          road1.midDivide.midDivideWidth == road2.midDivide.midDivideWidth
        ) {
          return false;
        } else {
          return true;
        }
      } else {
        return true;
      }
    } else {
      return true;
    }
  }

  isDifferentForCurveRoadPoints(curveRoadPoint1, curveRoadPoint2) {
    if (
      mathUtil.equalPoint(curveRoadPoint1, curveRoadPoint2) &&
      mathUtil.equalJSON(curveRoadPoint1.parent, curveRoadPoint2.parent) &&
      curveRoadPoint1.index == curveRoadPoint2.index
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForCurveRoadEdges(curveRoadEdge1, curveRoadEdge2) {
    if (
      mathUtil.equalPoint(curveRoadEdge1.start, curveRoadEdge2.start) &&
      mathUtil.equalPoint(curveRoadEdge1.end, curveRoadEdge2.end) &&
      mathUtil.equalPoints(curveRoadEdge1.points, curveRoadEdge2.points) &&
      curveRoadEdge1.parent == curveRoadEdge2.parent
    ) {
      return false;
    } else {
      return true;
    }
  }

  isDifferentForCurveRoads(curveRoad1, curveRoad2) {
    if (
      curveRoad1.startId == curveRoad2.startId &&
      curveRoad1.endId == curveRoad2.endId &&
      mathUtil.equalPoints(curveRoad1.points, curveRoad2.points) &&
      curveRoad1.leftEdgeId == curveRoad2.leftEdgeId &&
      curveRoad1.rightEdgeId == curveRoad2.rightEdgeId &&
      curveRoad1.way == curveRoad2.way
    ) {
      if (curveRoad1.way == Constant.oneWay) {
        if (
          curveRoad1.singleRoadWidth == curveRoad2.singleRoadWidth &&
          curveRoad1.singleRoadDrivewayCount ==
            curveRoad2.singleRoadDrivewayCount
        ) {
          return false;
        } else {
          return true;
        }
      } else if (curveRoad1.way == Constant.twoWay) {
        if (
          curveRoad1.leftWidth == curveRoad2.leftWidth &&
          curveRoad1.rightWidth == curveRoad2.rightWidth &&
          curveRoad1.leftDrivewayCount == curveRoad2.leftDrivewayCount &&
          curveRoad1.rightDrivewayCount == curveRoad2.rightDrivewayCount &&
          curveRoad1.midDivide.midDivideWidth ==
            curveRoad2.midDivide.midDivideWidth
        ) {
          return false;
        } else {
          return true;
        }
      } else {
        return true;
      }
    } else {
      return true;
    }
  }

  isDifferentForCrossPoints(crossPoint1, crossPoint2) {
    if (
      mathUtil.equalPoint(crossPoint1, crossPoint2) &&
      mathUtil.equalPoint(crossPoint1.extremePoint, crossPoint2.extremePoint) &&
      crossPoint1.edgeInfo1.id == crossPoint2.edgeInfo1.id &&
      crossPoint1.edgeInfo1.dir == crossPoint2.edgeInfo1.dir &&
      crossPoint1.edgeInfo2.id == crossPoint2.edgeInfo2.id &&
      crossPoint1.edgeInfo2.dir == crossPoint2.edgeInfo2.dir
    ) {
      return false;
    } else {
      return true;
    }
  }

  assignPointFromPoint(point1, point2) {
    const pointInfo = {};
    pointInfo.vectorId = point1.vectorId;
    pointInfo.position = { x: point2.x, y: point2.y };
    pointInfo.parent = JSON.parse(JSON.stringify(point2.parent));
    pointInfo.locationMode = point2.locationMode;
    pointInfo.linkedBasePointId = point2.linkedBasePointId;
    pointInfo.linkedTestPointId = point2.linkedTestPointId;
    pointInfo.category = point2.category;
    this.setPointInfo(pointInfo);
  }

  assignLineFromLine(line1, line2) {
    const lineInfo = {};
    lineInfo.vectorId = line1.vectorId;
    lineInfo.start = line2.start;
    lineInfo.end = line2.end;
    lineInfo.category = line2.category;
    lineInfo.value = line2.value;
    this.setLineInfo(lineInfo);
  }

  assignCircleFromCircle(circle1, circle2) {
    const circleInfo = {};
    circleInfo.vectorId = circle1.vectorId;
    circleInfo.center = circle2.center;
    circleInfo.radius = circle2.radius;
    circleInfo.points = JSON.parse(JSON.stringify(circle2.points));
    circleInfo.color = circle2.color;
    this.setCircleInfo(circleInfo);
  }

  assignTextFromText(text1, text2) {
    const textInfo = {};
    textInfo.vectorId = text1.vectorId;
    textInfo.value = text2.value;
    textInfo.center = JSON.parse(JSON.stringify(text2.center));
    this.setTextInfo(textInfo);
  }

  assignMagnifierFromMagnifier(magnifier1, magnifier2) {
    const magnifierInfo = {};
    magnifierInfo.vectorId = magnifier1.vectorId;
    magnifierInfo.photoUrl = magnifier2.photoUrl;
    magnifierInfo.position = JSON.parse(JSON.stringify(magnifier2.position));
    magnifierInfo.popPosition = JSON.parse(
      JSON.stringify(magnifier2.popPosition)
    );
    this.setMagnifierInfo(magnifierInfo);
  }

  assignSVGFromSVG(svg1, svg2) {
    const svgInfo = {};
    svgInfo.vectorId = svg1.vectorId;
    svgInfo.name = svg2.name;
    svgInfo.center = JSON.parse(JSON.stringify(svg2.center));
    this.setSVGInfo(svgInfo);
  }

  assignRoadPointFromRoadPoint(roadPoint1, roadPoint2) {
    const roadPointInfo = {};
    roadPointInfo.vectorId = roadPoint1.vectorId;
    roadPointInfo.position = {
      x: roadPoint2.position.x,
      y: roadPoint2.position.y,
    };
    roadPointInfo.parent = JSON.parse(JSON.stringify(roadPoint2.parent));
    this.setRoadPointInfo(roadPointInfo);
  }

  assignRoadEdgeFromRoadEdge(roadEdge1, roadEdge2) {
    const roadEdgeInfo = {};
    roadEdgeInfo.vectorId = roadEdge1.vectorId;
    roadEdgeInfo.start = { x: roadEdge2.start.x, y: roadEdge2.start.y };
    roadEdgeInfo.end = { x: roadEdge2.end.x, y: roadEdge2.end.y };
    roadEdgeInfo.parent = roadEdge2.parent;
    this.setRoadEdgeInfo(roadEdgeInfo);
  }

  assignRoadFromRoad(road1, road2) {
    const roadInfo = {};
    roadInfo.vectorId = road1.vectorId;
    roadInfo.startId = road2.startId;
    roadInfo.endId = road2.endId;
    roadInfo.leftEdgeId = road2.leftEdgeId;
    roadInfo.rightEdgeId = road2.rightEdgeId;
    roadInfo.way = road2.way;
    if (road2.way == Constant.oneWay) {
      roadInfo.singleRoadWidth = road2.singleRoadWidth;
      roadInfo.singleRoadDrivewayCount = road2.singleRoadDrivewayCount;
      roadInfo.singleLanes = JSON.parse(JSON.stringify(road2.singleLanes));
    } else if (road2.way == Constant.twoWay) {
      roadInfo.leftWidth = road2.leftWidth;
      roadInfo.rightWidth = road2.rightWidth;
      roadInfo.leftDrivewayCount = road2.leftDrivewayCount;
      roadInfo.rightDrivewayCount = road2.rightDrivewayCount;
      roadInfo.midDivide = JSON.parse(JSON.stringify(road2.midDivide));
      roadInfo.leftLanes = JSON.parse(JSON.stringify(road2.leftLanes));
      roadInfo.rightLanes = JSON.parse(JSON.stringify(road2.rightLanes));
    }
    this.setRoadInfo(roadInfo);
  }

  assignCurveRoadPointFromCurveRoadPoint(curveRoadPoint1, curveRoadPoint2) {
    const curveRoadPointInfo = {};
    curveRoadPointInfo.vectorId = curveRoadPoint1.vectorId;
    curveRoadPointInfo.position = {
      x: curveRoadPoint2.position.x,
      y: curveRoadPoint2.position.y,
    };
    curveRoadPointInfo.parent = JSON.parse(
      JSON.stringify(curveRoadPoint2.parent)
    );
    curveRoadPointInfo.index = curveRoadPoint1.index;
    this.setCurveRoadPointInfo(curveRoadPointInfo);
  }

  assignCurveRoadEdgeFromCurveRoadEdge(curveRoadEdge1, curveRoadEdge2) {
    const curveRoadEdgeInfo = {};
    curveRoadEdgeInfo.vectorId = curveRoadEdge1.vectorId;
    curveRoadEdgeInfo.start = {
      x: curveRoadEdge2.start.x,
      y: curveRoadEdge2.start.y,
    };
    curveRoadEdgeInfo.end = {
      x: curveRoadEdge2.end.x,
      y: curveRoadEdge2.end.y,
    };
    curveRoadEdgeInfo.points = JSON.parse(
      JSON.stringify(curveRoadEdge2.points)
    );
    curveRoadEdgeInfo.curves = JSON.parse(
      JSON.stringify(curveRoadEdge2.curves)
    );
    curveRoadEdgeInfo.parent = curveRoadEdge2.parent;
    this.setCurveRoadEdgeInfo(curveRoadEdgeInfo);
  }

  assignCurveRoadFromCurveRoad(curveRoad1, curveRoad2) {
    const curveRoadInfo = {};
    curveRoadInfo.vectorId = curveRoad1.vectorId;
    curveRoadInfo.startId = curveRoad2.startId;
    curveRoadInfo.endId = curveRoad2.endId;
    curveRoadInfo.leftEdgeId = curveRoad2.leftEdgeId;
    curveRoadInfo.rightEdgeId = curveRoad2.rightEdgeId;
    curveRoadInfo.way = curveRoad2.way;
    if (curveRoad2.way == Constant.oneWay) {
      curveRoadInfo.singleRoadWidth = curveRoad2.singleRoadWidth;
      curveRoadInfo.singleRoadDrivewayCount =
        curveRoad2.singleRoadDrivewayCount;
      curveRoadInfo.singleLanes = JSON.parse(
        JSON.stringify(curveRoad2.singleLanes)
      );
    } else if (curveRoad2.way == Constant.twoWay) {
      curveRoadInfo.leftWidth = curveRoad2.leftWidth;
      curveRoadInfo.rightWidth = curveRoad2.rightWidth;
      curveRoadInfo.leftDrivewayCount = curveRoad2.leftDrivewayCount;
      curveRoadInfo.rightDrivewayCount = curveRoad2.rightDrivewayCount;
      curveRoadInfo.midDivide = JSON.parse(
        JSON.stringify(curveRoad2.midDivide)
      );
      curveRoadInfo.leftLanes = JSON.parse(
        JSON.stringify(curveRoad2.leftLanes)
      );
      curveRoadInfo.rightLanes = JSON.parse(
        JSON.stringify(curveRoad2.rightLanes)
      );
    }
    curveRoadInfo.points = [];
    for (let i = 0; i < curveRoad2.points.length; ++i) {
      curveRoadInfo.points[i] = {};
      curveRoadInfo.points[i].vectorId = curveRoad2.points[i].vectorId;
    }
    this.setCurveRoadInfo(curveRoadInfo);
  }

  assignCrossPointFromCrossPoint(crossPoint1, crossPoint2) {
    const crossPointInfo = {};
    crossPointInfo.vectorId = crossPoint1.vectorId;
    crossPointInfo.position = {
      x: crossPoint2.position.x,
      y: crossPoint2.position.y,
    };
    crossPointInfo.edgeInfo1 = JSON.parse(
      JSON.stringify(crossPoint2.edgeInfo1)
    );
    crossPointInfo.edgeInfo2 = JSON.parse(
      JSON.stringify(crossPoint2.edgeInfo2)
    );
    crossPoint1.edgeInfo1 = JSON.parse(JSON.stringify(crossPoint2.edgeInfo1));
    crossPoint1.edgeInfo2 = JSON.parse(JSON.stringify(crossPoint2.edgeInfo2));
    dataService.addCrossPoint(crossPoint1);
    crossPointInfo.extremePoint = {
      x: crossPoint2.extremePoint.x,
      y: crossPoint2.extremePoint.y,
    };
    crossPointInfo.curves = JSON.parse(JSON.stringify(crossPoint2.curves));
    this.setCrossPointInfo(crossPointInfo);
  }

  getDataForPoint(point) {
    const data = {};
    data.id = point.vectorId;
    mathUtil.clonePoint(data, point);
    data.parent = JSON.parse(JSON.stringify(point.parent));
    data.category = point.category;
    data.locationMode = point.locationMode;
    data.linkedBasePointId = point.linkedBasePointId;
    data.linkedTestPointId = point.linkedTestPointId;
    data.type = point.geoType;
    return data;
  }

  getDataForLine(line) {
    const data = {};
    data.id = line.vectorId;
    data.start = line.startId;
    data.end = line.endId;
    data.category = line.category;
    data.type = line.geoType;
    return data;
  }

  getDataForCircle(circle) {
    const data = {};
    data.id = circle.vectorId;
    data.center = {};
    mathUtil.clonePoint(data.center, circle.center);
    data.radius = circle.radius;
    data.points = circle.points;
    data.color = circle.color;
    data.type = circle.geoType;
    return data;
  }

  getDataForText(text) {
    const data = {};
    data.id = text.vectorId;
    data.type = text.geoType;
    data.center = {};
    mathUtil.clonePoint(data.center, text.center);
    data.value = text.value;
    return data;
  }

  getDataForMagnifier(magnifier) {
    const data = {};
    data.id = magnifier.vectorId;
    data.type = magnifier.geoType;
    data.position = {};
    data.popPosition = {};
    mathUtil.clonePoint(data.position, magnifier.position);
    mathUtil.clonePoint(data.popPosition, magnifier.popPosition);
    data.photoUrl = magnifier.photoUrl;
    return data;
  }

  getDataForSVG(svg) {
    const data = {};
    data.id = svg.vectorId;
    data.type = svg.geoType;
    data.center = {};
    mathUtil.clonePoint(data.center, svg.center);
    data.name = svg.name;
    return data;
  }

  getDataForRoadPoint(roadPoint) {
    const data = {};
    data.id = roadPoint.vectorId;
    data.type = roadPoint.geoType;
    data.position = {};
    mathUtil.clonePoint(data.position, roadPoint);
    data.parent = JSON.parse(JSON.stringify(roadPoint.parent));
    return data;
  }

  getDataForRoadEdge(roadEdge) {
    const data = {};
    data.id = roadEdge.vectorId;
    data.type = roadEdge.geoType;
    data.parent = roadEdge.parent;
    data.start = {};
    data.start = JSON.parse(JSON.stringify(roadEdge.start));
    data.end = {};
    data.end = JSON.parse(JSON.stringify(roadEdge.end));
    return data;
  }

  getDataForRoad(road) {
    const data = {};
    data.id = road.vectorId;
    data.type = road.geoType;
    data.startId = road.startId;
    data.endId = road.endId;
    data.leftEdgeId = road.leftEdgeId;
    data.rightEdgeId = road.rightEdgeId;
    data.way = road.way;
    if (road.way == Constant.oneWay) {
      data.singleRoadWidth = road.singleRoadWidth;
      data.singleRoadDrivewayCount = road.singleRoadDrivewayCount;
      data.singleLanes = JSON.parse(JSON.stringify(road.singleLanes));
    } else if (road.way == Constant.twoWay) {
      data.leftWidth = road.leftWidth;
      data.rightWidth = road.rightWidth;
      data.leftDrivewayCount = road.leftDrivewayCount;
      data.rightDrivewayCount = road.rightDrivewayCount;
      data.midDivide = JSON.parse(JSON.stringify(road.midDivide));
      data.leftLanes = JSON.parse(JSON.stringify(road.leftLanes));
      data.rightLanes = JSON.parse(JSON.stringify(road.rightLanes));
    }
    return data;
  }

  getDataForCrossPoint(crossPoint) {
    const data = {};
    data.id = crossPoint.vectorId;
    data.type = crossPoint.geoType;
    data.position = {};
    mathUtil.clonePoint(data.position, crossPoint);
    data.extremePoint = {};
    mathUtil.clonePoint(data.extremePoint, crossPoint.extremePoint);

    data.edgeInfo1 = JSON.parse(JSON.stringify(crossPoint.edgeInfo1));
    data.edgeInfo2 = JSON.parse(JSON.stringify(crossPoint.edgeInfo2));
    data.curves = JSON.parse(JSON.stringify(crossPoint.curves));
    return data;
  }

  setPointInfo(pointInfo) {
    let point = dataService.getPoint(pointInfo.vectorId);
    mathUtil.clonePoint(point, pointInfo.position);
    point.parent = JSON.parse(JSON.stringify(pointInfo.parent));
    point.category = pointInfo.category;
    point.locationMode = pointInfo.locationMode;
    point.linkedBasePointId = pointInfo.linkedBasePointId;
    point.linkedTestPointId = pointInfo.linkedTestPointId;
    return point;
  }

  setLineInfo(lineInfo) {
    let line = dataService.getLine(lineInfo.vectorId);
    line.startId = lineInfo.start;
    line.endId = lineInfo.end;
    line.category = lineInfo.category;
    line.value = lineInfo.value;
    return line;
  }

  setCircleInfo(circleInfo) {
    let circle = dataService.getCircle(circleInfo.vectorId);
    circle.center = circleInfo.center;
    circle.radius = circleInfo.radius;
    circle.color = circleInfo.color;
    circle.points = circleInfo.points;
    return circle;
  }

  setTextInfo(textInfo) {
    let text = dataService.getText(textInfo.vectorId);
    text.vectorId = textInfo.vectorId;
    text.center = JSON.parse(JSON.stringify(textInfo.center));
    text.value = textInfo.value;
  }

  setMagnifierInfo(magnifierInfo) {
    let magnifier = dataService.getMagnifier(magnifierInfo.vectorId);
    magnifier.vectorId = magnifierInfo.vectorId;
    magnifier.position = JSON.parse(JSON.stringify(magnifierInfo.position));
    magnifier.popPosition = JSON.parse(
      JSON.stringify(magnifierInfo.popPosition)
    );
    magnifier.photoUrl = magnifierInfo.photoUrl;
  }

  setSVGInfo(svgInfo) {
    let svg = dataService.getSVG(svgInfo.vectorId);
    svg.vectorId = svgInfo.vectorId;
    svg.center = JSON.parse(JSON.stringify(svgInfo.center));
    svg.name = svgInfo.name;
  }

  setRoadPointInfo(roadPointInfo) {
    let roadPoint = dataService.getRoadPoint(roadPointInfo.vectorId);
    roadPoint.vectorId = roadPointInfo.vectorId;
    mathUtil.clonePoint(roadPoint, roadPointInfo.position);
    roadPoint.parent = JSON.parse(JSON.stringify(roadPointInfo.parent));
  }

  setRoadEdgeInfo(roadEdgeInfo) {
    let roadEdge = dataService.getRoadEdge(roadEdgeInfo.vectorId);
    roadEdge.vectorId = roadEdgeInfo.vectorId;
    mathUtil.clonePoint(roadEdge.start, roadEdgeInfo.start);
    mathUtil.clonePoint(roadEdge.end, roadEdgeInfo.end);
    roadEdge.name = roadEdgeInfo.name;
  }

  setRoadInfo(roadInfo) {
    let road = dataService.getRoad(roadInfo.vectorId);
    road.vectorId = roadInfo.vectorId;
    road.startId = roadInfo.startId;
    road.endId = roadInfo.endId;
    road.leftEdgeId = roadInfo.leftEdgeId;
    road.rightEdgeId = roadInfo.rightEdgeId;
    road.way = roadInfo.way;
    if (road.way == Constant.oneWay) {
      road.singleRoadWidth = roadInfo.singleRoadWidth;
      road.singleRoadDrivewayCount = roadInfo.singleRoadDrivewayCount;
      road.singleLanes = JSON.parse(JSON.stringify(roadInfo.singleLanes));
    } else if (road.way == Constant.twoWay) {
      road.leftWidth = roadInfo.leftWidth;
      road.rightWidth = roadInfo.rightWidth;
      road.leftDrivewayCount = roadInfo.leftDrivewayCount;
      road.rightDrivewayCount = roadInfo.rightDrivewayCount;
      road.midDivide = JSON.parse(JSON.stringify(roadInfo.midDivide));
      road.leftLanes = JSON.parse(JSON.stringify(roadInfo.leftLanes));
      road.rightLanes = JSON.parse(JSON.stringify(roadInfo.rightLanes));
    }
  }

  setCurveRoadPointInfo(curveRoadPointInfo) {
    let curveRoadPoint = dataService.getCurveRoadPoint(
      curveRoadPointInfo.vectorId
    );
    curveRoadPoint.vectorId = curveRoadPointInfo.vectorId;
    mathUtil.clonePoint(curveRoadPoint, curveRoadPointInfo.position);
    curveRoadPoint.parent = JSON.parse(
      JSON.stringify(curveRoadPointInfo.parent)
    );
    curveRoadPoint.index = curveRoadPointInfo.index;
  }

  setCurveRoadEdgeInfo(curveRoadEdgeInfo) {
    let curveRoadEdge = dataService.getCurveRoadEdge(
      curveRoadEdgeInfo.vectorId
    );
    curveRoadEdge.vectorId = curveRoadEdgeInfo.vectorId;
    mathUtil.clonePoint(curveRoadEdge.start, curveRoadEdgeInfo.start);
    mathUtil.clonePoint(curveRoadEdge.end, curveRoadEdgeInfo.end);
    mathUtil.clonePoints(curveRoadEdge.points, curveRoadEdgeInfo.points);
    curveRoadEdge.name = curveRoadEdgeInfo.name;
  }

  setCurveRoadInfo(curveRoadInfo) {
    let curveRoad = dataService.getCurveRoad(curveRoadInfo.vectorId);
    curveRoad.vectorId = curveRoadInfo.vectorId;
    curveRoad.startId = curveRoadInfo.startId;
    curveRoad.endId = curveRoadInfo.endId;
    curveRoad.leftEdgeId = curveRoadInfo.leftEdgeId;
    curveRoad.rightEdgeId = curveRoadInfo.rightEdgeId;
    for (let i = 0; i < curveRoadInfo.points.length; ++i) {
      curveRoad.points[i] = dataService.getCurveRoadPoint(
        curveRoadInfo.points[i]
      );
    }
    curveRoad.way = curveRoadInfo.way;
    if (curveRoad.way == Constant.oneWay) {
      curveRoad.singleRoadWidth = curveRoadInfo.singleRoadWidth;
      curveRoad.singleRoadDrivewayCount = curveRoadInfo.singleRoadDrivewayCount;
      curveRoad.singleLanes = JSON.parse(
        JSON.stringify(curveRoadInfo.singleLanes)
      );
    } else if (curveRoad.way == Constant.twoWay) {
      curveRoad.leftWidth = curveRoadInfo.leftWidth;
      curveRoad.rightWidth = curveRoadInfo.rightWidth;
      curveRoad.leftDrivewayCount = curveRoadInfo.leftDrivewayCount;
      curveRoad.rightDrivewayCount = curveRoadInfo.rightDrivewayCount;
      curveRoad.midDivide = JSON.parse(JSON.stringify(curveRoadInfo.midDivide));
      curveRoad.leftLanes = JSON.parse(JSON.stringify(curveRoadInfo.leftLanes));
      curveRoad.rightLanes = JSON.parse(
        JSON.stringify(curveRoadInfo.rightLanes)
      );
    }
  }

  setCrossPointInfo(crossPointInfo) {
    let crossPoint = dataService.getCrossPoint3(crossPointInfo.vectorId);
    crossPoint.vectorId = crossPointInfo.vectorId;
    mathUtil.clonePoint(crossPoint, crossPointInfo.position);
    crossPoint.extremePoint = {};
    mathUtil.clonePoint(crossPoint.extremePoint, crossPointInfo.extremePoint);
    crossPoint.edgeInfo1 = JSON.parse(JSON.stringify(crossPointInfo.edgeInfo1));
    crossPoint.edgeInfo2 = JSON.parse(JSON.stringify(crossPointInfo.edgeInfo2));
    crossPoint.curves = JSON.parse(JSON.stringify(crossPointInfo.curves));
  }
}

const historyUtil = new HistoryUtil();
export { historyUtil };