package com.mogo.map

import android.graphics.Point
import android.graphics.Rect
import android.os.Bundle
import android.text.TextUtils
import android.view.MotionEvent
import android.view.View
import com.mogo.eagle.core.data.deva.chain.ChainConstant
import com.mogo.eagle.core.data.enums.TrafficTypeEnum
import com.mogo.eagle.core.data.map.MapRoadInfo
import com.mogo.eagle.core.data.map.MogoLatLng
import com.mogo.eagle.core.data.map.MogoLocation
import com.mogo.eagle.core.function.call.autopilot.CallerChassisLocationWGS84ListenerManager.getChassisLocationWGS84
import com.mogo.eagle.core.function.call.map.CallerMapDataCollectorManager.setIsInit
import com.mogo.eagle.core.function.call.map.CallerMapDevaListenerManager.invokeUploadLogFile
import com.mogo.eagle.core.function.call.map.CallerMapRoadListenerManager.invokeListenersOnRoadIdGet
import com.mogo.eagle.core.function.call.map.CallerMapRoadListenerManager.invokeListenersOnStopLineGet
import com.mogo.eagle.core.function.call.map.CallerMapRomaListener.invokeMapRomaStatus
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.d
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.e
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.i
import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger.w
import com.mogo.eagle.core.utilcode.mogo.logger.scene.SceneConstant
import com.mogo.eagle.core.utilcode.util.ThreadUtils
import com.mogo.eagle.core.utilcode.util.UiThreadHandler
import com.mogo.map.listener.MogoMapListenerHandler.Companion.mogoMapListenerHandler
import com.mogo.map.uicontroller.*
import com.mogo.map.utils.MogoMapUtils
import com.mogo.map.utils.ObjectUtils
import com.zhidaoauto.map.data.point.LonLatPoint
import com.zhidaoauto.map.data.road.RoadCross
import com.zhidaoauto.map.data.road.StopLine
import com.zhidaoauto.map.sdk.open.MapAutoApi
import com.zhidaoauto.map.sdk.open.MapAutoApi.registerLogListener
import com.zhidaoauto.map.sdk.open.MapAutoApi.unregisterLogListener
import com.zhidaoauto.map.sdk.open.abs.*
import com.zhidaoauto.map.sdk.open.abs.log.ILog
import com.zhidaoauto.map.sdk.open.business.PointCloudHelper.setIsDrawPointCloud
import com.zhidaoauto.map.sdk.open.business.PointCloudHelper.setPointCloudColor
import com.zhidaoauto.map.sdk.open.business.PointCloudHelper.setPointCloudSize
import com.zhidaoauto.map.sdk.open.business.PointCloudHelper.updatePointCloudDataByPb
import com.zhidaoauto.map.sdk.open.camera.CameraPosition
import com.zhidaoauto.map.sdk.open.camera.CameraUpdateFactory.newLatLngBounds
import com.zhidaoauto.map.sdk.open.data.MapDataApi.getNearstFromPointToSegment
import com.zhidaoauto.map.sdk.open.marker.BitmapDescriptorFactory.convertViewToBitmap
import com.zhidaoauto.map.sdk.open.marker.Marker
import com.zhidaoauto.map.sdk.open.marker.OnMarkClickListener
import com.zhidaoauto.map.sdk.open.tools.MapTools.fromScreenLocation
import com.zhidaoauto.map.sdk.open.tools.MapTools.getVisibleRegion
import com.zhidaoauto.map.sdk.open.tools.MapTools.toScreenLocation
import com.zhidaoauto.map.sdk.open.view.MapAutoView
import com.zhjt.service.chain.ChainLog

class AMapViewWrapper(mMapView: MapAutoView) : IMogoMapView, IMogoMapUIController,
    OnMapLoadedListener, OnCameraChangeListener, OnMapClickListener, OnMapTouchListener,
    OnMarkClickListener, OnMapStyleListener, OnMapViewVisualAngleChangeListener, OnRoadInfoListener,
    ILog, OnRoamStatusListener {

    companion object {
        private const val TAG = "AMapViewWrapper"
    }

    private var mMapView: MapAutoView
    private val mIMap: IMogoMap
    private val DEFAULT_OPTION = CarCursorOption.Builder()
        .carCursorRes(R.drawable.map_api_ic_current_location2)
        .naviCursorRes(R.drawable.ic_amap_navi_cursor)
        .build()
    private var mCarCursorOption = DEFAULT_OPTION

    @Volatile
    private var visualLock = false

    @Volatile
    private var mCurrentUI: EnumMapUI = EnumMapUI.MAP_STYLE_NIGHT_VR
    override var currentMapVisualAngle: VisualAngleMode = VisualAngleMode.MODE_MEDIUM_SIGHT
        private set

    init {
        i(SceneConstant.M_MAP + TAG, "AMapViewWrapper: init")
        this.mMapView = mMapView
        initViews()
        initListeners()
        mIMap = AMapWrapper(this.mMapView.getMapAutoViewHelper(), this.mMapView, this)
    }

    private fun initViews() {
        // 初始化首次地图进入的时候的样式， MapAutoApi.INSTANCE.init(context, mapParams);将影响这里的数据
        val mapStyle = mMapView.getMapStyleParams()!!.getStyleMode()
        d(SceneConstant.M_MAP + TAG, "默认配置地图模式：mapStyle=$mapStyle")
        when (mapStyle) {
            MapAutoApi.MAP_STYLE_DAY -> mCurrentUI = EnumMapUI.MAP_STYLE_DAY
            MapAutoApi.MAP_STYLE_DAY_NAV -> mCurrentUI = EnumMapUI.MAP_STYLE_DAY_NAV
            MapAutoApi.MAP_STYLE_NIGHT -> mCurrentUI = EnumMapUI.MAP_STYLE_NIGHT
            MapAutoApi.MAP_STYLE_NIGHT_NAV -> mCurrentUI = EnumMapUI.MAP_STYLE_NIGHT_NAV
            MapAutoApi.MAP_STYLE_DAY_VR -> mCurrentUI = EnumMapUI.MAP_STYLE_DAY_VR
            MapAutoApi.MAP_STYLE_NIGHT_VR -> mCurrentUI = EnumMapUI.MAP_STYLE_NIGHT_VR
            else -> e(SceneConstant.M_MAP + TAG, "暂不支持此地图模式，默认使用VR夜间模式")
        }
    }

    private fun initListeners() {
        mMapView.setOnMarkClickListener(this)
        mMapView.setOnMapLoadedListener(this)
        mMapView.setOnMapTouchListener(this)
        mMapView.setOnMapClickListener(this)
        mMapView.setOnCameraChangeListener(this)
        mMapView.setOnMapStyleListener(this)
        mMapView.setOnRoamStatusListener(this)
        mMapView.setOnMapViewVisualAngleChangeListener(this)
        mMapView.setOnRoadInfoListener(this, 1)
        registerLogListener(this, mMapView.getEventController())
        d(SceneConstant.M_MAP + TAG, "initListeners - setOnMapStyleListener - view $mMapView")
    }

    override fun getMapView(): View {
        return mMapView
    }

    override fun getMap(): IMogoMap {
        return mIMap
    }

    override fun onCreate(bundle: Bundle) {
        mMapView.onCreate(bundle)
        d(SceneConstant.M_MAP + TAG, "map onCreate")
    }

    override fun onResume() {
        mMapView.onResume()
        d(SceneConstant.M_MAP + TAG, "map onResume")
    }

    override fun onPause() {
        mMapView.onPause()
        d(SceneConstant.M_MAP + TAG, "map onPause")
    }

    override fun onDestroy() {
        mMapView.onDestroy()
        mMapView.setOnMarkClickListener(null)
        mMapView.setOnMapLoadedListener(null)
        mMapView.setOnMapTouchListener(null)
        mMapView.setOnMapClickListener(null)
        mMapView.setOnCameraChangeListener(null)
        mMapView.setOnMapStyleListener(null)
        mMapView.setOnMapViewVisualAngleChangeListener(null)
        unregisterLogListener(this, mMapView.getEventController())
        d(SceneConstant.M_MAP + TAG, "map onDestroy")
    }

    override fun onSaveInstanceState(outState: Bundle) {
        mMapView.onSaveInstanceState(outState)
        d(SceneConstant.M_MAP + TAG, "map onSaveInstanceState")
    }

    override fun onLowMemory() {}

    //渲染第一帧
    @ChainLog(
        linkChainLog = ChainConstant.CHAIN_TYPE_INIT_STATUS,
        linkCode = ChainConstant.CHAIN_SOURCE_INIT,
        nodeAliasCode = ChainConstant.CHAIN_CODE_INIT_ON_MAP_INIT,
        paramIndexes = [-1]
    )
    override fun onMapInit() {
        i(SceneConstant.M_MAP + TAG, "onMapInit: ")
        mogoMapListenerHandler.onMapLoaded()
    }

    //地图视图准备
    @ChainLog(
        linkChainLog = ChainConstant.CHAIN_TYPE_INIT_STATUS,
        linkCode = ChainConstant.CHAIN_SOURCE_INIT,
        nodeAliasCode = ChainConstant.CHAIN_CODE_INIT_ON_MAP_LOADED,
        paramIndexes = [-1]
    )
    override fun onMapLoaded() {
        i(SceneConstant.M_MAP + TAG, "onMapLoaded: ")
        if (checkAMapView()) {
            val cameraPosition = mMapView.getMapAutoViewHelper()!!
                .getCameraPosition()
            mogoMapListenerHandler.onMapChanged(
                ObjectUtils.fromAMap(cameraPosition.target),
                cameraPosition.zoom,
                cameraPosition.tilt,
                cameraPosition.bearing
            )
            loadPreVehicleModel()
        }
    }

    override fun onRoadLoaded(roadInfo: String?) {

    }

    /**
     * 修改获取当前车道号
     *
     * @param roadId
     * @param laneId
     */
    override fun onRoadIdInfo(roadId: String?, laneId: String?) {
        if (roadId != null && !TextUtils.isEmpty(roadId)) {
            invokeListenersOnRoadIdGet(roadId)
        }
    }

    override fun onRoadCrossInfo(roadCross: RoadCross?) {
        d(SceneConstant.M_MAP + TAG, "onRoadCrossInfo:roadCross$roadCross")
    }

    //todo 多实例 对象替换
    override fun onStopLineInfo(stopLine: StopLine?) {
        val carLoc = getChassisLocationWGS84()
        if (stopLine != null && stopLine.road_id.isNotEmpty() && stopLine.points.size > 0) {
            val points = stopLine.points
            d(SceneConstant.M_MAP + TAG, "onStopLineInfo:stop_line$stopLine")
            val stopInfo = convert(stopLine)
            val p1 = points[0]
            val p2 = points[points.size - 1]
            val distanceOfCarToStopLine = getNearstFromPointToSegment(
                carLoc.longitude,
                carLoc.latitude,
                p1.longitude,
                p1.latitude,
                p2.longitude,
                p2.latitude
            ) * 100000
            stopInfo.distanceOfCarToStopLine = distanceOfCarToStopLine
            d(SceneConstant.M_MAP + TAG, "onStopLineInfo: --- distance: $distanceOfCarToStopLine")
            invokeListenersOnStopLineGet(stopInfo)
        }
    }

    private fun convert(line: StopLine): MapRoadInfo.StopLine {
        val ret = MapRoadInfo.StopLine()
        ret.distance = line.distance
        ret.laneId = line.lane_id
        ret.roadId = line.road_id
        ret.tieId = line.tile_id
        val points = line.points
        if (points.size > 0) {
            val newPoints: MutableList<MogoLatLng> = ArrayList()
            for (i in points.indices) {
                val lonLatPoint = points[i]
                val latLng = MogoLatLng(lonLatPoint.latitude, lonLatPoint.longitude)
                latLng.duration = lonLatPoint.duration
                latLng.angle = lonLatPoint.angle
                latLng.speed = lonLatPoint.speed
                latLng.altitude = lonLatPoint.altitude
                latLng.provider = lonLatPoint.provider
                newPoints.add(latLng)
            }
            ret.points = newPoints
        }
        return ret
    }

    override fun changeZoom(zoom: Float) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.setZoom(zoom.toInt())
        }
    }

    override fun changeZoom2(zoom: Float) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.setZoomVal(zoom)
        }
    }

    override fun changeMapVisualAngle(angelMode: VisualAngleMode, mogoLatLng: MogoLatLng?) {
        if(visualLock){
            e(SceneConstant.M_MAP + TAG, "视角切换已锁定")
            return
        }
        val mapAutoViewHelper = mMapView.getMapAutoViewHelper()
        if (mapAutoViewHelper != null) {
            currentMapVisualAngle = angelMode
            if (angelMode == VisualAngleMode.MODE_CLOSE_SIGHT) {
                if (mogoLatLng == null) {
                    e(SceneConstant.M_MAP + TAG, "切换地图近景需要传入要移动的经纬度数据")
                    return
                }
                // 近景传入经纬度为点击地图上静态marker经纬度数据，为GPS坐标点。
                mapAutoViewHelper.setNearViewAnglePosition(
                    LonLatPoint(
                        mogoLatLng.lon,
                        mogoLatLng.lat
                    ), true
                )
            } else {
                mapAutoViewHelper.setMapViewVisualAngle(angelMode.code)
            }
        }
    }

    @ChainLog(
        linkChainLog = ChainConstant.CHAIN_TYPE_HD_MAP,
        linkCode = ChainConstant.CHAIN_SOURCE_MAP,
        nodeAliasCode = ChainConstant.CHAIN_CODE_HD_MAP_CALL,
        paramIndexes = [0]
    )
    override fun setRoamTrajectory(trajectory: String) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.setRoamTrajectory(trajectory)
        }
    }

    @ChainLog(
        linkChainLog = ChainConstant.CHAIN_TYPE_HD_MAP,
        linkCode = ChainConstant.CHAIN_SOURCE_MAP,
        parentNodeAliasCode = ChainConstant.CHAIN_CODE_ROMA_REQUEST_OK,
        nodeAliasCode = ChainConstant.CHAIN_CODE_ROMA_MODE_INVOKE,
        paramIndexes = [0],
        endPoint = false
    )
    override fun setRomaMode(mode: Int) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.setRoamStyle(mode, 1800f, MapAutoApi.ROAM_SPEED_40)
        }
    }

    override fun moveToCenter(latLng: MogoLatLng) {
        moveToCenter(latLng, true)
    }

    private fun checkAMapView(): Boolean {
        if (mMapView.getMapAutoViewHelper() == null) {
            e(SceneConstant.M_MAP + TAG, "自研mapView实例为空，请检查")
            return false
        }
        return true
    }

    override fun moveToCenter(latLng: MogoLatLng, animate: Boolean) {
        d(SceneConstant.M_MAP + TAG, "move to center $latLng")
        if (latLng.lat == 0.0 || latLng.lon == 0.0) {
            e(SceneConstant.M_MAP + TAG, "latLng = null or is illegal")
            return
        }
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!
                .animateCamera(LonLatPoint(latLng.lon, latLng.lat))
        }
    }

    override fun showMyLocation(visible: Boolean) {
        d(SceneConstant.M_MAP + TAG, "showMyLocation1 $visible")
        // 如果是VR模式
        if (isVrMold) {
            return
        }
        // 不是VR模式情况强制刷新下
        if (checkAMapView()) {
            val style = mMapView.getMapAutoViewHelper()!!
                .getMyLocationStyle()
            if (visible) {
                // 强制刷新一遍车标
                style!!.myLocationIcon(mCarCursorOption!!.carCursorRes)
            }
            mMapView.getMapAutoViewHelper()!!.setMyLocationStyle(style!!)
        }
    }

    /**
     * @return true-是，false=不是
     */
    private val isVrMold: Boolean
        get() {
            val isVrMode =
                mCurrentUI === EnumMapUI.MAP_STYLE_NIGHT_VR || mCurrentUI === EnumMapUI.MAP_STYLE_DAY_VR
            d(SceneConstant.M_MAP + TAG, "是否是VR模式: $isVrMode")
            return isVrMode
        }

    /**
     * 是否是白天模式
     *
     * @return true-是，false-不是
     */
    override val isDayMode: Boolean
        get() = mCurrentUI === EnumMapUI.MAP_STYLE_DAY_VR || mCurrentUI === EnumMapUI.MAP_STYLE_DAY || mCurrentUI === EnumMapUI.MAP_STYLE_DAY_NAV

    override fun showMyLocation(view: View) {
        if (checkAMapView()) {
            val style = mMapView.getMapAutoViewHelper()!!.getMyLocationStyle()
            style!!.myLocationIcon(convertViewToBitmap(view))
            mMapView.getMapAutoViewHelper()!!.setMyLocationStyle(style)
        }
    }

    override val scalePerPixel: Float
        get() = if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.getScalePerPixel()
        } else 0.0f
    override val zoomLevel: Float
        get() = if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.getZoom().toFloat()
        } else 0.0f
    override val cameraNorthEastPosition: MogoLatLng?
        get() = ObjectUtils.fromAMap(getVisibleRegion(mMapView.getMapController()).rightTopPoint)
    override val cameraSouthWestPosition: MogoLatLng?
        get() {
            try {
                return ObjectUtils.fromAMap(getVisibleRegion(mMapView.getMapController()).leftBottomPoint)
            } catch (e: Exception) {
                e.printStackTrace()
            }
            return null
        }
    override val windowCenterLocation: MogoLatLng?
        get() {
            try {
                if (checkAMapView()) {
                    return ObjectUtils.fromAMap(mMapView.getMapAutoViewHelper()!!.getCenter())
                }
            } catch (e: Exception) {
                e.printStackTrace()
            }
            return null
        }

    override fun setPointToCenter(mapCenterX: Double, mapCenterY: Double) {
        if (checkAMapView()) {
            if (isVrMold) {
                return
            }
            mMapView.getMapAutoViewHelper()!!
                .setPointToCenter(mapCenterX.toFloat(), mapCenterY.toFloat())
        }
    }

    override fun getLocationPointInScreen(latLng: MogoLatLng): Point? {
        return if (checkAMapView()) {
            try {
                toScreenLocation(ObjectUtils.fromMogo(latLng), mMapView.getMapController())
            } catch (e: Exception) {
                e.printStackTrace()
                null
            }
        } else null
    }

    override fun getLocationMogoLatLngInScreen(point: Point): MogoLatLng? {
        return if (checkAMapView()) {
            try {
                ObjectUtils.fromAMap(fromScreenLocation(point, mMapView.getMapController()))
            } catch (e: Exception) {
                e.printStackTrace()
                null
            }
        } else null
    }

    override fun setRenderFps(fps: Int) {
        if (checkAMapView()) {
            if (mMapView.getMapAutoViewHelper() != null) {
                mMapView.getMapAutoViewHelper()!!.setRenderFps(fps)
            }
        }
    }

    override fun showBounds(
        tag: String,
        carPosition: MogoLatLng,
        lonLats: List<MogoLatLng>,
        bound: Rect,
        lockCarPosition: Boolean
    ) {
        if (!checkAMapView()) {
            return
        }
        if (isVrMold) {
            w(SceneConstant.M_MAP + TAG, "vr 模式下忽略该设置")
            return
        }
        i(
            SceneConstant.M_MAP + TAG,
            "showBounds : " + carPosition.toString() + " , " + bound.toShortString() + " , " + lockCarPosition
        )
        try {
            val latLngBounds = MogoMapUtils.getLatLngBounds(carPosition, lonLats, lockCarPosition)
            mMapView.getMapAutoViewHelper()!!.setCenter(ObjectUtils.fromMogo(carPosition))
            mMapView.getMapAutoViewHelper()!!.moveCamera(
                newLatLngBounds(
                    latLngBounds,
                    bound.left,
                    bound.right,
                    bound.top,
                    bound.bottom
                )
            )
        } catch (e: Exception) {
            e(SceneConstant.M_MAP + TAG, " error : $e")
        }
    }

    override fun forceRender() {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.runOnDrawFrame()
        }
    }

    override fun calculateLineDistance(p1: MogoLatLng, p2: MogoLatLng): Float {
        return MogoMapUtils.calculateLineDistance(
            ObjectUtils.fromMogo(p1),
            ObjectUtils.fromMogo(p2)
        )
    }

    @get:Synchronized
    override val isCarLocked: Boolean
        get() = mMapView.getMapAutoViewHelper()!!.getLockMode()

    override fun setCarCursorOption(option: CarCursorOption) {
        if (isVrMold) {
            return
        }
        if (!checkAMapView()) {
            return
        }
        if (mCarCursorOption != null && mCarCursorOption !== DEFAULT_OPTION) {
            mCarCursorOption!!.destroy()
        }
        mCarCursorOption = try {
            option.clone()
        } catch (e: Exception) {
            DEFAULT_OPTION
        }
        val style = mMapView.getMapAutoViewHelper()!!.getMyLocationStyle()
        if (mCarCursorOption!!.carCursorBmp != null && !mCarCursorOption!!.carCursorBmp.isRecycled) {
            style!!.myLocationIcon(mCarCursorOption!!.carCursorBmp)
        } else {
            if (mCarCursorOption!!.carCursorRes != 0) {
                style!!.myLocationIcon(mCarCursorOption!!.carCursorRes)
            }
        }
        mMapView.getMapAutoViewHelper()!!.setMyLocationStyle(style!!)
    }

    /**
     * 设置转向灯和刹车灯
     *
     * @param type :车尾灯类型
     * @param time 闪烁时间 最小500ms 小于500ms 默认为500ms
     */
    override fun setCarLightsType(type: Int, time: Int) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.setTailLightsType(type, time)
        }
    }

    override val mapCameraPosition: MapCameraPosition?
        get() {
            if (checkAMapView()) {
                val cameraPosition = mMapView.getMapAutoViewHelper()!!.getCameraPosition()
                return ObjectUtils.fromAMap(cameraPosition)
            }
            return null
        }

    override fun changeBearing(bearing: Float) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.setMapViewRotation(bearing)
        }
    }

    override fun changeCurrentIcon(iconId: Int) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.getMyLocationStyle()!!.myLocationIcon(iconId, true)
        }
    }

    override fun result(path: String) {
        invokeUploadLogFile(path)
    }

    override fun onTouch(event: MotionEvent): Boolean {
        mogoMapListenerHandler.onTouch(event)
        return false
    }

    override fun onMapClick(lonLatPoint: LonLatPoint) {
        mogoMapListenerHandler.onMapClick(ObjectUtils.fromAMap(lonLatPoint))
    }

    override fun onMapViewVisualAngleChange(type: Int) {
        d(SceneConstant.M_MAP + TAG, " 地图自动更改视距 currentThread : " + Thread.currentThread().name)
        currentMapVisualAngle = getVisualAngleMode(type)
        mogoMapListenerHandler.onMapVisualAngleChanged(currentMapVisualAngle)
    }

    private fun getVisualAngleMode(mode: Int): VisualAngleMode {
        return when (mode) {
            0 -> VisualAngleMode.MODE_CLOSE_SIGHT
            1 -> VisualAngleMode.MODE_MEDIUM_SIGHT
            2 -> VisualAngleMode.MODE_LONG_SIGHT
            3 -> VisualAngleMode.MAP_STYLE_VR_ANGLE_300
            4 -> VisualAngleMode.MAP_STYLE_VR_ANGLE_TOP
            5 -> VisualAngleMode.MAP_STYLE_VR_ANGLE_CROSS
            7 -> VisualAngleMode.MAP_STYLE_VR_ROMA
            else -> VisualAngleMode.MODE_MEDIUM_SIGHT
        }
    }

    override fun onCameraChange(type: Int, value: Int) {}
    override fun onCameraChangeFinish(position: CameraPosition?) {
        position?.let {
            mogoMapListenerHandler.onMapChanged(
                ObjectUtils.fromAMap(position.target),
                position.zoom,
                position.tilt,
                position.bearing
            )
        }
    }

    override fun onChangeMapStyle(style: Int) {
//        CallerLogger.INSTANCE.d(M_MAP + TAG, "currentMapStyle = " + styleId + " , current = " + mCurrentUI);
        // 映射地图样式ID到鹰眼样式ID
        when (style) {
            MapAutoApi.MAP_STYLE_DAY, MapAutoApi.MAP_STYLE_DAY_NAV -> {
                mCurrentUI = EnumMapUI.MAP_STYLE_DAY_NAV
            }
            MapAutoApi.MAP_STYLE_NIGHT -> {
                mCurrentUI = EnumMapUI.MAP_STYLE_NIGHT
            }
            MapAutoApi.MAP_STYLE_NIGHT_NAV -> {
                mCurrentUI = EnumMapUI.MAP_STYLE_NIGHT_NAV
            }
            MapAutoApi.MAP_STYLE_NIGHT_VR -> {
                mCurrentUI = EnumMapUI.MAP_STYLE_NIGHT_VR
            }
            MapAutoApi.MAP_STYLE_DAY_VR -> {
                mCurrentUI = EnumMapUI.MAP_STYLE_DAY_VR
            }
        }
        loadPreVehicleModel()
        mogoMapListenerHandler.onMapModeChanged(mCurrentUI)
    }

    override fun onMarkClick(marker: Marker) {

    }

    override fun onRoamStatus(status: Int, msg: String) {
        invokeMapRomaStatus(status, msg)
    }

    override fun rtkEnable(enable: Boolean) {
        if (checkAMapView()) {
            mMapView.getLocationClient()!!.rtkEnable(enable)
        }
    }

    override fun stepInDayMode(isDayMode: Boolean) {
//        try {
//            if (mMapView != null && mMapView.getMapAutoViewHelper() != null) {
//                mMapView.getMapAutoViewHelper().setMapStyle();
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
    }

    override fun visualAngleLock(lock: Boolean) {
        visualLock = lock
    }

    override fun setMapDAngle(angle: Float) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.setMapDAngle(angle)
        }
    }

    /**
     * 加载3D模型
     */
    private fun loadPreVehicleModel() {
        d(SceneConstant.M_MAP + TAG, "添加感知模型到地图中……")
        ThreadUtils.getIoPool().submit {
            addPreVehicleModelWeiZhi(
                TrafficTypeEnum.TYPE_TRAFFIC_ID_WEI_ZHI,
                "添加感知模型到地图中……preVehicleStrWeiZhi="
            )
            addPreVehicleModelWeiZhi(
                TrafficTypeEnum.TYPE_TRAFFIC_ID_PEOPLE,
                "添加感知模型到地图中……preVehicleStrPeople="
            )
            addPreVehicleModelWeiZhi(
                TrafficTypeEnum.TYPE_TRAFFIC_ID_BICYCLE,
                "添加感知模型到地图中……preVehicleStrBicycle="
            )
            addPreVehicleModelWeiZhi(
                TrafficTypeEnum.TYPE_TRAFFIC_ID_TA_CHE,
                "添加感知模型到地图中……preVehicleStrTaChe="
            )
            addPreVehicleModelWeiZhi(
                TrafficTypeEnum.TYPE_TRAFFIC_ID_MOTO,
                "添加感知模型到地图中……preVehicleStrMoto="
            )
            addPreVehicleModelWeiZhi(
                TrafficTypeEnum.TYPE_TRAFFIC_ID_BUS,
                "添加感知模型到地图中……preVehicleStrBus="
            )
            addPreVehicleModelWeiZhi(
                TrafficTypeEnum.TYPE_TRAFFIC_ID_TRUCK,
                "添加感知模型到地图中……preVehicleStrTruck="
            )
        }
    }

    /**
     * 添加模型到地图中
     *
     * @param typeTrafficId 障碍物类型ID
     * @param logMsg        日志消息
     */
    private fun addPreVehicleModelWeiZhi(typeTrafficId: TrafficTypeEnum, logMsg: String) {
        // 根据当前的地图皮肤模式动态替换
        val preVehicleStrWeiZhi: String? = if (isDayMode) {
            map.addPreVehicleModel(typeTrafficId.type, typeTrafficId.traffic3DIconId)
        } else {
            map.addPreVehicleModel(typeTrafficId.type, typeTrafficId.traffic3DNightIconId)
        }
        d(SceneConstant.M_MAP + TAG, logMsg + preVehicleStrWeiZhi)
        if (preVehicleStrWeiZhi == null) {
            UiThreadHandler.postDelayed({
                w(SceneConstant.M_MAP + TAG, "添加感知模型到地图中失败，尝试重复添加……")
                addPreVehicleModelWeiZhi(typeTrafficId, logMsg)
            }, 1000L)
        }
    }

    override fun setLockMode(isLock: Boolean) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.setLockMode(isLock)
        }
    }

    override fun setScrollGesturesEnable(isEnable: Boolean) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.setScrollGesturesEnabled(isEnable)
        }
    }

    override fun setAllGesturesEnabled(isEnable: Boolean) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.setAllGesturesEnabled(isEnable)
        }
    }

    override fun setExtraGPSData(gnssInfo: MogoLocation) {
        val locationClient = mMapView.getLocationClient()
        if (locationClient != null) {
            locationClient.setIsUseExtraGPSData(true) //设置是否使用外界坐标
            locationClient.rtkEnable(true) //设置是否是高精定位
            val lonLatPoint = LonLatPoint()
            lonLatPoint.angle = gnssInfo.heading
            lonLatPoint.altitude = gnssInfo.altitude
            lonLatPoint.longitude = gnssInfo.longitude
            lonLatPoint.latitude = gnssInfo.latitude
            lonLatPoint.satelliteTime =
                java.lang.Double.valueOf((gnssInfo.satelliteTime * 1000).toDouble()).toLong()
            lonLatPoint.speed = gnssInfo.gnssSpeed.toDouble()
            locationClient.updateLocation(lonLatPoint) //更新新自动驾驶RTK相关数据
            setIsInit()
        }
    }

    // 是否绘制点云
    override fun setIsDrawPointCloud(isDrawPointCloud: Boolean) {
        try {
            setIsDrawPointCloud(isDrawPointCloud, mMapView.getMapController())
        } catch (e: Exception) {
            e.printStackTrace()
        }
    }

    //设置点云大小
    override fun setPointCloudSize(pointCloudSize: Float) {
        setPointCloudSize(pointCloudSize, mMapView.getMapController())
    }

    // 设置点云颜色
    override fun setPointCloudColor(color: String) {
        setPointCloudColor(color, mMapView.getMapController())
    }

    //更新点云
    override fun updatePointCloud(
        dataArray: ByteArray?, isTransformer: Boolean, isResidual: Boolean, isReset: Boolean
    ): Boolean {
        return updatePointCloudDataByPb(
            dataArray, isTransformer, isResidual, isReset, mMapView.getMapController()
        )
    }

    override fun animateTo(
        lon: Double,
        lat: Double,
        rotateAngle: Float,
        duration: Int,
        isGps: Boolean
    ) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.animateTo(lon, lat, rotateAngle, duration, isGps)
        }
    }

    override fun animateTo(
        lon: Double,
        lat: Double,
        v1: Float,
        v2: Float,
        v3: Float,
        v4: Float,
        duration: Int,
        isGps: Boolean
    ) {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.animateTo(lon, lat, v1, v2, v3, v4, duration, isGps)
        }
    }

    override fun clear() {
        if (checkAMapView()) {
            mMapView.getMapAutoViewHelper()!!.clearPanel()
        }
    }

}