package com.khronos.vulkan_samples;


import android.Manifest;
import android.content.pm.PackageManager;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.util.Log;
import android.view.WindowManager;
import android.widget.Toast;

import androidx.annotation.NonNull;
import androidx.camera.core.AspectRatio;
import androidx.camera.core.CameraSelector;
import androidx.camera.core.ImageAnalysis;
import androidx.camera.core.ImageProxy;
import androidx.camera.lifecycle.ProcessCameraProvider;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;

import com.google.androidgamesdk.GameActivity;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.mediapipe.tasks.components.containers.NormalizedLandmark;
import com.google.mediapipe.tasks.vision.core.RunningMode;
import com.google.mediapipe.tasks.vision.facelandmarker.FaceLandmarker;
import com.google.mediapipe.tasks.vision.facelandmarker.FaceLandmarkerResult;

import org.jetbrains.annotations.NotNull;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MainActivity extends GameActivity implements FaceLandmarkerHelper.LandmarkerListener, CameraDataFetcher.CameraDataCallback {
    private ProcessCameraProvider cameraProvider;
    private void initCamera(){
        backgroundExecutor = Executors.newSingleThreadExecutor();
        if (hasCameraPermission()) {
            startCamera();
        } else {
            requestCameraPermission();
        }
    }

    private void detectFace(ImageProxy imageProxy) {
        faceLandmarkerHelper.detectLiveStream(
                imageProxy,false
        );
    }

    private Handler handler = new Handler(Looper.getMainLooper());
    private Runnable cameraDataRunnable;
    private static final long INTERVAL = 1000; // 5秒间隔

    @Override
    protected void onCreate(Bundle savedInstanceState) {

//        if (!AssetsCopyUtil.isExternalStorageAvailable()) {
//            Log.w(TAG, "External storage not available, skipping assets copy");
//            return;
//        }

        //AssetsCopyUtil.copyAssetsToAppFiles(this, "assets");
        //AssetsCopyUtil.copyAssetsToAppFiles(this, "shaders");


        String native_lib_name = getResources().getString(R.string.native_lib_name);
        try {
            System.loadLibrary(native_lib_name);
        } catch (UnsatisfiedLinkError e) {
            Toast.makeText(getApplicationContext(), "Native code library failed to load.", Toast.LENGTH_SHORT).show();
        }
        String[] argArray = new String[2];
        argArray[0] = "sample";
        argArray[1] = "texture_loading";//"hello_triangle";
        sendArgumentsToPlatform(argArray);
        super.onCreate(savedInstanceState);

        // 隐藏状态栏
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);

        initCamera();

        backgroundExecutor.execute(new Runnable() {
            @Override
            public void run() {
                faceLandmarkerHelper = new FaceLandmarkerHelper(
                        0.5f,
                        0.5f,
                         0.5f,
                        1,
                        0,
                        RunningMode.LIVE_STREAM,
                        MainActivity.this,
                        MainActivity.this
                        );
            }
        });

        // 初始化Runnable
//        cameraDataRunnable = new Runnable() {
//            @Override
//            public void run() {
//                fetchCameraData();
//                handler.postDelayed(this, INTERVAL); // 再次调度
//            }
//        };

        // 开始周期性调用
//        startPeriodicFetching();


        Log.i("MainActivity", "onCreate: ");
    }

    boolean canFetch = true;
    private void fetchCameraData() {
        if(canFetch)
        {
            CameraDataFetcher.fetchCameraData("http://175.178.100.240:5000/data", MainActivity.this);
            canFetch = false;
        }
    }
    private void startPeriodicFetching() {
        handler.postDelayed(cameraDataRunnable, INTERVAL);
    }

    private void stopPeriodicFetching() {
        handler.removeCallbacks(cameraDataRunnable);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        stopPeriodicFetching(); // 避免内存泄漏
    }

    private boolean hasCameraPermission() {
        return ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
                == PackageManager.PERMISSION_GRANTED;
    }

    private void requestCameraPermission() {
        ActivityCompat.requestPermissions(this,
                new String[]{Manifest.permission.CAMERA},
                REQUEST_CAMERA_PERMISSION);
    }

    private static final int REQUEST_CAMERA_PERMISSION = 1001;
    ImageAnalysis imageAnalyzer;
    ExecutorService backgroundExecutor;
    FaceLandmarkerHelper faceLandmarkerHelper;

    private void startCamera() {
        ListenableFuture<ProcessCameraProvider> cameraProviderFuture =
                ProcessCameraProvider.getInstance(this);

        cameraProviderFuture.addListener(() -> {
            try {
                cameraProvider = cameraProviderFuture.get();

                CameraSelector cameraSelector = new CameraSelector.Builder()
                        .requireLensFacing(CameraSelector.LENS_FACING_BACK)
                        .build();

                imageAnalyzer = new ImageAnalysis.Builder()
                        .setTargetAspectRatio(AspectRatio.RATIO_4_3)
                        .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
                        .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_RGBA_8888)
                        .build();


                imageAnalyzer.setAnalyzer(backgroundExecutor, new ImageAnalysis.Analyzer() {

                    @Override
                    public void analyze(@NonNull ImageProxy image) {
                        try {
                            //Log.d("Camera", "Received image: " + image.getWidth() + "x" + image.getHeight());
                            processImageForVulkan(image);
                            detectFace(image);
                        } finally {
                            //image.close(); // 确保在这里关闭
                            //Log.d("Camera", "Image closed, ready for next frame");
                        }
                    }
                });

                cameraProvider.bindToLifecycle(this, cameraSelector, imageAnalyzer);

            } catch (ExecutionException | InterruptedException e) {
                Log.e("MainActivity", "Error starting camera: " + e.getMessage());
            }
        }, ContextCompat.getMainExecutor(this));
    }


    private void processImageForVulkan(ImageProxy image) {
        // 获取图像信息
        int width = image.getWidth();
        int height = image.getHeight();
        int format = image.getFormat();

        // 获取图像数据平面
        ImageProxy.PlaneProxy[] planes = image.getPlanes();

        // 对于 RGBA_8888 格式，通常只有一个平面
        if (planes.length > 0) {
            ImageProxy.PlaneProxy plane = planes[0];
            ByteBuffer buffer = plane.getBuffer();
            int rowStride = plane.getRowStride();
            int pixelStride = plane.getPixelStride();

            // 调用 Native 方法处理图像
            processImageNative(buffer, width, height, format,
                    rowStride, pixelStride, image.getImageInfo().getRotationDegrees());
        }
    }

    // Native 方法
    private native void processImageNative(ByteBuffer buffer, int width, int height,
                                           int format, int rowStride, int pixelStride,
                                           int rotation);


    private static final int REQUEST_CODE_PERMISSIONS = 1001;
    private static final String[] REQUIRED_PERMISSIONS = new String[]{Manifest.permission.CAMERA};
    private static final String TAG = "MainActivity";

    private boolean allPermissionsGranted() {
        for (String permission : REQUIRED_PERMISSIONS) {
            if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
                return false;
            }
        }
        return true;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == REQUEST_CODE_PERMISSIONS) {
            if (allPermissionsGranted()) {
                startCamera();
            } else {
                Log.e(TAG, "Permissions not granted by the user.");
                finish(); // Close the activity if permission is denied
            }
        }
    }

    private native void sendArgumentsToPlatform(String[] args);

    @Override
    public void onError(@NotNull String error, int errorCode) {
        Log.e(TAG, "onError: Face Error");
    }

    private ByteBuffer nativeBuffer = null;
    float[] points = new float[480 * 3];


    public class Vector {
        public float x, y, z;

        public Vector(float x, float y, float z) {
            this.x = x;
            this.y = y;
            this.z = z;
        }
    }

    public static String toObjString(ArrayList<Vector> vertices, ArrayList<Integer> triangleIndices) {
        StringBuilder sb = new StringBuilder();

        // 写入顶点数据 (v x y z)
        for (Vector v : vertices) {
            sb.append(String.format("v %.6f %.6f %.6f\n", v.x, v.y, v.z));
        }

        // 写入面数据 (f i1 i2 i3)，OBJ索引从1开始，因此每个索引+1
        int size = triangleIndices.size();
        for (int i = 0; i < size; i += 3) {
            if (i + 2 < size) {
                int i1 = triangleIndices.get(i) + 1;
                int i2 = triangleIndices.get(i + 1) + 1;
                int i3 = triangleIndices.get(i + 2) + 1;
                sb.append(String.format("f %d %d %d\n", i1, i2, i3));
            } else {
                // 如果剩余索引不足3个，说明数据不完整
                System.err.println("Warning: Incomplete triangle face at the end of index list.");
            }
        }

        return sb.toString();
    }

    @Override
    public void onResults(FaceLandmarkerHelper.@NotNull ResultBundle resultBundle) {
        FaceLandmarkerResult faceLandmarkerResult = resultBundle.getResult();
        int height = resultBundle.getInputImageHeight();
        int width = resultBundle.getInputImageWidth();
        int bufferSize = 480 * 3 * 4;

        if(nativeBuffer == null)
        {
            // 创建直接ByteBuffer（在native内存中）
            nativeBuffer = ByteBuffer.allocateDirect(bufferSize);
            nativeBuffer.order(ByteOrder.nativeOrder());
        }



//        ArrayList<Vector> vertexs = new ArrayList<>();
//        ArrayList<Integer> triangle_index = new ArrayList<>();
//
//        for (var conn : FaceLandmarker.FACE_LANDMARKS_TESSELATION) {
//            triangle_index.add(conn.start());
//        }


        //StringBuilder sb = new StringBuilder();
        //sb.append("[");

        int index = 0;
        // Iterate through each detected face
        for (List<NormalizedLandmark> faceLandmarks : faceLandmarkerResult.faceLandmarks()) {
            //should be 1

            int arrayIndex = 0;
            for (NormalizedLandmark p : faceLandmarks)
            {
                //sb.append("[");
                points[arrayIndex++] = p.x();
                //sb.append(""+p.x()+",");
                points[arrayIndex++] = p.y();
                //sb.append(""+p.y()+",");
                points[arrayIndex++] = p.z() * z_rate;
                //sb.append(""+p.z());
                //vertexs.add(new Vector(p.x(), p.y(), p.z()));
                //sb.append("],");
                index++;
            }
        }

        //sb.append("]");
        //String objStr = sb.toString();

        //String objStr = toObjString(vertexs, triangle_index);

        // 转换为FloatBuffer并填充数据
        FloatBuffer floatBuffer = nativeBuffer.asFloatBuffer();
        floatBuffer.put(points);
        floatBuffer.position(0);
        passDataToNative(nativeBuffer, index, width, height);
    }

    public float z_rate = -1.0f;

    public native void passDataToNative(ByteBuffer buffer, int pointCount, int width, int height);
    public native void upDateCameraData(float fov, float x, float y, float z, float sx, float sy, float sz, float rotx, float roty, float rotz,
                                        float camx, float camy, float camz, float dashSize, float gapSize, float dashOffset, float uAASize);

    @Override
    public void onSuccess(CameraDataFetcher.CameraData data) {
        z_rate = data.z_rate;
        upDateCameraData(data.fov, data.x, data.y, data.z, data.sx, data.sy, data.sz,
                data.rotx, data.roty, data.rotz,
                data.camx, data.camy, data.camz,
                data.dashSize, data.gapSize, data.dashOffset, data.uAASize
        );
        canFetch = true;
        Log.e(TAG, "GetCameraData " + data.toString());
    }

    @Override
    public void onError(String errorMessage) {
        Log.e(TAG, "GetCameraData Error");
        canFetch = true;
    }
}