import { GeometryUtils } from '../utils/geometry-utils.js'

const gu = new GeometryUtils()

export async function calcRouteSplit (viewer, positions, angle, space, relativeHeight, isActivateEdit) {
  const entity = viewer.entities.getById('flightLine')
  if (entity) viewer.entities.remove(entity)
  if (!Array.isArray(positions) || positions.length < 4 || !(space > 0)) return []

  const positionOffset = gu.computeOffsetPositions(positions, relativeHeight)

  const distance01 = Cesium.Cartesian3.distance(positionOffset[0], positionOffset[1])
  const distance12 = Cesium.Cartesian3.distance(positionOffset[1], positionOffset[2])
  const distance23 = Cesium.Cartesian3.distance(positionOffset[2], positionOffset[3])
  const distance30 = Cesium.Cartesian3.distance(positionOffset[3], positionOffset[0])

  const splitLinePosition = []

  if (angle === 0) {
    if (!isActivateEdit) {
      const split12 = gu.splitSegment(positionOffset[1], positionOffset[2], space, false)
      const newSplit03 = gu.splitSegment(positionOffset[3], positionOffset[0], space, true)
      for (let i = 0; i < split12.length; i++) {
        if (i % 2 === 0) { splitLinePosition.push(newSplit03[i], split12[i]) } else { splitLinePosition.push(split12[i], newSplit03[i]) }
      }
    } else {
      const adj = gu.adjustCornersByProjection(positionOffset, distance01)
      const newPointList = adj.newPointList
      const distanceNew12 = Cesium.Cartesian3.distance(positionOffset[1], positionOffset[2])
      const distanceNew23 = Cesium.Cartesian3.distance(positionOffset[2], positionOffset[3])
      const distanceNew30 = Cesium.Cartesian3.distance(positionOffset[3], positionOffset[0])

      const newSplit12 = gu.splitSegment(newPointList[1], newPointList[2], space, false)
      const newSplit03 = gu.splitSegment(newPointList[3], newPointList[0], space, true)

      const newSplitLinePosition03 = []
      const newSplitLinePosition12 = []
      const newSplitLinePosition23 = []

      for (let i = 0; i < newSplit12.length; i++) {
        const newLinePoint1 = [newSplit12[i].x, newSplit12[i].y, newSplit12[i].z]
        const newLinePoint2 = [newSplit03[i].x, newSplit03[i].y, newSplit03[i].z]

        const linePoint1 = [positionOffset[1].x, positionOffset[1].y, positionOffset[1].z]
        const linePoint2 = [positionOffset[2].x, positionOffset[2].y, positionOffset[2].z]
        const intersectPoint12 = math.intersect(newLinePoint1, newLinePoint2, linePoint1, linePoint2)
        if (intersectPoint12 && intersectPoint12.length > 0) {
          const cartesian3 = new Cesium.Cartesian3(intersectPoint12[0], intersectPoint12[1], intersectPoint12[2])
          const distanceLine12 = Cesium.Cartesian3.distance(cartesian3, positionOffset[1])
          if (distanceLine12 <= distanceNew12) newSplitLinePosition12.push(cartesian3)
        }

        const linePoint3 = [positionOffset[3].x, positionOffset[3].y, positionOffset[3].z]
        const linePoint0 = [positionOffset[0].x, positionOffset[0].y, positionOffset[0].z]
        const intersectPoint03 = math.intersect(newLinePoint1, newLinePoint2, linePoint3, linePoint0)
        if (intersectPoint03 && intersectPoint03.length > 0) {
          const cartesian3 = new Cesium.Cartesian3(intersectPoint03[0], intersectPoint03[1], intersectPoint03[2])
          const distanceLine30 = Cesium.Cartesian3.distance(cartesian3, positionOffset[0])
          if (distanceLine30 <= distanceNew30) newSplitLinePosition03.push(cartesian3)
        }

        const intersectPoint23 = math.intersect(newLinePoint1, newLinePoint2, linePoint3, linePoint2)
        if (intersectPoint23 && intersectPoint23.length > 0) {
          const cartesian3 = new Cesium.Cartesian3(intersectPoint23[0], intersectPoint23[1], intersectPoint23[2])
          const distanceLine23 = Cesium.Cartesian3.distance(cartesian3, adj.distanceP2 > adj.distanceP3 ? positionOffset[2] : positionOffset[3])
          if (distanceLine23 < distanceNew23) newSplitLinePosition23.push(cartesian3)
        }
      }

      if (adj.distanceP2 > adj.distanceP3) {
        const reNewSplitLinePosition0323 = [...newSplitLinePosition03, ...newSplitLinePosition23]
        for (let i = 0; i < newSplitLinePosition12.length; i++) {
          if (i % 2 === 0) splitLinePosition.push(reNewSplitLinePosition0323[i], newSplitLinePosition12[i])
          else splitLinePosition.push(newSplitLinePosition12[i], reNewSplitLinePosition0323[i])
        }
      } else {
        const reNewSplitLinePosition1223 = [...newSplitLinePosition12, ...newSplitLinePosition23]
        for (let i = 0; i < newSplitLinePosition03.length; i++) {
          if (i % 2 === 0) splitLinePosition.push(newSplitLinePosition03[i], reNewSplitLinePosition1223[i])
          else splitLinePosition.push(reNewSplitLinePosition1223[i], newSplitLinePosition03[i])
        }
      }
    }
  } else {
    if (distance12 === distance30) {
      const split01 = gu.splitSegment(positionOffset[0], positionOffset[1], space, false)
      const newSplit23 = gu.splitSegment(positionOffset[2], positionOffset[3], space, true)
      for (let i = 0; i < split01.length; i++) {
        if (i % 2 === 0) splitLinePosition.push(split01[i], newSplit23[i])
        else splitLinePosition.push(newSplit23[i], split01[i])
      }
    } else {
      const adj = gu.adjustCornersByProjection(positionOffset, distance01)
      const newPointList = adj.newPointList
      const distanceNew12 = Cesium.Cartesian3.distance(positionOffset[1], positionOffset[2])
      const distanceNew23 = Cesium.Cartesian3.distance(positionOffset[2], positionOffset[3])
      const distanceNew30 = Cesium.Cartesian3.distance(positionOffset[3], positionOffset[0])
      const distanceNew01 = Cesium.Cartesian3.distance(positionOffset[1], positionOffset[0])

      const newSplit01 = gu.splitSegment(newPointList[0], newPointList[1], space, false)
      const newSplit32 = gu.splitSegment(newPointList[3], newPointList[2], space, false)

      const newSplitLinePosition01 = []
      const newSplitLinePosition12 = []
      const newSplitLinePosition23 = []
      const newSplitLinePosition03 = []

      for (let i = 0; i < newSplit01.length; i++) {
        const newLinePoint1 = [newSplit01[i].x, newSplit01[i].y, newSplit01[i].z]
        const newLinePoint2 = [newSplit32[i].x, newSplit32[i].y, newSplit32[i].z]

        const linePoint1 = [positionOffset[1].x, positionOffset[1].y, positionOffset[1].z]
        const linePoint2 = [positionOffset[2].x, positionOffset[2].y, positionOffset[2].z]
        const intersectPoint12 = math.intersect(newLinePoint1, newLinePoint2, linePoint1, linePoint2)
        if (intersectPoint12 && intersectPoint12.length > 0) {
          const cartesian3 = new Cesium.Cartesian3(intersectPoint12[0], intersectPoint12[1], intersectPoint12[2])
          const distanceLine12 = Cesium.Cartesian3.distance(cartesian3, positionOffset[1])
          const Cartographic1 = viewer.scene.globe.ellipsoid.cartesianToCartographic(cartesian3)
          const Cartographic2 = viewer.scene.globe.ellipsoid.cartesianToCartographic(positionOffset[1])
          if (distanceLine12 <= distanceNew12 && Cartographic1.height >= Cartographic2.height) newSplitLinePosition12.push(cartesian3)
        }

        const linePoint3 = [positionOffset[3].x, positionOffset[3].y, positionOffset[3].z]
        const linePoint0 = [positionOffset[0].x, positionOffset[0].y, positionOffset[0].z]
        const intersectPoint03 = math.intersect(newLinePoint1, newLinePoint2, linePoint3, linePoint0)
        if (intersectPoint03 && intersectPoint03.length > 0) {
          const cartesian3 = new Cesium.Cartesian3(intersectPoint03[0], intersectPoint03[1], intersectPoint03[2])
          const distanceLine30 = Cesium.Cartesian3.distance(cartesian3, positionOffset[0])
          const Cartographic1 = viewer.scene.globe.ellipsoid.cartesianToCartographic(cartesian3)
          const Cartographic2 = viewer.scene.globe.ellipsoid.cartesianToCartographic(positionOffset[0])
          if (distanceLine30 <= distanceNew30 && Cartographic1.height >= Cartographic2.height) newSplitLinePosition03.push(cartesian3)
        }

        const intersectPoint23 = math.intersect(newLinePoint1, newLinePoint2, linePoint3, linePoint2)
        if (intersectPoint23 && intersectPoint23.length > 0) {
          const cartesian3 = new Cesium.Cartesian3(intersectPoint23[0], intersectPoint23[1], intersectPoint23[2])
          const distanceLine03 = Cesium.Cartesian3.distance(cartesian3, positionOffset[2])
          const distanceLine04 = Cesium.Cartesian3.distance(cartesian3, positionOffset[3])
          const distanceLine233 = Cesium.Cartesian3.distance(positionOffset[2], positionOffset[3])
          const distance = distanceLine04 > distanceLine03 ? distanceLine04 : distanceLine03
          if (distance < distanceLine233) newSplitLinePosition23.push(cartesian3)
        }

        const intersectPoint01 = math.intersect(newLinePoint1, newLinePoint2, linePoint0, linePoint1)
        if (intersectPoint01 && intersectPoint01.length > 0) {
          const cartesian3 = new Cesium.Cartesian3(intersectPoint01[0], intersectPoint01[1], intersectPoint01[2])
          const distanceLine01 = Cesium.Cartesian3.distance(cartesian3, positionOffset[0])
          const distanceLine02 = Cesium.Cartesian3.distance(cartesian3, positionOffset[1])
          const distanceLine012 = Cesium.Cartesian3.distance(positionOffset[0], positionOffset[1])
          const distance = distanceLine02 > distanceLine01 ? distanceLine02 : distanceLine01
          if (distance < distanceLine012) newSplitLinePosition01.push(cartesian3)
        }
      }

      if (adj.distanceP2 > adj.distanceP3) {
        let arr, brr, startPoint, endPoint
        if (adj.distanceP20 + adj.distanceP21 > distance01) {
          if (adj.distanceP30 + adj.distanceP31 > distance01) {
            arr = [...newSplitLinePosition23].reverse()
            brr = [...newSplitLinePosition12].reverse().concat([...newSplitLinePosition01].reverse(), [...newSplitLinePosition03].reverse())
            startPoint = brr.shift(); endPoint = arr.pop()
          } else {
            arr = [...newSplitLinePosition23].reverse().concat([...newSplitLinePosition03].reverse())
            brr = [...newSplitLinePosition12].reverse().concat([...newSplitLinePosition01].reverse())
            startPoint = brr.shift(); endPoint = arr.pop()
          }
        } else {
          if (adj.distanceP30 + adj.distanceP31 > distance01) {
            arr = [...newSplitLinePosition12].reverse().concat([...newSplitLinePosition23].reverse())
            brr = [...newSplitLinePosition01].reverse().concat([...newSplitLinePosition03].reverse())
            startPoint = arr.shift(); endPoint = brr.pop()
          } else {
            arr = [...newSplitLinePosition01].reverse()
            brr = [...newSplitLinePosition12].reverse().concat([...newSplitLinePosition23].reverse(), [...newSplitLinePosition03].reverse())
            startPoint = brr.shift(); endPoint = arr.pop()
          }
        }
        splitLinePosition.push(startPoint)
        gu.handleSplitLinePosition(arr, brr, splitLinePosition)
        splitLinePosition.push(endPoint)
      } else {
        let arr, brr
        if (adj.distanceP20 + adj.distanceP21 > distance01) {
          if (adj.distanceP30 + adj.distanceP31 > distance01) {
            arr = [...newSplitLinePosition23].reverse()
            brr = [...newSplitLinePosition12].reverse().concat([...newSplitLinePosition01].reverse(), [...newSplitLinePosition03].reverse())
          } else {
            arr = [...newSplitLinePosition23].reverse().concat([...newSplitLinePosition03].reverse())
            brr = [...newSplitLinePosition12].reverse().concat([...newSplitLinePosition01].reverse())
          }
        } else {
          if (adj.distanceP30 + adj.distanceP31 > distance01) {
            arr = [...newSplitLinePosition12].reverse().concat([...newSplitLinePosition23].reverse())
            brr = [...newSplitLinePosition01].reverse().concat([...newSplitLinePosition03].reverse())
          } else {
            arr = [...newSplitLinePosition01].reverse()
            brr = [...newSplitLinePosition12].reverse().concat([...newSplitLinePosition23].reverse(), [...newSplitLinePosition03].reverse())
          }
        }
        gu.handleSplitLinePosition(arr, brr, splitLinePosition)
      }
    }
  }

  return splitLinePosition
}