package safeluck.drive.evaluation.fragment;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Path;
import android.os.Bundle;
import android.os.Handler;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.appcompat.widget.Toolbar;


import com.anyun.exam.lib.MyLog;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;


import org.json.JSONException;
import org.json.JSONObject;

import java.lang.reflect.Type;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

import me.yokeyword.fragmentation.SupportFragment;
import safeluck.drive.evaluation.Constant;
import safeluck.drive.evaluation.R;
import safeluck.drive.evaluation.bean.ExamMap;
import safeluck.drive.evaluation.bean.RealTimeCarPos;
import safeluck.drive.evaluation.cEventCenter.CEventCenter;
import safeluck.drive.evaluation.cEventCenter.ICEventListener;
import safeluck.drive.evaluation.util.CThreadPoolExecutor;
import safeluck.drive.evaluation.util.FileUtil;


/**
 * MyApplication2
 * Created by lzw on 2019/9/26. 15:20:58
 * 邮箱：632393724@qq.com
 * All Rights Saved! Chongqing AnYun Tech co. LTD
 */
public class MapFragment extends SupportFragment {
    private boolean isDrawing = false;
    private ICEventListener rtcmicEventListener = new ICEventListener() {
        @Override
        public void onCEvent(String topic, int msgCode, int resultCode, final Object obj) {
            if (msgCode == Constant.DEBUG_RTCM){

                CThreadPoolExecutor.runOnMainThread(new Runnable() {
                    @Override
                    public void run() {
                        Log.i(TAG, "title="+(String)obj);
                        toolbar.setTitle((String)obj);
                    }
                });
                }
        }
    };
    private ICEventListener debugTxticEventListener = new ICEventListener() {
        @Override
        public void onCEvent(String topic, int msgCode, int resultCode, final Object obj) {
            if (msgCode == Constant.DEBUG_TXT){
                CThreadPoolExecutor.runOnMainThread(new Runnable() {
                    @Override
                    public void run() {
                        Log.i(TAG, "subtitle="+(String)obj);
                        toolbar.setSubtitle((String)obj);
                    }
                });

            }
        }
    };

    public static SupportFragment newInstance() {
        return new MapFragment();
    }

    private SurfaceView mSurfaceView;
    private static final String TAG = "MapFragment";
    private SurfaceHolder holder;
    Path path = new Path();
    private Canvas canvas;
    private int x = -1;
    private int y = -1;
    private Toolbar toolbar;

    private Bitmap bmp = null;
    private Canvas canvas2 = null;
    private Paint paint = null;
    private int screen_width = 0, screen_height = 0;
    private String osd = null;
    private String osd2 = null;
    private String osd3 = null;
    private int map_id;
//    double map[][] = {{1, 1}, {10, 1}, {10, 10}, {1, 10}};
    double map[][] = {{-2.4065, 30.7090}, {-3.0759, 30.3599}, { -2.6023, 29.2578}, {-3.3316,28.9383},{-3.8247,30.0293},
        {-3.4503,30.1946}, {-2.9669,29.0981}, { -3.6962, 28.7786}, {-4.1991, 29.8640}};
//    double map[][] ;
    double car[][] = {{8.278, 1.467}, {7.2780000000000009, 1.467}, {7.2780000000000009, -1.533}, {8.278, -1.533}
            , {9.278, -1.5330000000000004}, {9.277999999999999, 1.467000000000001}};
    Gson gson;
    private LinearLayout linearLayout;//surfaceview的父容器，为了移动surfaceview而使用，因为scrollto不能移动view，
    private LinkedBlockingQueue queue = new LinkedBlockingQueue(100);
    private ExecutorService producer = Executors.newSingleThreadExecutor();
    private ExecutorService consumer = Executors.newSingleThreadExecutor();


    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.layout_mapfragment, container, false);
        gson = new Gson();
        initView(view);
        consumer.execute(new CalRunnable());
        return view;
    }
private int avaliableHeight,avalibleWidth;
    private void initView(View view) {
        toolbar = view.findViewById(R.id.toolbar);
        toolbar.setTitle("简单地图");
        toolbar.setNavigationIcon(R.drawable.ic_arrow_back_white_24dp);
        toolbar.setNavigationOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                _mActivity.onBackPressed();
            }
        });
 avaliableHeight= getResources().getDisplayMetrics().heightPixels;
avalibleWidth = getResources().getDisplayMetrics().widthPixels;
        Log.i(TAG, "initView: aliwidht="+avalibleWidth+" height="+avaliableHeight);
        mSurfaceView = view.findViewById(R.id.surfaceview);

        holder = mSurfaceView.getHolder();

        holder.addCallback(new SurfaceHolder.Callback() {
            @Override
            public void surfaceCreated(SurfaceHolder surfaceHolder) {
                Canvas canvas = surfaceHolder.lockCanvas();

                if (canvas != null) {
                    Log.d(TAG, "W = " + canvas.getWidth() + " H = " + canvas.getHeight());
                    screen_width = canvas.getWidth();
                    screen_height = canvas.getHeight();
                    surfaceHolder.unlockCanvasAndPost(canvas);

                    bmp = Bitmap.createBitmap(screen_width, screen_height, Bitmap.Config.ARGB_8888);
                    canvas2 = new Canvas(bmp);
                    canvas2.drawColor(Color.WHITE);

                    paint = new Paint();

                    paint.setTextSize(30);
                    paint.setColor(Color.BLACK);
                    paint.setStrokeWidth(1.5f);
                    paint.setAntiAlias(true);
                    paint.setStyle(Paint.Style.STROKE);

                    holder.lockCanvas();
                    canvas.drawBitmap(bmp, 0, 0, paint);
                    holder.unlockCanvasAndPost(canvas);
                }

//                new Thread(new NeedForSpeed(car, map)).start();
            }

            @Override
            public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i1, int i2) {

            }

            @Override
            public void surfaceDestroyed(SurfaceHolder surfaceHolder) {

            }
        });
    }


    class NeedForSpeed implements Runnable {
        public NeedForSpeed(double[][] car, double[][] map) {
            DrawMap(map, car);
        }

        @Override
        public void run() {

//            double car[][] = {{3,3}, {8,3}, {8,8}, {3,8}};


            DrawMap(map, car);
        }
    }

    public void DrawMap(final double[][] map, final double[][] car) {
        if (canvas2 == null || bmp == null) {
            return;
        }
//        _mActivity.runOnUiThread(new Runnable() {
//            @Override
//            public void run() {
                double base_x = 100, base_y = 100;
                double max_x = 0, min_x = 0, max_y = 0, min_y = 0;

                Log.d(TAG, "DrawMap map size " + map.length + " car size " + car.length);

                for (int i = 0; i < map.length; i++) {
                    if (i == 0) {
                        max_x = map[0][0];
                        min_x = map[0][0];
                        max_y = map[0][1];
                        min_y = map[0][1];
                    } else {
                        if (max_x < map[i][0]) {
                            max_x = map[i][0];
                        }
                        if (min_x > map[i][0]) {
                            min_x = map[i][0];
                        }
                        if (max_y < map[i][1]) {
                            max_y = map[i][1];
                        }
                        if (min_y > map[i][1]) {
                            min_y = map[i][1];
                        }
                    }
                }

                Log.d(TAG, "DrawMap max_x " + max_x + " max_y " + max_y + " min_x " + min_x + " min_y " + min_y);

                for (int i = 0; i < car.length; i++) {
                    if (max_x < car[i][0]) {
                        max_x = car[i][0];
                    }
                    if (min_x > car[i][0]) {
                        min_x = car[i][0];
                    }
                    if (max_y < car[i][1]) {
                        max_y = car[i][1];
                    }
                    if (min_y > car[i][1]) {
                        min_y = car[i][1];
                    }
                }

                Log.d(TAG, "DrawMap max_x " + max_x + " max_y " + max_y + " min_x " + min_x + " min_y " + min_y);

                long scale_x = Math.round(500 / (max_x - min_x));
                long scale_y = Math.round(300 / (max_y - min_y));

                if (scale_x >= scale_y) {
                    scale_x = scale_y;
                } else {
                    scale_y = scale_x;
                }

                Log.d(TAG, "DrawMap scale_x " + scale_x + " scale_y " + scale_y);

                canvas2.drawColor(Color.WHITE);

                paint.setStyle(Paint.Style.STROKE);

                Path path = new Path();

                if (map.length != 9) {
                    Log.d(TAG, "DrawMap X = " + String.format("%f", (float) (base_x + (map[0][0] - min_x) * scale_x)) + " Y = " + String.format("%f", (float) (base_y + (map[0][1] - min_y) * scale_y)));
                    path.moveTo((float) (base_x + (map[0][0] - min_x) * scale_x), (float) (base_y + (map[0][1] - min_y) * scale_y));
                    for (int i = 1; i < map.length; i++) {
                        Log.d(TAG, "DrawMap to X = " + (float) (base_x + (map[i][0] - min_x) * scale_x) + " Y = " + (float) (base_y + (map[i][1] - min_y) * scale_y));
                        path.lineTo((float) (base_x + (map[i][0] - min_x) * scale_x), (float) (base_y + (map[i][1] - min_y) * scale_y));
                    }
                    path.close();
                } else {
                    path.moveTo((float) (base_x + (map[0][0] - min_x) * scale_x), (float) (base_y + (map[0][1] - min_y) * scale_y));
                    path.lineTo((float) (base_x + (map[8][0] - min_x) * scale_x), (float) (base_y + (map[8][1] - min_y) * scale_y));

                    path.moveTo((float) (base_x + (map[2][0] - min_x) * scale_x), (float) (base_y + (map[2][1] - min_y) * scale_y));
                    path.lineTo((float) (base_x + (map[1][0] - min_x) * scale_x), (float) (base_y + (map[1][1] - min_y) * scale_y));

                    path.moveTo((float) (base_x + (map[3][0] - min_x) * scale_x), (float) (base_y + (map[3][1] - min_y) * scale_y));
                    path.lineTo((float) (base_x + (map[4][0] - min_x) * scale_x), (float) (base_y + (map[4][1] - min_y) * scale_y));

                    path.moveTo((float) (base_x + (map[6][0] - min_x) * scale_x), (float) (base_y + (map[6][1] - min_y) * scale_y));
                    path.lineTo((float) (base_x + (map[5][0] - min_x) * scale_x), (float) (base_y + (map[5][1] - min_y) * scale_y));

                    path.moveTo((float) (base_x + (map[7][0] - min_x) * scale_x), (float) (base_y + (map[7][1] - min_y) * scale_y));
                    path.lineTo((float) (base_x + (map[8][0] - min_x) * scale_x), (float) (base_y + (map[8][1] - min_y) * scale_y));
                }
                canvas2.drawPath(path, paint);

                path.moveTo((float) (base_x + (car[0][0] - min_x) * scale_x), (float) (base_y + (car[0][1] - min_y) * scale_y));
                for (int i = 1; i < car.length; i++)
                    path.lineTo((float) (base_x + (car[i][0] - min_x) * scale_x), (float) (base_y + (car[i][1] - min_y) * scale_y));
                path.close();
                canvas2.drawPath(path, paint);

                paint.setStyle(Paint.Style.FILL_AND_STROKE);

                if (osd != null) {
                    Path pathText = new Path();
                    pathText.moveTo(10, 170);
                    pathText.lineTo(700, 170);
                    canvas2.drawTextOnPath(osd, pathText, 0, 0, paint);//逆时针生成
                }

                if (osd2 != null) {
                    Path pathText = new Path();
                    pathText.moveTo(10, 30);
                    pathText.lineTo(700, 30);
                    canvas2.drawTextOnPath(osd2, pathText, 0, 0, paint);//逆时针生成
                }
//                if (osd3 != null) {
//                    Path pathText = new Path();
//                    pathText.moveTo(10, 240);
//                    pathText.lineTo(700, 130);
//                    canvas2.drawTextOnPath(osd2, pathText, 0, 0, paint);//逆时针生成
//                }

                // 提交画布
                Canvas canvas = holder.lockCanvas();
                if (canvas != null){

                    canvas.drawBitmap(bmp, 0, 0, paint);
                    holder.unlockCanvasAndPost(canvas);
                }
//            }
//        });
    }

    public void CCL(final int c, final int who) {
        _mActivity.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                /*if (canvas2 != null && bmp != null) {
                    if (c == 0)
                        canvas2.drawColor(Color.GREEN);
                    else
                        canvas2.drawColor(Color.GRAY);
                    // 提交画布
                    Canvas canvas = holder.lockCanvas();
                    canvas.drawBitmap(bmp, 0, 0, paint);
                    holder.unlockCanvasAndPost(canvas);
                }*/
//                Button button;
//                if (who == 0) {
//                    button = findViewById(R.id.sample_button);
//                } else {
//                    button = findViewById(R.id.net_button);
//                }
//
//                if (c == 0)
//                    button.setBackgroundColor(Color.GREEN);
//                else
//                    button.setBackgroundColor(Color.RED);
            }
        });
    }

    int line = 0;
    int map_line = 0;
    private StringBuffer stringBuffer = new StringBuffer();
    class MessageRemoteService{
        public int msgCode;
        public String json;

        public MessageRemoteService(int msgCode, Object obj) {
            this.json = (String) obj;
            this.msgCode = msgCode;
        }
    }
    private ICEventListener icEventListener = new ICEventListener() {
        @Override
        public void onCEvent(String topic, final int msgCode, int resultCode, final Object obj) {


            producer.execute(new Runnable() {
                @Override
                public void run() {
                    queue.offer(new MessageRemoteService(msgCode,obj));
                }
            });


        }
    };
    boolean flag = true;
    class CalRunnable implements Runnable{

        private String json;
        private int cmd;

        @Override
        public void run() {
            while (flag){
                MessageRemoteService messageRemoteService = (MessageRemoteService) queue.peek();
                if (messageRemoteService == null){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                messageRemoteService = (MessageRemoteService) queue.poll();
                if (messageRemoteService != null){
                    this.cmd = messageRemoteService.msgCode;
                    this.json = messageRemoteService.json;
                    MyLog.i(TAG, json);


                    RealTimeCarPos timeCarPos = gson.fromJson((String) json, RealTimeCarPos.class);
                    List<Double> points = timeCarPos.getPoint();
                    switch (timeCarPos.getMove()){
                        case 0:
                            osd2 = "停车";
                            break;
                        case 1:
                            osd2 = "前进";
                            break;
                        case -1:
                            osd2 = "后退";
                            break;
                    }
                    osd="方向角"+String.valueOf(timeCarPos.getHeading());
                    line = 0;
                    map_line = 0;

                    for (int i = 0; i < points.size(); i++) {
                        if ((i % 2) == 0) {
                            car[line][0] = points.get(i);
                        } else {
                            double value = 0 - points.get(i);
                            Log.i(TAG, "onCEvent: 新值=" + value + " 位置：" + i);
                            car[line][1] = value;
                            line++;
                        }

                    }
                    map_id = timeCarPos.getMap_id();
//            1 - 倒库
//            2 - 坡起
//            3 - 侧方停车
//            4 - 曲线行驶
//            5 - 直角转弯


                    StringBuffer buffer = FileUtil.readAssetTxtFile(_mActivity,Constant.MAP);
                    Type type = new TypeToken<List<ExamMap>>(){}.getType();
                    if (buffer != null){
                        List<ExamMap> examMaps = gson.fromJson(buffer.toString().trim(), type);



                        for (int i = 0; i < examMaps.size(); i++) {
                            ExamMap examMap = examMaps.get(i);
                            if (map_id == examMap.getId()){
                                List<ExamMap.PointBean> pointBeanList = examMap.getPoint();

                                for(int j=0; j<pointBeanList.size();j++){
                                    List<Double> xys = pointBeanList.get(j).getXy();
                                    if(j==0){
                                        map = new double[xys.size()/2][2];
                                    }else{
                                        MyLog.i(TAG,"暂时还不支持曲线");
                                        break;
                                    }

                                    for (int k=0; k<xys.size();k++){
                                        if ((k % 2) == 0) {
                                            map[map_line][0] = xys.get(k);
                                        } else {
                                            double value = 0 - xys.get(k);
                                            Log.i(TAG, "onCEvent: map新值=" + value + " 位置：" + i);
                                            map[map_line][1] = value;
                                            map_line++;
                                        }
                                    }

                                }
                                break;
                            }
                        }
                    }
                    DrawMap(map,car);
                }

            }

        }
    }
    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        CEventCenter.onBindEvent(true, icEventListener, Constant.REAL_TIME_POS_CAR_TOPIC);
        CEventCenter.onBindEvent(true, rtcmicEventListener, Constant.BIND_RTCM_TOPIC);
        CEventCenter.onBindEvent(true, debugTxticEventListener, Constant.BIND_DEBUG_TXT);
    }

    @Override
    public void onDetach() {
        super.onDetach();
        flag = false;
        producer.shutdown();
        consumer.shutdown();
        CEventCenter.onBindEvent(false, icEventListener, Constant.REAL_TIME_POS_CAR_TOPIC);
        CEventCenter.onBindEvent(false, icEventListener, Constant.BIND_RTCM_TOPIC);
        CEventCenter.onBindEvent(false, icEventListener, Constant.BIND_DEBUG_TXT);
    }
}