// 导入proj控件
import * as proj from 'ol/proj'

type TransformFunction = (input: number[], output: number[], offset: number) => void

function forEachPoint(func: TransformFunction) {
  return function (input: number[], opt_output?: number[], opt_dimension?: number): number[] {
    const len = input.length

    const dimension = opt_dimension || 2
    let output: number[]

    if (opt_output) {
      output = opt_output
    }
    else {
      if (dimension !== 2) {
        output = input.slice()
      }
      else {
        output = Array.from({ length: len })
      }
    }
    for (let offset = 0; offset < len; offset += dimension) {
      func(input, output, offset)
    }
    return output
  }
}

const gcj02: {
  toWGS84: (input: number[], opt_output?: number[], opt_dimension?: number) => number[]
  fromWGS84: (input: number[], opt_output?: number[], opt_dimension?: number) => number[]
} = {} as any

const PI = Math.PI
const AXIS = 6378245.0
// eslint-disable-next-line no-loss-of-precision
const OFFSET = 0.00669342162296594323 // (a^2 - b^2) / a^2

function delta(wgLon: number, wgLat: number): [number, number] {
  let dLat = transformLat(wgLon - 105.0, wgLat - 35.0)
  let dLon = transformLon(wgLon - 105.0, wgLat - 35.0)
  const radLat = (wgLat / 180.0) * PI
  let magic = Math.sin(radLat)
  magic = 1 - OFFSET * magic * magic
  const sqrtMagic = Math.sqrt(magic)
  dLat = (dLat * 180.0) / (((AXIS * (1 - OFFSET)) / (magic * sqrtMagic)) * PI)
  dLon = (dLon * 180.0) / ((AXIS / sqrtMagic) * Math.cos(radLat) * PI)
  return [dLon, dLat]
}

function outOfChina(lon: number, lat: number): boolean {
  if (lon < 72.004 || lon > 137.8347) {
    return true
  }
  return lat < 0.8293 || lat > 55.8271
}

function transformLat(x: number, y: number): number {
  let ret = -100.0 + 2.0 * x + 3.0 * y + 0.2 * y * y + 0.1 * x * y + 0.2 * Math.sqrt(Math.abs(x))
  ret += ((20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0) / 3.0
  ret += ((20.0 * Math.sin(y * PI) + 40.0 * Math.sin((y / 3.0) * PI)) * 2.0) / 3.0
  ret += ((160.0 * Math.sin((y / 12.0) * PI) + 320 * Math.sin((y * PI) / 30.0)) * 2.0) / 3.0
  return ret
}

function transformLon(x: number, y: number): number {
  let ret = 300.0 + x + 2.0 * y + 0.1 * x * x + 0.1 * x * y + 0.1 * Math.sqrt(Math.abs(x))
  ret += ((20.0 * Math.sin(6.0 * x * PI) + 20.0 * Math.sin(2.0 * x * PI)) * 2.0) / 3.0
  ret += ((20.0 * Math.sin(x * PI) + 40.0 * Math.sin((x / 3.0) * PI)) * 2.0) / 3.0
  ret += ((150.0 * Math.sin((x / 12.0) * PI) + 300.0 * Math.sin((x / 30.0) * PI)) * 2.0) / 3.0
  return ret
}

gcj02.toWGS84 = forEachPoint((input, output, offset) => {
  let lng = input[offset]
  let lat = input[offset + 1]
  if (!outOfChina(lng, lat)) {
    const deltaD = delta(lng, lat)
    lng = lng - deltaD[0] // 改回减法
    lat = lat - deltaD[1] // 改回减法
  }
  output[offset] = lng
  output[offset + 1] = lat
})

gcj02.fromWGS84 = forEachPoint((input, output, offset) => {
  let lng = input[offset]
  let lat = input[offset + 1]
  if (!outOfChina(lng, lat)) {
    const deltaD = delta(lng, lat)
    lng = lng + deltaD[0] // 改回加法
    lat = lat + deltaD[1] // 改回加法
  }
  output[offset] = lng
  output[offset + 1] = lat
})

const sphericalMercator: {
  forward: (input: number[], opt_output?: number[], opt_dimension?: number) => number[]
  inverse: (input: number[], opt_output?: number[], opt_dimension?: number) => number[]
} = {} as any

const RADIUS = 6378137
const MAX_LATITUDE = 85.0511287798
const RAD_PER_DEG = Math.PI / 180

sphericalMercator.forward = forEachPoint((input, output, offset) => {
  const lat = Math.max(Math.min(MAX_LATITUDE, input[offset + 1]), -MAX_LATITUDE)
  const sin = Math.sin(lat * RAD_PER_DEG)
  output[offset] = RADIUS * input[offset] * RAD_PER_DEG
  output[offset + 1] = (RADIUS * Math.log((1 + sin) / (1 - sin))) / 2
})

sphericalMercator.inverse = forEachPoint((input, output, offset) => {
  output[offset] = input[offset] / RADIUS / RAD_PER_DEG
  output[offset + 1] = (2 * Math.atan(Math.exp(input[offset + 1] / RADIUS)) - Math.PI / 2) / RAD_PER_DEG
})

const projzh: {
  ll2gmerc: (input: number[], opt_output?: number[], opt_dimension?: number) => number[]
  gmerc2ll: (input: number[], opt_output?: number[], opt_dimension?: number) => number[]
  smerc2gmerc: (input: number[], opt_output?: number[], opt_dimension?: number) => number[]
  gmerc2smerc: (input: number[], opt_output?: number[], opt_dimension?: number) => number[]
  ll2smerc: (input: number[], opt_output?: number[], opt_dimension?: number) => number[]
  smerc2ll: (input: number[], opt_output?: number[], opt_dimension?: number) => number[]
} = {} as any

projzh.ll2gmerc = function (input: number[], opt_output?: number[], opt_dimension?: number): number[] {
  const output = gcj02.toWGS84(input, opt_output, opt_dimension) // 改用 toWGS84
  return projzh.ll2smerc(output, output, opt_dimension)
}

projzh.gmerc2ll = function (input: number[], opt_output?: number[], opt_dimension?: number): number[] {
  const output = projzh.smerc2ll(input, input, opt_dimension)
  return gcj02.fromWGS84(output, opt_output, opt_dimension) // 改用 fromWGS84
}

// smerc2gmerc 需要修改

projzh.smerc2gmerc = function (input: number[], opt_output?: number[], opt_dimension?: number): number[] {
  let output = projzh.smerc2ll(input, input, opt_dimension)
  output = gcj02.toWGS84(output, output, opt_dimension) // 这里应该用 toWGS84
  return projzh.ll2smerc(output, output, opt_dimension)
}

// gmerc2smerc 需要修改

projzh.gmerc2smerc = function (input: number[], opt_output?: number[], opt_dimension?: number): number[] {
  let output = projzh.smerc2ll(input, input, opt_dimension)
  output = gcj02.fromWGS84(output, output, opt_dimension) // 这里应该用 fromWGS84
  return projzh.ll2smerc(output, output, opt_dimension)
}

projzh.ll2smerc = sphericalMercator.forward
projzh.smerc2ll = sphericalMercator.inverse

// 定义WGS84转GCJ02的投影
const extent: [number, number, number, number] = [-20037508.342789244, -20037508.342789244, 20037508.342789244, 20037508.342789244]
export const wgs84ToGcj02Projection = new proj.Projection({
  code: 'WGS84-TO-GCJ02',
  extent,
  units: 'm',
})

// 添加投影和转换方法
proj.addProjection(wgs84ToGcj02Projection)
// 注意这里转换方法的顺序与原来相反
proj.addCoordinateTransforms('EPSG:4326', wgs84ToGcj02Projection, projzh.ll2gmerc, projzh.gmerc2ll)
proj.addCoordinateTransforms('EPSG:3857', wgs84ToGcj02Projection, projzh.smerc2gmerc, projzh.gmerc2smerc)