import {AttachCAD} from '../index'
import Column from '../architecture/column'
import Door from '../architecture/door/index'
import Casement from '../architecture/casement'
import Arch from '../architecture/linearch'
import FurnColumn from '../furniture/column'
import {FurnClass as Furn} from '../furniture/furn'
import WallLine from '../core/wallline'
import Point from '../core/point'

import {
  lineDis,
  lineCenter,
  getDisPointLinePoints,
  segmentsIntrFine,
  isContainPoint,
  Line,
  lineStretch
} from '../geometry'
import SlideDoor from '../architecture/slideDoor'

// 拦截arch门窗柱子墙线条添加方法， 添加额外属性
export default (cad: AttachCAD) => {

  let addCase = cad.processing.addCase
  let addDoor = cad.processing.addDoor
  let addColumn = cad.processing.addColumn
  let addLine = cad.processing.addLine
  let addSlideDoor = cad.processing.addSlideDoor
  let addFurnColumn = cad.processing.addFurnColumn
  let addFurnFlue = cad.processing.addFurnFlue

  // 添加与宽度相关的属性
  let addWidthAttr = (ele: Column | Door | Casement | SlideDoor ) => {
    Object.defineProperties(ele, {
      // 修改宽度
      ewidth: {
        get: () => Number(lineDis({points: ele.linePoints}).toFixed(2)),
        set: (val) => {
          if (val <= 0 || val === ele.ewidth) return;
          let center = lineCenter({points: ele.linePoints})
          let [p1, p2] = getDisPointLinePoints(ele.attachment, center, val / 2)

          if (lineDis({points: [ele.linePoints[0], p1]}) > lineDis({points: [ele.linePoints[0], p2]})) {
            ele.linePoints[0].x = p2.x
            ele.linePoints[0].y = p2.y
            ele.linePoints[1].x = p1.x
            ele.linePoints[1].y = p1.y
          } else {
            ele.linePoints[0].x = p1.x
            ele.linePoints[0].y = p1.y
            ele.linePoints[1].x = p2.x
            ele.linePoints[1].y = p2.y
          }
        }
      },
      // 最大宽度
      maxWidth: {
        get: () => {
          let archs = [...Arch.attaArch.get(ele.attachment), ele.attachment]
          let p1MinPoints: Array<{dis: number, point: Point}> = []
          let p2MinPoints: Array<{dis: number, point: Point}> = []
          let item = (arch: any, i, j) : {dis: number, point: Point} => {
            let points = arch.linePoints || arch.points
            return {
              dis: lineDis({points: [ele.linePoints[i], points[j]]}), 
              point: points[j]
            }
          }

          archs.forEach(arch => {
            if (arch !== ele) {
              p1MinPoints.push(item(arch, 0, 0))
              p1MinPoints.push(item(arch, 0, 1))
              p2MinPoints.push(item(arch, 1, 0))
              p2MinPoints.push(item(arch, 1, 1))
            }
          })

          p1MinPoints.sort((a, b) => a.dis - b.dis)
          p2MinPoints.sort((a, b) => a.dis - b.dis)
          
          let points = (p1MinPoints[0].dis > p2MinPoints[0].dis ?
            [ele.linePoints[1], p2MinPoints[0].point] :
            [ele.linePoints[0], p1MinPoints[0].point]) as [Point, Point];

          
          return Number((lineDis({points}) * 2 + lineDis({points: ele.linePoints})).toFixed(2))
        }
      },
      minWidth: {
        get: () => 0.2
      }
    })
  }

  // 为柱子添加厚度的属性
  let addTickAttr = (ele: Column) => {
    Object.defineProperties(ele, {
      tick: {
        get: () => Math.max(
          Number(lineDis({points: [ele.points[0], ele.points[3]]}).toFixed(2)),
          Number(lineDis({points: [ele.points[1], ele.points[2]]}).toFixed(2)),
        ),
        set: (val) => {
          if (val <= 0 || val === ele.oldVal) return;
          ele.oldVal = val
          ele.thickness = val
          ele.updatePeripheral()
        }
      },
      maxTick: {
        get() {
          let line1 = {points: [ele.points[0], ele.points[3]]} as {points: [Point, Point]}
          let line2 = {points: [ele.points[1], ele.points[2]]} as {points: [Point, Point]}
          let lines = cad.processing.lines.map(line => line.ele)
          let j1points = []
          let j2points = []

          for (let i = 0; i < lines.length; i++) {
            if (lines[i] === ele.attachment) continue;

            let point1 = segmentsIntrFine(lines[i], line1)
            let point2 = segmentsIntrFine(lines[i], line2)

            if (point1 && isContainPoint(lines[i], point1)) {
              j1points.push(point1)
            }
            if (point2 && isContainPoint(lines[i], point2)) {
              j2points.push(point2)
            }
          }

          j1points.sort((a, b) => lineDis({points: [ele.points[0], a]}) - lineDis({points: [ele.points[0], b]}))
          j2points.sort((a, b) => lineDis({points: [ele.points[1], a]}) - lineDis({points: [ele.points[1], b]}))

          let minp1len = 0;
          for(let i = 0; i < j1points.length; i++) {
            if ( isContainPoint({points: [ele.points[0], j1points[i]]}, ele.points[3]) ||
            isContainPoint({points: [ele.points[0], ele.points[3]]}, j1points[i]) ) {
              minp1len = lineDis({points: [ele.points[0], j1points[i]]})
              break;
            }
          }
          let minp2len = 0;
          for(let i = 0; i < j2points.length; i++) {
            if ( isContainPoint({points: [ele.points[1], j2points[i]]}, ele.points[2]) ||
            isContainPoint({points: [ele.points[1], ele.points[2]]}, j2points[i]) ) {
              minp2len = lineDis({points: [ele.points[1], j2points[i]]})
              break;
            }
          }

          let len = !minp1len ? minp2len : 
            !minp2len ? minp1len :
              minp1len < minp2len ? minp1len : minp2len


          return Number((len).toFixed(2)) || 10
        }
      },
      minTick: {
        get: () => 0.2
      }
    })
  }

  // 为门窗添加高度的属性
  let addHeightAttr = (ele: Column | Door | SlideDoor ) => {
    Object.defineProperties(ele, {
      eheight: {
        get: () => {
          return Number((ele.top - ele.bottom).toFixed(2))
        },
        set: (val) => {
          ele.in3D.changeHeight(val)
        }
      },
      maxHeight: {
        get: () => {
          let rooms = cad.processing.getRoomsByLine(ele.attachment)

          if (rooms.length) {
            return Number((rooms[0].top - rooms[0].bottom).toFixed(2))
          } else {
            return 5
          }
        }
      },
      minHeight: {
        get: () => 0.2
      }
    })
  }

  // 为线条添加修改高度的属性
  let addTopAttr = (ele: WallLine) => {
    Object.defineProperties(ele, {
      top: {
        get: () => {
          let hole = cad.processing.getHolesByLine(ele)[0]
          if (hole) {
            return hole.top
          } else {
            let room = cad.processing.getRoomsByLine(ele)[0]
            return room.top
          }
        },
        set: (val) => {
          val !== ele.top && ele.updateRoomTop(val)
        }
      },
      maxTop: {
        get: () => 10
      },
      minTop: {
        get: () => 0.5
      }
    })
  }

  // 最线条添加修改底边的属性
  let addBottomAttr = (ele: WallLine) => {
    Object.defineProperties(ele, {
      bottom: {
        get: () => {
          let room = cad.processing.getRoomsByLine(ele)[0]
          if (room) {
            return room.bottom
          } else {
            let hole = cad.processing.getHolesByLine(ele)[0]
            return hole.bottom
          }
        },
        set: (val) => {
          if (val !== ele.bottom) {
            let lines = cad.processing.lines.filter(({ele: cele}) => ~cele.points.indexOf(ele.points[0]) && ~cele.points.indexOf(ele.points[1]))
            // let rooms = lines.map(({room}) => room)
            console.error(lines)
            lines.forEach(({ele}) => ele.updateRoomBottom(val))
          }
        }
      },
      minBottom: {
        get: () =>  -2.5
      },
      maxBottom: {
        get: () => -0.5
      }
    })
  }

  let addFurnTopAttr = (ele: Furn) => {
    Object.defineProperties(ele, {
      top: {
        get: () => ele.top,
        set: (val) => {
          ele.top = val
        }
      },
      maxTop: {
        get: () => ele.room.top
      },
      minTop: {
        get: () => 0.5
      }
    })
  }

  let addFurnBottomAttr = (ele: Furn) => {
    Object.defineProperties(ele, {
      bottom: {
        get: () => ele.bottom,
        set: (val) => {
          ele.bottom = val
        }
      },
      maxTop: {
        get: () => ele.room.bottom
      },
      minTop: {
        get: () => -0.5
      }
    })
  }


  let addFurnWidthAttr = (ele: Furn) => {
    Object.defineProperties(ele, {
      // 修改宽度
      ewidth: {
        get: () => Number(lineDis({points: [ele.points[0], ele.point[1]]}).toFixed(2)),
        set: (val) => {
          if (val <= 0 || val === ele.ewidth) return;
          let newLine1 = lineStretch( { points: [ele.points[0], ele.points[1]] }, val )
          let newLine2 = lineStretch( { points: [ele.points[2], ele.points[3]] }, val )
          let points = newLine1.points.concat(newLine2.points)

          if (ele.check(points)) {
            ele.stop = false
            ele.points.forEach((point, i) => {
              point.x = points[i].x
              point.y = points[i].y
            })
            ele.nextTick(() => ele.stop = true)
          }
        }
      },
      // 最大宽度
      maxWidth: {
        get: () => {
          return 10
        }
      },
      minWidth: {
        get: () => 0.25
      }
    })
  }

  let addFurnTickAttr = (ele: Furn) => {
    Object.defineProperties(ele, {
      tick: {
        get: () => Number(lineDis({points: [ele.points[1], ele.point[2]]}).toFixed(2)),
        set: (val) => {
          if (val <= 0 || val === ele.tick) return;
          let newLine1 = lineStretch( { points: [ele.points[0], ele.points[3]] }, val )
          let newLine2 = lineStretch( { points: [ele.points[1], ele.points[2]] }, val )
          let points = [newLine1.points[0], newLine2.points[0], newLine2.points[1], newLine1.points[1]]

          if (ele.check(points)) {
            ele.stop = false
            ele.points.forEach((point, i) => {
              point.x = points[i].x
              point.y = points[i].y
            })
            ele.nextTick(() => ele.stop = true)
          }
        }
      },
      // 最大宽度
      maxTick: {
        get: () => {
          return 10
        }
      },
      minTick: {
        get: () => 0.25
      }
    })
  }

  
  cad.processing.addCase = function(...args) {
    let ret = addCase.call(this, ...args)
    addWidthAttr(ret.ele)
    addHeightAttr(ret.ele)
    return ret
  }

  cad.processing.addDoor = function(...args) {
    let ret = addDoor.call(this, ...args)
    addWidthAttr(ret.ele)
    addHeightAttr(ret.ele)
    return ret
  }
  
  cad.processing.addSlideDoor = function(...args) {
    let ret = addSlideDoor.call(this, ...args)
    addWidthAttr(ret.ele)
    addHeightAttr(ret.ele)
    return ret
  }

  cad.processing.addColumn = function(...args) {
    let ret = addColumn.call(this, ...args)
    addWidthAttr(ret.ele)
    addTickAttr(ret.ele)
    return ret
  }

  cad.processing.addLine = function(...args) {
    let ret = addLine.call(this, ...args)
    addTopAttr(ret.ele)
    addBottomAttr(ret.ele)
    return ret
  }

  
  cad.processing.addFurnColumn = function(...args) {
    let ret = addFurnColumn.call(this, ...args)
    addFurnTopAttr(ret.ele)
    addFurnBottomAttr(ret.ele)
    addFurnWidthAttr(ret.ele)
    addFurnTickAttr(ret.ele)
    return ret
  }

  cad.processing.addFurnFlue = function(...args) {
    let ret = addFurnFlue.call(this, ...args)
    addFurnTopAttr(ret.ele)
    addFurnBottomAttr(ret.ele)
    addFurnWidthAttr(ret.ele)
    addFurnTickAttr(ret.ele)
    return ret
  }

  
  let destroy = cad.destroy
  cad.destroy = function(...args) {
    addCase = null
    addDoor = null
    addColumn = null
    addLine = null
    addFurnFlue = null
    addFurnColumn = null
    destroy.apply(this, args)
  }
}