package com.mogo.map;

import android.content.Context;
import android.graphics.Point;

import com.mogo.eagle.core.utilcode.mogo.logger.CallerLogger;
import com.mogo.map.marker.AMapInfoWindowAdapter;
import com.mogo.map.marker.AMapMarkerWrapper;
import com.mogo.map.marker.IMogoMarker;
import com.mogo.map.marker.MogoMarkerOptions;
import com.mogo.map.marker.MogoMarkersHandler;
import com.mogo.map.overlay.AMapPolylineWrapper;
import com.mogo.map.overlay.IMogoPolyline;
import com.mogo.map.overlay.MogoPolylineOptions;
import com.mogo.map.uicontroller.AMapUIController;
import com.mogo.map.uicontroller.IMogoMapUIController;
import com.mogo.map.utils.ObjectUtils;
import com.zhidaoauto.map.sdk.open.MapAutoApi;
import com.zhidaoauto.map.sdk.open.data.MapDataApi;
import com.zhidaoauto.map.sdk.open.data.SinglePointRoadInfo;
import com.zhidaoauto.map.sdk.open.marker.Marker;
import com.zhidaoauto.map.sdk.open.marker.MarkerHelper;
import com.zhidaoauto.map.sdk.open.marker.MarkerOptions;
import com.zhidaoauto.map.sdk.open.marker.MarkerSimpleData;
import com.zhidaoauto.map.sdk.open.marker.MultiPointOverlayOptions;
import com.zhidaoauto.map.sdk.open.poyline.Polyline;
import com.zhidaoauto.map.sdk.open.poyline.PolylineOptions;
import com.zhidaoauto.map.sdk.open.query.LonLatPoint;
import com.zhidaoauto.map.sdk.open.tools.MapTools;
import com.zhidaoauto.map.sdk.open.view.MapAutoView;
import com.zhidaoauto.map.sdk.open.view.MapAutoViewHelper;

import java.util.ArrayList;
import java.util.List;

import mogo.telematics.pad.MessagePad;

/**
 * @author congtaowang
 * @since 2019-12-18
 * <p>
 * 代理自研AMap
 */
public class AMapWrapper implements IMogoMap {

    private static final String TAG = "AMapWrapper";

    private static MapAutoViewHelper sAMap;
    private IMogoMapUIController mUIcontroller;
    private MapAutoViewHelper mAMap;
    private MapAutoView mMapView;
    private IMogoUiSettings mUiSettings;

    public AMapWrapper(MapAutoViewHelper map, MapAutoView mapView, IMogoMapUIController controller) {
        CallerLogger.INSTANCE.i(TAG, "autoop--AMapWrapper: init" + this);
        this.mAMap = map;
        sAMap = map;
        this.mMapView = mapView;
        mUIcontroller = controller;
        // 设置实现自定义 info window
        MapAutoApi.INSTANCE.setInfoWindowAdapter(new AMapInfoWindowAdapter());
        AMapUIController.getInstance().initClient(mUIcontroller);
    }

    public static MapAutoViewHelper getAMap() {
        return sAMap;
    }

    @Override
    public IMogoUiSettings getUiSettings() {
        if (!checkAMap()) {
            return null;
        }
        if (mUiSettings == null) {
            mUiSettings = new AMapUiSettingsWrapper(mAMap);
        }
        return mUiSettings;
    }

    @Override
    public IMogoMapUIController getUIController() {
        return mUIcontroller;
    }

    @Override
    public IMogoMarker addMarker(String tag, MogoMarkerOptions options) {
        if (!checkAMap()) {
            return null;
        }
        MarkerOptions markerOptions = ObjectUtils.fromMogo(options);
        if (markerOptions == null) {
            CallerLogger.INSTANCE.e(TAG, "marker参数为空");
            return null;
        }
        final IMogoMarker mogoMarker = new AMapMarkerWrapper(mAMap.addMarker(markerOptions), options);
        if (options.isAutoManager()) {
            MogoMarkersHandler.getInstance().add(tag, mogoMarker);
        }
        return mogoMarker;
    }

    @Override
    public void updateBatchMarkerPosition(ArrayList<MessagePad.TrackedObject> optionsArrayList) {
        if (!checkAMap()) {
            return;
        }
        ArrayList<MarkerSimpleData> markerOptionsArrayList = new ArrayList<>();
        for (MessagePad.TrackedObject mogoMarkerOptions : optionsArrayList) {
            MarkerSimpleData markerOptions = ObjectUtils.fromTrafficData(mogoMarkerOptions);
            if (markerOptions == null) {
                CallerLogger.INSTANCE.e(TAG, "marker参数为空");
                break;
            }
            markerOptionsArrayList.add(markerOptions);
        }

        MarkerHelper.INSTANCE.updateBatchMarkerPositon(markerOptionsArrayList,false,8.0f,0,100);
    }

    @Override
    public String addPreVehicleModel(int type, int modelRes) {
        try {
          return  MarkerHelper.INSTANCE.addPreVehicleModel(type, modelRes);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public void removeMarker(String uuidString) {
        try {
            MarkerHelper.INSTANCE.removeMarker(uuidString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public ArrayList<IMogoMarker> addMarkers(String tag, ArrayList<MogoMarkerOptions> options, boolean moveToCenter) {
        if (!checkAMap()) {
            return null;
        }

        if (options == null || options.isEmpty()) {
            return null;
        }

        ArrayList<Marker> markers = new ArrayList<>();
        ArrayList<MarkerOptions> markerOptions = new ArrayList<>();
        ArrayList<IMogoMarker> mogoMarkers = new ArrayList<>();
        for (MogoMarkerOptions option : options) {
            if (option == null) {
                continue;
            }
            MarkerOptions mo = ObjectUtils.fromMogo(option);
            if (mo == null) {
                continue;
            }
            markerOptions.add(mo);
        }
        if (markerOptions.isEmpty()) {
            return null;
        }
        MultiPointOverlayOptions multiPointOverlayOptions = new MultiPointOverlayOptions();
        multiPointOverlayOptions.setData(markerOptions);
        multiPointOverlayOptions.setMarkerIcon(R.drawable.marker_blue);
        List<MarkerOptions> data = mAMap.addMarkers(multiPointOverlayOptions).getOptions().getData();
        for (int i = 0; i < data.size(); i++) {
            markers.add(new Marker(data.get(i)));
        }
        if (markers == null || markers.isEmpty()) {
            return null;
        }
        for (int i = 0; i < markers.size(); i++) {
            Marker marker = markers.get(i);
            if (marker == null) {
                continue;
            }
            mogoMarkers.add(new AMapMarkerWrapper(marker, options.get(i)));
        }
        MogoMarkersHandler.getInstance().add(tag, mogoMarkers);
        return mogoMarkers;
    }

    @Override
    public void clear() {
        if (checkAMap()) {
            mAMap.clearPanel();
        }
    }

    @Override
    public void clear(boolean isKeepMyLocationOverlay) {
        if (checkAMap()) {
            mAMap.clearPanel();
        }
    }

    @Override
    public void setPointToCenter(int x, int y) {
        if (checkAMap()) {
            LonLatPoint lonLatPoint = MapTools.INSTANCE.fromScreenLocation(new Point(x, y));
            mAMap.setCenter(lonLatPoint);
        }
    }

    @Override
    public void setTouchPoiEnable(boolean touchPoiEnable) {
        if (checkAMap()) {
            mAMap.setTouchPoiEnable(touchPoiEnable);
        }
    }

    @Override
    public void setTrafficEnable(boolean enable) {
        if (checkAMap()) {
            mAMap.setTraffic(enable);
        }
    }

    @Override
    public void showBuildings(boolean enabled) {
        if (checkAMap()) {
            mAMap.showBuildings(enabled);
        }
    }

    @Override
    public void showIndoorMap(boolean enable) {
        if (checkAMap()) {
//            mAMap.showIndoorMap( enable );
        }
    }

    @Override
    public void showMapText(boolean enable) {
        if (checkAMap()) {
            mAMap.showMapText(enable);
        }
    }

    @Override
    public void stopAnimation() {
        if (checkAMap()) {
//            mAMap.stopAnimation();
        }
    }

    @Override
    public float getScalePerPixel() {
        if (checkAMap()) {
            return mAMap.getScalePerPixel();
        }
        return 0;
    }

    @Override
    public void changeZoom(float zoom) {
        CallerLogger.INSTANCE.d(TAG, "changeZoom %s", zoom);
        if (checkAMap()) {
            mAMap.setZoom((int) zoom);
        }
    }

    @Override
    public float getZoomLevel() {
        if (checkAMap()) {
            try {
                return mAMap.getZoom();
            } catch (Exception e) {

            }
        }
        return 0;


    }

    @Override
    public IMogoPolyline addPolyline(MogoPolylineOptions options) {
        if (checkAMap()) {
            PolylineOptions polylineOptions = ObjectUtils.fromMogo(options);
            CallerLogger.INSTANCE.d(TAG, "addPolyline %s", polylineOptions.toString());
            if (polylineOptions == null) {
                return null;
            }
            Polyline polyline = null;
            if (polylineOptions.getLineWidth() > 0) {
                polyline = mAMap.drawThickLine(polylineOptions);
            } else {
                polyline = mAMap.drawLine(polylineOptions);
            }
            return new AMapPolylineWrapper(polyline, options);
        }
        return null;
    }

    @Override
    public String getMapVersion() {
        return MapAutoApi.INSTANCE.getSDKVersion();
    }

    private boolean checkAMap() {
        mAMap = mMapView.getMapAutoViewHelper();
        sAMap = mAMap;
        if (mAMap == null) {
            CallerLogger.INSTANCE.e(TAG, "自研map实例为空，请检查");
            return false;
        }
        return true;
    }

    @Override
    public float getRoadWidth(double lon, double lat, float angle, boolean isGpsLocation, boolean isRTK) {
        SinglePointRoadInfo singlePointRoadInfo = MapDataApi.INSTANCE.getSinglePointMatchRoad(lon, lat, angle, isGpsLocation, isRTK);

        return singlePointRoadInfo != null ? singlePointRoadInfo.getLaneWidth() : 0;
    }

    private Context getContext() {
        return mMapView.getContext();
    }
}