    import proj4 from 'proj4'
    import epsg from './EPSG'
    import { defaultValue } from '../util'
    import Zondy from './Zondy'
    import {
      Circle,
      Extent,
      LineString,
      MultiLineString,
      MultiPoint,
      MultiPolygon,
      Point,
      Polygon,
      SpatialReference
    } from './geometry'
    import GeometryType from './enum/GeometryType'

    /**
     * 投影转换工具
     * @class Projection
     * */
    class Projection {}

    /**
     * 将墨卡托的点转为经纬度
     * @private
     * @param {Object} mercator 墨卡托点坐标，{x: 0, y: 0}
     * @return {Object} 经纬度坐标， { longitude: 0, latitude: 0 }
     * */
    Projection.projectMercatorToLonLat = function (mercator) {
      const lonlat = { longitude: 0, latitude: 0 }

      const x = (mercator.x / 20037508.34) * 180
      let y = (mercator.y / 20037508.34) * 180

      y =
        (180 / Math.PI) *
        (2 * Math.atan(Math.exp((y * Math.PI) / 180)) - Math.PI / 2)

      lonlat.longitude = x
      lonlat.latitude = y

      return lonlat
    }

    /**
     * 将任意坐标系的点坐标转为经纬度(EPSG:4326)坐标
     * @private
     * @param {Object} options 投影参数
     * @param {Array} [options.points = []] 要投影的点数组。[[x, y], [x, y],...]
     * @param {String | Number} [options.wkid] wkid号
     * @param {String} [options.proj4Defs] 可选参数，EPSG的椭球体参数，本工具内置了部分EPSG号，如果有EPSG号未收录，请在EPSG官网：https://epsg.io，查找并通过该参数传入
     * @return {Array} 投影后的点坐标数组
     * @example <caption><h7>将4547坐标系的点转为4326坐标系的点</h7></caption>
     * const points = Projection.projectToGeographyPoints({
     *   points: [[-45257.10778559791, 3212885.1836444484]],
     *   wkid: 4547
     * })
     * @example <caption><h7>将未收录的坐标系的点转为4326坐标系的点</h7></caption>
     * const points = Projection.projectToGeographyPoints({
     *   points: [[-45257.10778559791, 3212885.1836444484]],
     *   // 定义了椭球体参数，请在WPSG官网查询
     *   proj4Defs: '+proj=tmerc +lat_0=0 +lon_0=114 +k=1 +x_0=500000 +y_0=0 +ellps=GRS80 +units=m +no_defs'
     * })
     * */
    Projection.projectToGeographyPoints = function (options) {
      options = defaultValue(options, {})
      // 要投影的点数组
      const points = defaultValue(options.points, [])
      // 目的坐标系的wkid
      const wkid = defaultValue(options.wkid, -1)
      // 目的坐标系的椭球体参数
      const proj4Defs = defaultValue(options.proj4Defs, undefined)
      // 投影后的点数组
      const projPoints = []

      let defs = undefined
      if (proj4Defs) {
        defs = proj4Defs
      } else {
        const epsgObj = Projection.getEPSGByWKID(wkid)
        if (epsgObj) {
          defs = epsgObj.strProject
        }
      }

      if (defs) {
        for (let i = 0; i < points.length; i++) {
          projPoints.push(
            proj4(defs, '+proj=longlat +datum=WGS84 +no_defs +type=crs', points[i])
          )
        }
      }

      return projPoints
    }

    /**
     * 将点数组从一个坐标系投影到另一个坐标系
     * @private
     * @param {Object} options 投影参数
     * @param {String | Number} [options.originWKID] 点数组所在的原始坐标系的wkid
     * @param {String | Number} [options.targetWKID] 目的坐标系的wkid
     * @param {Array} [options.points = []] 要投影的点数组
     * @param {String} [options.originDefs] 可选参数，若一个坐标系未收录，则请在EPSG官网：https://epsg.io查询原始坐标系的Defs
     * @param {String} [options.targetDefs] 可选参数，若一个坐标系未收录，则请在EPSG官网：https://epsg.io查询目的坐标系的Defs
     * @example <caption><h7>将3857坐标系的点转为4326坐标系的点</h7></caption>
     * const points = Projection.projectPoints({
     *   originWKID: 3857,
     *   targetWKID: 4326,
     *   points: [[12062959.621822732, 3379793.1381245172]]
     * })
     * @example <caption><h7>将未收录的坐标系的点转为4326坐标系的点</h7></caption>
     * const points = Projection.projectPoints({
     *   // 定义了椭球体参数，请在WPSG官网查询
     *   originDefs: '+proj=tmerc +lat_0=0 +lon_0=114 +k=1 +x_0=500000 +y_0=0 +ellps=GRS80 +units=m +no_defs',
     *   targetWKID: 4326,
     *   points: [[-45257.10778559791, 3212885.1836444484]]
     * })
     * */
    Projection.projectPoints = function (options) {
      options = defaultValue(options, {})
      // 要投影的点数组
      const points = defaultValue(options.points, [])
      // 原始坐标系的wkid
      const originWKID = defaultValue(options.originWKID, -1)
      // 原始坐标系的椭球体参数
      const originDefs = defaultValue(options.originDefs, undefined)
      // 目的坐标系的wkid
      const targetWKID = defaultValue(options.targetWKID, -1)
      // 目的坐标系的椭球体参数
      const targetDefs = defaultValue(options.targetDefs, undefined)
      // 要获取的原始坐标系椭球体参数
      let _originDefs = undefined
      // 要获取的目的坐标系椭球体参数
      let _targetDefs = undefined
      // 投影后的点数组
      const projPoints = []

      if (originDefs) {
        _originDefs = originDefs
      } else {
        const epsgObj = Projection.getEPSGByWKID(originWKID)
        if (epsgObj) {
          _originDefs = epsgObj.strProject
        }
      }

      if (targetDefs) {
        _targetDefs = targetDefs
      } else {
        const epsgObj = Projection.getEPSGByWKID(targetWKID)
        if (epsgObj) {
          _targetDefs = epsgObj.strProject
        }
      }

      if (_originDefs && _targetDefs) {
        for (let i = 0; i < points.length; i++) {
          projPoints.push(proj4(_originDefs, _targetDefs, points[i]))
        }
      }

      return projPoints
    }

    /**
     * 根据wkid获取epsg对象
     * @private
     * @param {Number | String} wkid wkid号
     * @return {Object} EPSG参数对象
     * */
    Projection.getEPSGByWKID = function (wkid) {
      let _epsg = undefined
      for (let i = 0; i < epsg.length; i++) {
        if (String(epsg[i].id) === String(wkid)) {
          _epsg = epsg[i]
          break
        }
      }
      return _epsg
    }

    /**
     * 将几何对象投影到指定坐标系中
     * @private
     * @param {Geometry | Array<geometry>} geometry 要投影的几何或几何数组
     * @param {SpatialReference} outSpatialReference 目标参考系
     * @param {String} geographicTransformation 可选参数，若一个坐标系未收录，则请在EPSG官网：https://epsg.io查询目标参考系椭球体参数
     * @return {Geometry | Array<Geometry>} 投影后的几何对象
     * */
    Projection.projectGeometry = function (
      geometry,
      outSpatialReference,
      geographicTransformation
    ) {
      let coordinates = []
      const projectOptions = {
        originWKID: geometry.spatialReference.wkid,
        originDefs: geometry.spatialReference.geographicTransformation,
        targetWKID: outSpatialReference.wkid,
        targetDefs: geographicTransformation
      }
      switch (geometry.type) {
        case GeometryType.point:
          coordinates = [geometry.coordinates]
          projectOptions.points = coordinates
          coordinates = Projection.projectPoints(projectOptions)
          return new Point({
            coordinates: coordinates[0],
            spatialReference: new SpatialReference(outSpatialReference)
          })
        case GeometryType.multiPoint:
          coordinates = geometry.coordinates
          projectOptions.points = coordinates
          coordinates = Projection.projectPoints(projectOptions)
          return new MultiPoint({
            coordinates,
            spatialReference: new SpatialReference(outSpatialReference)
          })
        case GeometryType.lineString:
          coordinates = geometry.coordinates
          projectOptions.points = coordinates
          coordinates = Projection.projectPoints(projectOptions)
          return new LineString({
            coordinates,
            spatialReference: new SpatialReference(outSpatialReference)
          })
        case GeometryType.multiLineString:
          coordinates = geometry.coordinates
          const multiLines = []
          for (let i = 0; i < coordinates.length; i++) {
            projectOptions.points = coordinates[i]
            multiLines.push(Projection.projectPoints(projectOptions))
          }
          return new MultiLineString({
            coordinates: multiLines,
            spatialReference: new SpatialReference(outSpatialReference)
          })
        case GeometryType.polygon:
          coordinates = geometry.coordinates
          const polygonRings = []
          for (let i = 0; i < coordinates.length; i++) {
            projectOptions.points = coordinates[i]
            polygonRings.push(Projection.projectPoints(projectOptions))
          }
          return new Polygon({
            coordinates: polygonRings,
            spatialReference: new SpatialReference(outSpatialReference)
          })
        case GeometryType.multiPolygon:
          coordinates = geometry.coordinates
          const multiPolygons = []
          for (let i = 0; i < coordinates.length; i++) {
            const polygonRings = []
            for (let j = 0; j < coordinates[i].length; j++) {
              projectOptions.points = coordinates[i][j]
              polygonRings.push(Projection.projectPoints(projectOptions))
            }
            multiPolygons.push(polygonRings)
          }
          return new MultiPolygon({
            coordinates: multiPolygons,
            spatialReference: new SpatialReference(outSpatialReference)
          })
        case GeometryType.circle:
          coordinates = [
            [geometry.center[0], geometry.center[1], geometry.center[2]],
            [
              geometry.center[0] + geometry.radius,
              geometry.center[1] + geometry.radius,
              geometry.center[2]
            ]
          ]
          projectOptions.points = coordinates
          coordinates = Projection.projectPoints(projectOptions)
          const radius = coordinates[1][0] - coordinates[0][0]
          return new Circle({
            center: coordinates[0],
            radius
          })
        case GeometryType.extent:
          coordinates = [
            [geometry.xmin, geometry.ymin, geometry.zmin],
            [geometry.xmax, geometry.ymax, geometry.zmax]
          ]
          projectOptions.points = coordinates
          coordinates = Projection.projectPoints(projectOptions)
          return new Extent({
            xmin: coordinates[0][0],
            ymin: coordinates[0][1],
            zmin: coordinates[0][2],
            xmax: coordinates[1][0],
            ymax: coordinates[1][1],
            zmax: coordinates[1][2],
            spatialReference: new SpatialReference(outSpatialReference)
          })
        default:
          return geometry
      }
    }

    /**
     * 将几何对象投影到指定坐标系中
     * @param {Geometry | Array<geometry>} geometry 要投影的几何或几何数组
     * @param {SpatialReference} outSpatialReference 目标参考系
     * @param {String} geographicTransformation 可选参数，若一个坐标系未收录，则请在EPSG官网：https://epsg.io查询目标参考系椭球体参数
     * @return {Geometry | Array<Geometry>} 投影后的几何对象
     * @example <caption><h7>将3857坐标系的点转为4326坐标系的点</h7></caption>
     * const projectedGeometry = Zondy.Tool.Projection.project(
     *   new Zondy.Geometry.Extent({
     *     xmin: 12062959.621822732,
     *     ymin: 3379793.138124517,
     *     xmax: 12927637.10614421,
     *     ymax: 3931626.287996913,
     *     spatialReference: new Zondy.SpatialReference({
     *       wkid: 3857
     *     })
     *   }),
     *   new Zondy.SpatialReference({
     *     wkid: 4326
     *   })
     * )
     * @example <caption><h7>将未收录的坐标系的点转为4326坐标系的点</h7></caption>
     * const projectedGeometry = Zondy.Tool.Projection.project(
     *   new Zondy.Geometry.Extent({
     *     xmin: -45257.10778559791,
     *     ymin: 3212885.1836444484,
     *     xmax: 705989.8953363781,
     *     ymax: 3691623.86404564,
     *     spatialReference: new Zondy.SpatialReference({
     *       wkid: 4547,
     *       geographicTransformation: '+proj=tmerc +lat_0=0 +lon_0=114 +k=1 +x_0=500000 +y_0=0 +ellps=GRS80 +units=m +no_defs'
     *     })
     *   }),
     *   new Zondy.SpatialReference({
     *     wkid: 4326
     *   })
     * )
     * */
    Projection.project = function (
      geometry,
      outSpatialReference,
      geographicTransformation
    ) {
      if (geometry instanceof Array) {
        const projectGeometries = []
        for (let i = 0; i < geometry.length; i++) {
          projectGeometries.push(
            Projection.projectGeometry(
              geometry[i],
              outSpatialReference,
              geographicTransformation
            )
          )
        }
        return projectGeometries
      } else {
        // 4326坐标系下，获取有效范围内经度。proj纬度最大为 89.99999999
        if (geometry.spatialReference.isWGS84) {
          const _validLat = (lat) => {
            const projLimit = 89.99999999
            if (lat > projLimit) {
              lat = projLimit
            } else if (lat < -projLimit) {
              lat = -projLimit
            }
            return lat
          }
          if (geometry.coordinates && geometry.coordinates.length > 1) {
            geometry.coordinates[1] = _validLat(geometry.coordinates[1])
          }
          geometry.ymax = _validLat(geometry.ymax)
          geometry.ymin = _validLat(geometry.ymin)
        }
        return Projection.projectGeometry(
          geometry,
          outSpatialReference,
          geographicTransformation
        )
      }
    }

    Zondy.Tool.Projection = Projection
    Zondy.Tool.Proj4 = proj4
    export default Projection