import Point from '../../core/point'
import WallLine from '../../core/wallline'
import {LineArchClass as LineArch} from '../../architecture/linearch'
import { _Point, _Line, _window, _door, _column, Data, That, _tagging, _groundCase, _bayCase, _furnColumn, _furnFlue, _slideDoor, _doubledoor } from './index'
import Door from '../../architecture/door/index'
import Casement from '../../architecture/casement'
import Column from '../../architecture/column'
import Tagging from '../../label/tagging'
import GroundCase from '../../architecture/groundCase'
import BayCase from '../../architecture/bayCase'
import DoubleDoor from '../../architecture/doubleDoor'
import FurnColumn from '../../furniture/column'
import FurnFlue from '../../furniture/flue'
import { FurnClass as Furn } from '../../furniture/furn'
import SlideDoor from '../../architecture/slideDoor'

export interface dataApi {
  getNewPointId: () => number
  getNewLineId: () => number
  getLineId: (line: WallLine) => number
  getPointId: (point: Point) => number
  baseArchToData: (ele: LineArch) => _door
  roomArchToData: (ele: Furn) => _furnColumn
  pointToData: (ele: {ele: Point, id: number}) => _Point
  lineToData: (ele: {ele: WallLine, id: number}) => _Line
  doorToData: (ele: {ele: Door}) => _door
  DoubleDoorToData: (ele: {ele: DoubleDoor}) => _doubledoor
  slideDoorToData: (ele: {ele: Door}) => _slideDoor
  caseToData: (ele: {ele: Casement}) => _window
  groundCaseToData: (ele: {ele: GroundCase}) => _groundCase
  BayCaseToData: (ele: {ele: BayCase}) => _bayCase
  columnToData: (ele: {ele: Column}) => _column
  taggingToData: ({ele}: {ele: Tagging}) => _tagging,
  furnColumnToData: (ele: {ele: FurnColumn}) => _furnColumn,
  furnFlueToData: (ele: {ele: FurnFlue}) => _furnFlue
  toData: () => Data
}

const numRetain = (n: number, m = 2) => Number(n.toFixed(m))

export const methods: That = {
  baseArchToData(ele: LineArch) {
    return {
      line: this.getLineId(ele.attachment),
      pos: [
        numRetain(ele.linePoints[0].x), numRetain(ele.linePoints[0].y), 
        numRetain(ele.linePoints[1].x), numRetain(ele.linePoints[1].y) 
      ],
      top: ele.top,
      bottom: ele.bottom
    }
  },
  roomArchToData(ele: FurnColumn) {
    return {
      pos: [
        numRetain(ele.points[0].x), numRetain(ele.points[0].y), 
        numRetain(ele.points[1].x), numRetain(ele.points[1].y),
        numRetain(ele.points[2].x), numRetain(ele.points[2].y), 
        numRetain(ele.points[3].x), numRetain(ele.points[3].y) 
      ],
      top: ele.top,
      bottom: ele.bottom,
      angle: ele.angle
    }
  },
  pointToData({ele, id}) {
    return {
      id,
      x: numRetain(ele.x), y: numRetain(ele.y)
    }
  },
  lineToData({ele, id, border}) {
    return {
      id,
      p1: this.getPointId(ele.points[0]),
      p2: this.getPointId(ele.points[1]),
      border,
      exterior: ele.exterior
    }
  },
  doorToData ({ele}: {ele: Door}) {
    let data = this.baseArchToData(ele)
    data.within = ele.within
    data.show = ele.show
    data.ctl = [ele.ctl[0].x, -ele.ctl[0].y]
    data.start = ele.start
    return data
  },
  DoubleDoorToData ({ele}: {ele: Door}) {
    let data = this.baseArchToData(ele)
    data.within = ele.within
    data.show = ele.show
    return data
  },
  slideDoorToData ({ele}: {ele: SlideDoor}) {
    let data = this.baseArchToData(ele)
    data.within = ele.within
    data.show = ele.show
    return data
  },
  caseToData ({ele}: {ele: Casement}) {
    return this.baseArchToData(ele)
  },
  groundCaseToData ({ele}: {ele: GroundCase}) {
    return this.baseArchToData(ele)
  },
  BayCaseToData ({ele}: {ele: BayCase}) {
    let data = this.baseArchToData(ele)
    data.within = ele.within
    data.ctl = [ele.ctl[0].x, -ele.ctl[0].y, ele.ctl[1].x, -ele.ctl[1].y]
    return data
  },
  columnToData ({ele}: {ele:Column}) {
    let data = this.baseArchToData(ele)
    return {
      ...data,
      pos: [
        ...data.pos,
        numRetain(ele.points[3].x), numRetain(ele.points[3].y),
        numRetain(ele.points[2].x), numRetain(ele.points[2].y)
      ]
    }
  },
  taggingToData ({ele}: {ele: Tagging}) {
    return {
      pos: [ele.x, ele.y],
      title: ele.title,
      content: ele.content,
      showTitle: ele.showTitle,
      showContent: ele.showContent
    }
  },
  furnColumnToData ({ele}: {ele: FurnColumn}) {
    return this.roomArchToData(ele)
  },
  furnFlueToData ({ele}: {ele: FurnFlue}) {
    return this.roomArchToData(ele)
  },
  
  getNewPointId() {
    if (this.points.length === 0) {
      return 1
    } else {
      return Math.max(...this.points.map(({id}) => id)) + 1
    }
  },
  getNewLineId() {
    if (this.lines.length === 0) {
      return 1
    } else {
      return Math.max(...this.lines.map(({id}) => id)) + 1
    }
  },
  getLineId (line: WallLine) {
    let l = this.lines.find(({ele}) => ele === line)
    return l ? l.id : 0
  },
  getPointId (point: Point) {
    return this.points.find(({ele}) => ele === point).id
  },
  // 将ele转换为data
  toData (): Data {
    let vertex = this.points.map(a => this.pointToData(a))

    let column = this.columns.map(a => this.columnToData(a))
    let window = this.cases.map(a => this.caseToData(a))
    let door = this.doors.map(a => this.doorToData(a))
    let slideDoor = this.slideDoors.map(a => this.slideDoorToData(a))
    let groundCase = this.groundCases.map(a => this.groundCaseToData(a))
    let tagging = this.taggings.map(a => this.taggingToData(a))
    let bayCase = this.bayCases.map(a => this.BayCaseToData(a))
    let doubleDoor = this.doubleDoors.map(a => this.DoubleDoorToData(a))



    let furnColumn = this.furnColumns.map(a => this.furnColumnToData(a))
    let furnFlue = this.furnFlues.map(a => this.furnFlueToData(a))
    let wall = []
    this.lines.forEach(a => {
      try {
        wall.push(this.lineToData(a))
      } catch {
      }
    })


    return {
      id: this.id,
      show: this.show,
      vertex, wall, 
      window, door, column, 
      surplus: this.data.surplus, 
      slideDoor, groundCase, tagging, doubleDoor, 
      bayCase, furnColumn, furnFlue,
      dire: this.data.dire
    }
  }
}