import { Event } from './Event';
import { AMap, LngLat } from './AMap';
import { Layer, Overlay, VectorOverlay } from './other';
export class Map extends Event<MapEvent> {
  constructor(div: string | HTMLDivElement, opts: MapOptions)

  resize(): void

  setCenter(center: number[] | string[] | AMap.LngLat, immediately = false, duration?: number): void

  setZoomAndCenter(zoom: number, center: number[] | AMap.LngLat, immediately = false, duration?: number): void

  getBounds(): AMap.Bounds

  getCenter(): AMap.LngLat

  setZoom(zoom: number, immediately = false, duration?: number): void

  getZoom(digits: number): number

  zoomIn(): void

  zoomOut(): void

  getPitch(): number

  setPitch(pitch: number, immediately = false, duration?: number): void

  getRotation(): number

  setRotation(rotation: number, immediately = false, duration?: number): void

  setBounds(bounds: number[] | AMap.Bounds, immediately = false, duration?: number): void

  panTo(lnglat: number[] | AMap.LngLat, duration?: number): void

  panBy(x: number, y: number, duration?: number): void

  getContainer(): HTMLDivElement

  getSize(): AMap.Size

  addLayer(layer: Layer): void

  removeLayer(layer): void

  add(features: VectorOverlay | any[])

  setLayers(layers: Layer[])

  getLayers(): Layer[]

  remove(features: Overlay | AMap.LngLat | Array<Overlay | AMap.LngLat>)

  getStatus(): MapStatus

  lngLatToCoords(lnglat: number[] | LngLat): any

  setStatus(status: MapStatus): void

  coordsToLnglat(coords: number[]): any

  lngLatToContainer(lnglat: number[] | AMap.LngLat): AMap.Pixel

  getAltitude(lnglat: number[] | AMap.LngLat): number

  containerToLngLat(pixel: number[] | AMap.Pixel): AMap.LngLat

  getDefaultCursor(): string

  setDefaultCursor(cursor: string): void

  coordToContainer(coord: number[]): number[]

  containerToCoord(pixel: number[] | AMap.Pixel)

  destroy(): void

  getAltitudeByContainer(pixel: number[] | AMap.Pixel)

  pixelToLngLat(pixel: number[] | AMap.Pixel, zoom?: number): AMap.LngLat

  lngLatToPixel(lnglat: number[] | AMap.LngLat, zoom?: number): AMap.Pixel

  getLimitBounds(): void

  setLimitBounds(): void

  clearLimitBounds(): void

  getZooms(): number[]

  setZooms(zooms: number[])

  getResolution(): number

  getScale(dpi: number): number

  getCity(getCityCallBack: {(e: any)}, lnglat: number[])

  setCity(cityName: string)

  setFitView(overlays: Overlay[], immediately = false, avoid?: [number, number, number, number], maxZoom?: number): void

  getFitZoomAndCenterByOverlays(overlays: Overlay[], avoid: number[], maxZoom: number): void

  getFitZoomAndCenterByBounds(bounds: number[] | AMap.Bounds, avoid: number[], maxZoom: number): void

  addControl(control: AMap.Control): void

  removeControl(control: AMap.Control): void

  setMapStyle(value: string): void

  getMapStyle(): string

  getAllOverlays(type?: 'marker' | 'circle' | 'polyline' | 'polygon'): Overlay[]

  clearMap(): void

  clearInfoWindow(): void

  getFeatures(): string[]

  setFeatures(features: Array<'bg' | 'point' | 'road' | 'building'>)

  getMapApprovalNumber(): string

  setMask(maskPath: number[][], maskPath: number[]): void

  setLabelRejectMask(reject: boolean): void
}

export interface MapOptions {
  center?: number[] | AMap.LngLat,
  zoom?: number,
  rotation?: number,
  pitch?: number,
  viewMode?: '2D' | '3D',
  terrain?: boolean,
  features?: ('bg' | 'point' | 'road' | 'building')[],
  layers?: Layer[],
  zooms?: number[],
  dragEnable?: boolean,
  zoomEnable?: boolean,
  jogEnable?: boolean,
  pitchEnable?: boolean,
  rotateEnable?: boolean,
  animateEnable?: boolean,
  keyboardEnable?: boolean,
  doubleClickZoom?: boolean,
  scrollWheel?: boolean,
  touchZoom?: boolean,
  touchZoomCenter?: boolean,
  showLabel?: boolean,
  defaultCursor?: string,
  isHotspot?: string,
  mapStyle?: string,
  wallColor?: string | number[],
  roofColor?: string | number[],
  showBuildingBlock?: boolean,
  showIndoorMap?: boolean,
  skyColor?: boolean,
  labelRejectMask?: boolean,
  mask?: number[],
  WebGLParams?: any
}

interface MapStatus {
  showIndoorMap?: boolean,
  resizeEnable?: boolean,
  dragEnable?: boolean,
  keyboardEnable?: boolean,
  doubleClickZoom?: boolean,
  zoomEnable?: boolean,
  rotateEnable?: boolean
}

// region Event
type MapEventType =
  | 'resize'
  | 'complete'
  | 'click'
  | 'dblclick'
  | 'mapmove'
  | 'hotspotclick'
  | 'hotspotover'
  | 'hotspotout'
  | 'movestart'
  | 'moveend'
  | 'zoomchange'
  | 'zoomstart'
  | 'zoomend'
  | 'rotatechange'
  | 'rotatestart'
  | 'mousemove'
  | 'mousewheel'
  | 'mouseover'
  | 'mouseout'
  | 'mouseup'
  | 'mousedown'
  | 'rightclick'
  | 'dragstart'
  | 'dragging'
  | 'dragend'
  | 'touchstart'
  | 'touchmove'
  | 'touchend';

export interface MapsEvent {
  lnglat: AMap.LngLat,
  pixel: AMap.Pixel,
  type: string,
  target: any
}

type MapEvent = Record<MapEventType, MapsEvent>
// endregion