package com.example.tyre;

import android.app.ProgressDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.SystemClock;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.widget.*;
import androidx.appcompat.app.AppCompatActivity;
import com.android.hdhe.uhf.reader.UhfReader;
import com.android.hdhe.uhf.readerInterface.TagModel;
import com.example.tyre.entity.AjaxResult;
import com.example.tyre.entity.BaseCar;
import com.example.tyre.entity.BaseTyre;
import com.example.tyre.entity.EPC;
import com.example.tyre.entity.InStoreSpinnerVo;
import com.example.tyre.util.CarSelectionDialog;
import com.example.tyre.util.CommonDialog;
import com.example.tyre.util.MyUrl;
import com.example.tyre.util.SharedPreferencesUtils;
import com.example.tyre.util.Util;
import com.google.gson.Gson;
import com.google.gson.JsonSyntaxException;
import com.google.gson.reflect.TypeToken;
import com.lzy.okgo.OkGo;
import com.lzy.okgo.callback.StringCallback;
import com.lzy.okgo.model.Response;
import com.lzy.okgo.request.base.Request;
import java.lang.ref.WeakReference;
import java.util.*;
import cn.pda.serialport.Tools;
import okhttp3.MediaType;
import okhttp3.RequestBody;

public class UpActivity extends AppCompatActivity implements AdapterView.OnItemSelectedListener {

    // UI Components - 对应新 XML 的 ID
    private TextView epcText, thText; // EPC 和 胎号
    private EditText zbhEdit, carEdit, startEdit,patternDepthEdit; // 自编号、车牌、里程
    private Spinner conditionSpinner; // 轮位选择
    private Button searchBtn, confirmBtn, cancelBtn; // 搜索、确认、取消

    // RFID Manager
    private UhfReader manager;
    private boolean runFlag = true;
    private boolean startFlag = false;

    // Data Lists
    private ArrayList<EPC> listEPC;
    private ArrayList<String> listepcStr;

    // Loading Dialog
    private ProgressDialog progressDialog;
    private boolean isProcessing = false; // 标记是否正在处理请求
    // Debounce Handler for RFID Scan
    private static final long DEBOUNCE_DELAY = 500;
    private String lastScannedEpc;
//    private Handler debounceHandler = new Handler(new Handler.Callback() {
//        @Override
//        public boolean handleMessage(Message msg) {
//            if (msg.what == 1 && lastScannedEpc != null) {
//                // 延迟结束，执行查询逻辑
//                showLoadingDialog();
//                if (isInRange(lastScannedEpc, min, max)) {
//                    findCar(lastScannedEpc); // 车辆芯片
//                } else {
//                    find(lastScannedEpc); // 轮胎芯片
//                }
//                lastScannedEpc = null;
//            }
//            return true;
//        }
//    });

    // EPC Range Check (示例范围，请根据实际业务修改)
    String min = "EC0001012026010100000001"; // 左边界（包含）
    String max = "EC0001012026010100100000"; // 右边界（包含）

    private int startPosition=0;
    private List<String> locationList;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_up); // 确保使用新布局

        // 初始化视图
        initViews();

        // 初始化硬件
        manager = UhfReader.getInstance(); // 假设单例模式，根据实际情况调整
        if (manager == null) {
            Toast.makeText(this, "UHF Reader Init Failed", Toast.LENGTH_SHORT).show();
            finish();
            return;
        }

        listEPC = new ArrayList<>();
        listepcStr = new ArrayList<>();

        // 设置 Spinner 监听
        conditionSpinner.setOnItemSelectedListener(this);

        // 启动扫描线程
        Thread thread = new InventoryThread();
        thread.start();

        // 初始化工具类
        Util.initSoundPool(this);

        // 加载轮位数据
        check_spinner();

        // 默认显示加载框（如果需要预加载数据）
        // showLoadingDialog();

        Intent intent=getIntent();
        boolean dataType = intent.getBooleanExtra("dataType", false);
        locationList=new ArrayList<>(Arrays.asList("左前轮","右前轮","右内轮","右外轮","左内轮","左外轮"));
        if (dataType){
            String location = intent.getStringExtra("location");

            startPosition = locationList.indexOf(location);

            String carNo = intent.getStringExtra("carNo");
            carEdit.setText(carNo);   ;
            String licheng = intent.getStringExtra("licheng");
            startEdit.setText(licheng);   ;
        }


    }

    private void initViews() {
        // 绑定新布局中的控件
        epcText = findViewById(R.id.epc);
        thText = findViewById(R.id.th);
        zbhEdit = findViewById(R.id.zbh);
        carEdit = findViewById(R.id.car);
        startEdit = findViewById(R.id.start);
        patternDepthEdit = findViewById(R.id.patternDepth);
        conditionSpinner = findViewById(R.id.condition);
        searchBtn = findViewById(R.id.searchButton);
        confirmBtn = findViewById(R.id.confirmButton);
        cancelBtn = findViewById(R.id.back);
        // 设置按钮点击事件
        searchBtn.setOnClickListener(v -> {
            String carNo = carEdit.getText().toString().trim();
            if (carNo.isEmpty()) {
                new CommonDialog(UpActivity.this).setMessage("请输入车牌号或扫描车辆芯片！").show();
                return;
            }
            showLoadingDialog();
            car_spinner(carNo);
        });

        confirmBtn.setOnClickListener(v -> {
            String rfid = epcText.getText().toString();
            String carNo = carEdit.getText().toString();
            String mileage = startEdit.getText().toString();
            String wheel = conditionSpinner.getSelectedItem().toString();
            String selfNo = zbhEdit.getText().toString();
            String patternDepth = patternDepthEdit.getText().toString();
            // 校验逻辑
            if (rfid.isEmpty() || "请扫描或输入EPC".equals(rfid)) {
                new CommonDialog(UpActivity.this).setMessage("请扫描轮胎！").show();
                return;
            }
            if (carNo.isEmpty()) {
                new CommonDialog(UpActivity.this).setMessage("请选择安装车辆！").show();
                return;
            }
            if (mileage.isEmpty()) {
                new CommonDialog(UpActivity.this).setMessage("请输入起始里程！").show();
                return;
            }
            if (wheel.isEmpty()) {
                new CommonDialog(UpActivity.this).setMessage("请选择安装轮位！").show();
                return;
            }

            // 提交数据
            up_insert(rfid, carNo, mileage, wheel, selfNo,patternDepth);
            showLoadingDialog();
        });

        cancelBtn.setOnClickListener(v -> finish());
    }

    // ---------------- RFID 扫描线程 ----------------
    class InventoryThread extends Thread {
        @Override
        public void run() {
            while (runFlag) {
                if (startFlag && !isProcessing) { // 只有非处理状态才允许扫描
                    List<TagModel> tagList = manager.inventoryRealTime();
                    if (tagList != null && !tagList.isEmpty()) {
                        // 1. 立即停止扫描标志，防止循环继续
                        startFlag = false;

                        Util.play(1, 0);
                        TagModel tag = tagList.get(0); // 只取第一个标签
                        if (tag != null) {
                            String epcStr = Tools.Bytes2HexString(tag.getmEpcBytes(), tag.getmEpcBytes().length);
                            // 2. 发送到主线程处理
                            addToList(epcStr);
                        }
                        tagList.clear();
                    }
                    try {
                        Thread.sleep(20);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    private void handleScannedTag(String epc) {
        runOnUiThread(() -> {
            if (isProcessing) return; // 二次检查

            isProcessing = true; // 锁定状态
            showLoadingDialog(); // 显示加载框，自然阻塞用户操作

            // 执行业务逻辑
            if (isInRange(epc, min, max)) {
                findCar(epc); // 内部网络请求完成后需重置 isProcessing
            } else {
                find(epc); // 内部网络请求完成后需重置 isProcessing
            }
        });
    }
    private void addToList(final String epc) {
        runOnUiThread(() -> {
            // 1. 状态锁检查：如果正在请求网络，直接无视本次扫描结果
            if (isProcessing) return;

            // 2. 更新内部列表（如果你还需要保留 listEPC 用于显示或其他逻辑）
            boolean found = false;
            for (EPC mEPC : listEPC) {
                if (epc.equals(mEPC.getEpc())) {
                    mEPC.setCount(mEPC.getCount() + 1);
                    found = true;
                    break;
                }
            }
            if (!found) {
                EPC newEPC = new EPC();
                newEPC.setEpc(epc);
                newEPC.setCount(1);
                listEPC.add(newEPC);
            }

            // 3. 进入业务逻辑处理（替代原有的 debounceHandler）
            // 这里直接调用 handleScannedTag 或者直接写逻辑
            handleScannedTag(epc);
        });
    }

    private void clearData() {
        // listEPC.clear(); // 根据实际逻辑决定是否清空，注释掉以便保留显示
        listepcStr.clear();
    }
    private void finishQuery() {
        hideLoadingDialog();
        isProcessing = false; // 解锁状态，允许下次扫描
    }
    // ---------------- 网络请求与业务逻辑 ----------------
    private void up_insert(String rfid, String carNo, String mileage, String wheel, String selfNo,String patternDepth) {
        OkGo.<String>post(MyUrl.url + "/tyre/install/PdaInstallTyre")
                .tag(this)
                .params("tyreRfid", rfid)
                .params("mileage", mileage)
                .params("carNo", carNo)
                .params("wheelPostion", wheel)
                .params("selfNo", selfNo)
                .params("patternDepth", patternDepth)
                .params("createBy", SharedPreferencesUtils.getstring("user", "admin"))
                .execute(new StringCallback() {
                    @Override
                    public void onSuccess(Response<String> response) {

                        Gson gson = new Gson();
                        try {
                            AjaxResult result = gson.fromJson(response.body(), AjaxResult.class);
                            handleResponse(result);
                        } catch (JsonSyntaxException e) {
                            Toast.makeText(UpActivity.this, "数据解析错误", Toast.LENGTH_SHORT).show();
                        }
                        finishQuery(); // 关键：处理完成
                    }

                    @Override
                    public void onError(Response<String> response) {
                        super.onError(response);
                        finishQuery();
                        Toast.makeText(UpActivity.this, "网络请求失败", Toast.LENGTH_SHORT).show();
                    }
                });
    }
    public MediaType JSON = MediaType.parse("application/json; charset=utf-8");
    /**
     * 根据车牌号查询车辆信息
     * 对应之前的 car_spinner 逻辑
     * @param carNo 车牌号
     */
    private void car_spinner(String carNo) {
        // 1. 参数校验
        if (carNo == null || carNo.trim().isEmpty()) {
            hideLoadingDialog();
            new CommonDialog(UpActivity.this).setMessage("车牌号不能为空！").show();
            return;
        }
        Map<String, String> map = new HashMap<>();
        map.put("carNo", carNo);
        // 2. 发起网络请求
        // 接口说明：通常调用车辆查询接口，传入车牌号
        OkGo.<String>post(MyUrl.url + "/tyre/car/PdaQueryCarList") // 注意：这是根据车牌查询的接口，区别于之前的 RFID 查询
                .tag(this)
                // .params("carNo", carNo) // 传递车牌号参数
                .upRequestBody(RequestBody.create(JSON, new Gson().toJson(map)))
                .execute(new StringCallback() {
                    @Override
                    public void onSuccess(Response<String> response) {
                        hideLoadingDialog();
                        String body = response.body();
                        Log.d("CarQuery", "Response: " + body);
                        Gson gson = new Gson();

                        try {
                            // 1. 将响应体解析为 JsonObject (通用 JSON 对象)
                            // 这样可以绕过 AjaxResult 类对 data 字段的 String 类型限制
                            com.google.gson.JsonObject jsonObject = gson.fromJson(body, com.google.gson.JsonObject.class);

                            // 2. 获取 code 字段 (注意：你的日志显示 code 是数字 0，但 AjaxResult 定义是 String，这里做兼容处理)
                            String code = "";
                            if (jsonObject.has("code")) {
                                // 尝试获取 code，无论是 "0" 还是 0 都能处理
                                code = jsonObject.get("code").getAsString();
                            }

                            // 3. 判断成功状态 (根据你的日志，0 代表成功)
                            if ("0".equals(code) || "200".equals(code)) {

                                // 4. 获取 data 元素
                                if (jsonObject.has("data")) {
                                    com.google.gson.JsonElement dataElement = jsonObject.get("data");

                                    // 5. 将 data 元素转换为 List<BaseCar>
                                    // 使用 TypeToken 指定泛型类型
                                    java.lang.reflect.Type type = new com.google.gson.reflect.TypeToken<List<BaseCar>>() {}.getType();
                                    List<BaseCar> carList = gson.fromJson(dataElement, type);

                                    if (carList != null && !carList.isEmpty()) {
                                        // 6. 展示弹窗列表
                                        showCarSelectionDialog(carList);
                                    } else {
                                        // 7. 无数据处理
                                        new CommonDialog(UpActivity.this).setMessage("未查询到相关车辆信息").show();
                                    }
                                }
                            } else {
                                // 业务错误处理
                                String msg = jsonObject.has("msg") ? jsonObject.get("msg").getAsString() : "未知错误";
                                new CommonDialog(UpActivity.this).setMessage(msg).show();
                            }

                        } catch (Exception e) {
                            e.printStackTrace();
                            new CommonDialog(UpActivity.this).setMessage("数据解析异常").show();
                        }
                    }

                    @Override
                    public void onError(Response<String> response) {
                        super.onError(response);
                        hideLoadingDialog();
                        handleCarQueryError("response.getMessage()");
                    }
                });
    }

    /**
     * 展示车辆选择弹窗
     * @param carList 车辆列表
     */
    private void showCarSelectionDialog(List<BaseCar> carList) {
        if (carList.size() == 1) {
            // 如果只有一辆车，直接填充，无需弹窗
            BaseCar car = carList.get(0);
            fillCarInfoToUI(car);
            //Util.play(1, 0); // 提示音
            Toast.makeText(this, "自动匹配车辆：" + car.getCarNo(), Toast.LENGTH_SHORT).show();
        } else {
            // 如果有多辆车，展示弹窗供用户选择
            // 提取车牌号列表用于显示
            List<String> licensePlates = new ArrayList<>();
            for (BaseCar car : carList) {
                licensePlates.add(car.getCarNo() != null ? car.getCarNo() : "未知车牌");
            }

            // 创建并显示弹窗
            CarSelectionDialog dialog = new CarSelectionDialog(this, licensePlates);
            dialog.setOnCarSelectedListener((selectedItem) -> {
                // selectedItem 是 Object，转成 String
                String selectedPlate = selectedItem.toString().trim();

                // 遍历列表找到对应的对象
                for (BaseCar car : carList) {
                    if (selectedPlate.equals(car.getCarNo())) {
                        fillCarInfoToUI(car);
                        break;
                    }
                }
            });
            dialog.show();
        }
    }

    /**
     * 将车辆信息填充到界面控件
     * @param car 车辆对象
     */
    private void fillCarInfoToUI(BaseCar car) {
        // 填充车牌号
        carEdit.setText(safeGetString(car.getCarNo()));
        // 如果有其他字段，例如：
        // startEdit.setText(safeGetString(car.getDefaultMileage())); // 默认里程

        // 视觉反馈
        carEdit.setTextColor(getColor(R.color.green500));
        //  Util.play(1, 0);
    }
    /**
     * 统一处理车辆查询错误（复用之前的逻辑）
     */
    private void handleCarQueryError(String errorMsg) {
        new CommonDialog(UpActivity.this).setMessage(errorMsg).show();
    }
    /**
     * 扫描到轮胎芯片后的处理逻辑
     * @param tyreRfid 扫描到的轮胎 EPC 码
     */
    private void find(String tyreRfid) {
        // 1. 前置条件校验：必须先选择轮位才能扫描轮胎
        // 这里的逻辑是：防止用户先扫轮胎后扫车，或者忘记选轮位
        // 2. UI 更新：显示扫描到的轮胎 EPC
        // 将 EPC 码显示在界面上，给用户视觉反馈
        epcText.setText(tyreRfid);
        // 3. 网络请求：查询轮胎详情
        // 调用后台接口，根据 EPC 查询轮胎档案
        OkGo.<String>post(MyUrl.url + "/tyre/tyre/pdaQueryTyreInfo")
                .tag(this)
                .params("tyreEpc", tyreRfid)
                .execute(new StringCallback() {
                    @Override
                    public void onSuccess(Response<String> response) {
                        finishQuery();
                        Gson gson = new Gson();
                        String body = response.body();
                        try {
                            // 4. 解析数据
                            // 假设后端返回标准 AjaxResult，data 字段包含 BaseTyre 对象

                            // 解析轮胎对象
                            BaseTyre tyre = gson.fromJson(body, BaseTyre.class);

                            // 5. 数据回填 (UI 更新)
                            // 将查询到的轮胎信息填充到界面控件
                            thText.setText(safeGetString(tyre.getTyreNo())); // 胎号
                            zbhEdit.setText(safeGetString(tyre.getSelfNo())); // 自编号/工厂码
                            patternDepthEdit.setText(safeGetString(tyre.getPatternDepth()));
                            // 视觉反馈：高亮显示，提示成功
                            epcText.setTextColor(getColor(R.color.green500));

                            Util.play(1, 0); // 播放成功提示音
                            Toast.makeText(UpActivity.this, "轮胎识别成功", Toast.LENGTH_SHORT).show();

                        } catch (Exception e) {
                            e.printStackTrace();
                            handleTyreError("数据解析异常");
                        }
                    }

                    @Override
                    public void onError(Response<String> response) {
                        super.onError(response);
                        hideLoadingDialog();
                        handleTyreError("网络请求失败: ");
                        // handleTyreError("网络请求失败: " + response.getMessage());
                    }
                });
    }

    /**
     * 统一处理轮胎查询错误
     * 作用：清空无效数据，防止误操作
     */
    private void handleTyreError(String errorMsg) {
        // 1. 清空轮胎相关显示
        // thText.setText("未知轮胎");
        // zbhEdit.setText("");
        epcText.setTextColor(getColor(R.color.colorAccent));
        new CommonDialog(UpActivity.this).setMessage("轮胎识别错误！").show();

    }
    /**
     * 根据车辆RFID查询车辆基本信息
     * @param carRfid 扫描到的车辆EPC码
     */
    private void findCar(String carRfid) {
        // 1. 构建请求
        OkGo.<String>post(MyUrl.url + "/tyre/car/queryCarByRfid")
                .tag(this)
                .params("rfid", carRfid) // 发送RFID查询
                .execute(new StringCallback() {
                    @Override
                    public void onSuccess(Response<String> response) {
                        hideLoadingDialog(); // 隐藏加载框
                        String body = response.body();
                        Gson gson = new Gson();
                        try {
                            // 2. 解析响应
                            // 假设后端返回的是标准的 AjaxResult 包装类，或者直接是 BaseCar JSON
                            // 这里为了健壮性，先尝试解析 BaseCar
                            BaseCar baseCar = gson.fromJson(body, BaseCar.class);
                            if (baseCar != null && baseCar.getCarNo() != null) {
                                // 3. UI 更新 - 数据回填
                                // 填充车牌号
                                carEdit.setText(safeGetString(baseCar.getCarNo()));
                                // 如果有其他字段，继续填充
                                // start.setText(safeGetString(baseCar.getDefaultMileage())); // 默认里程

                                // 视觉反馈：高亮车牌号，提示用户车辆已识别
                                carEdit.setTextColor(getColor(R.color.green500)); // 假设 colors.xml 中有定义
                                Toast.makeText(UpActivity.this, "车辆识别成功: " + baseCar.getCarNo(), Toast.LENGTH_SHORT).show();

                                // 清空轮胎显示区，准备扫描轮胎
//                                epcText.setText("车辆已识别，请扫描轮胎");
//                                thText.setText("");
//                                zbhEdit.setText("");

                            } else {
                                // 4. 数据不存在处理
                                handleCarQueryError("系统无此车辆绑定信息，请检查芯片是否损坏或未绑定！");
                            }
                            finishQuery();
                        } catch (JsonSyntaxException e) {
                            e.printStackTrace();
                            handleCarQueryError("数据解析异常，请重试");
                        }
                    }

                    @Override
                    public void onError(Response<String> response) {
                        super.onError(response);
                        handleCarQueryError("请求失败");
                        finishQuery();
                    }
                });
    }

    /**
     * 统一处理车辆查询错误
     * 作用：锁定流程，必须正确识别车辆才能继续
     */

    private String safeGetString(String value) {
        return value == null || "null".equals(value) ? "" : value;
    }

    private void handleResponse(AjaxResult result) {
        runOnUiThread(() -> {
            CommonDialog dialog = new CommonDialog(this);
            if ("200".equals(result.getCode()) || "0".equals(result.getCode())) {
                dialog.setMessage(result.getMsg()).show();
            } else {
                dialog.setMessage(result.getMsg()).show();
            }
        });
    }

    // 重置表单
    private void resetForm() {
        epcText.setText("");
        thText.setText("请扫描或输入EPC");
        zbhEdit.setText("");
        startEdit.setText("");
        // 车牌号不清空，方便连续装车
        // carEdit.setText("");
    }

    // ---------------- Spinner 数据加载 ----------------
    /**
     * 加载轮位下拉框数据
     * 对应接口：/system/dict/data/wheelPositionList
     * 对应实体：InStoreSpinnerVo (根据你上传的代码推断)
     */
    private void check_spinner() {
        // 1. 显示加载状态（如果需要，可选）
        showLoadingDialog();
        OkGo.<String>post(MyUrl.url + "/system/dict/data/wheelPositionList")
                .tag(this)
                .execute(new StringCallback() {
                    @Override
                    public void onSuccess(Response<String> response) {
                        hideLoadingDialog();
                        String body = response.body();
                        Log.d("WheelPosition", "Raw Response: " + body);

                        Gson gson = new Gson();
                        try {
                            // 2. 解析数据
                            // 根据你上传的代码，使用了 InStoreSpinnerVo
                            // 假设接口返回的是 List<InStoreSpinnerVo> 或者 包含 data 字段的 AjaxResult
                            // 这里提供两种常见场景的解析逻辑：

                            // --- 场景 A：接口直接返回 List<String> 或 List<InStoreSpinnerVo> ---
                            // 如果是直接列表，使用 TypeToken 解析
//                            List<String> tempList = gson.fromJson(body,
//                                    new TypeToken<List<String>>(){}.getType());
//
                            List<String> wheelList = gson.fromJson(body,
                                    new TypeToken<List<String>>(){}.getType());
//                            if (tempList != null && !tempList.isEmpty()) {
//                                for (InStoreSpinnerVo vo : tempList) {
//                                    // 假设 InStoreSpinnerVo 有 getDictLabel() 或类似方法
//                                    // 如果是直接 String 列表，直接 add vo 即可
//                                    wheelList.add(vo.getDictLabel());
//                                }
//                            }

                            // --- 场景 B：接口返回 AjaxResult 包装类 (如果场景 A 报错，请尝试此逻辑) ---
//                             AjaxResult result = gson.fromJson(body, AjaxResult.class);
//                             if (result.getCode().equals("200")) {
//                                 tempList = gson.fromJson(gson.toJson(result.getData()),
//                                         new TypeToken<List<InStoreSpinnerVo>>(){}.getType());
//                                 // ... 后续填充逻辑同上
//                             }

                            // 3. 绑定适配器
                            if (wheelList.isEmpty()) {
                                wheelList.add("未获取到轮位数据");
                            }

                            // 创建适配器 (Simple Spinner Item 样式)
                            ArrayAdapter<String> adapter = new ArrayAdapter<>(UpActivity.this,
                                    android.R.layout.simple_spinner_item, wheelList);
                            adapter.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item);

                            // 绑定到 Spinner
                            conditionSpinner.setAdapter(adapter);
                            conditionSpinner.setSelection(startPosition);
                        } catch (JsonSyntaxException e) {
                            e.printStackTrace();
                            showErrorDialog("轮位数据解析失败");
                        }
                    }

                    @Override
                    public void onError(Response<String> response) {
                        super.onError(response);
                        hideLoadingDialog();
                        showErrorDialog("轮位数据加载失败");
                        //showErrorDialog("轮位数据加载失败: " + response.getMessage());
                    }
                });
    }

    // 通用错误处理
    private void showErrorDialog(String msg) {
        new CommonDialog(UpActivity.this).setMessage(msg).show();
    }

    // ---------------- 生命周期与广播 ----------------
    @Override
    protected void onResume() {
        super.onResume();
        registerReceiver();
        startFlag = false; // 开启扫描
    }

    @Override
    protected void onPause() {
        super.onPause();
        startFlag = false; // 关闭扫描
        unregisterReceiver();
    }

    @Override
    protected void onDestroy() {
        runFlag = false;
        super.onDestroy();
    }

    private void registerReceiver() {
        IntentFilter filter = new IntentFilter();
        filter.addAction("android.rfid.FUN_KEY");
        filter.addAction("android.intent.action.FUN_KEY");
        registerReceiver(keyReceiver, filter);
    }

    private void unregisterReceiver() {
        try {
            unregisterReceiver(keyReceiver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    private BroadcastReceiver keyReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if ("android.rfid.FUN_KEY".equals(intent.getAction()) || "android.intent.action.FUN_KEY".equals(intent.getAction())) {
                int keyCode = intent.getIntExtra("keyCode", 0);
                boolean keyDown = intent.getBooleanExtra("keydown", false);
                if (keyDown && keyCode == KeyEvent.KEYCODE_F5) {
                    // 只有不在处理中，才允许开启扫描
                    if (!isProcessing) {
                        startFlag = true;
                        // 清除上次扫描的显示（可选）
                        //epcText.setText("扫描中...");
                    }
                }
            }
        }
    };



    private void showLoadingDialog() {
        if (progressDialog == null) {
            progressDialog = new ProgressDialog(this);
            progressDialog.setMessage("数据加载中...");
            progressDialog.setCancelable(false);
        }
        if (!progressDialog.isShowing()) {
            progressDialog.show();
        }
    }

    private void hideLoadingDialog() {
        if (progressDialog != null && progressDialog.isShowing()) {
            progressDialog.dismiss();
        }
    }

    // Spinner 选中事件 (用于显示选中的轮位)
    @Override
    public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
        if (parent.getId() == R.id.condition) {
            // 在实际应用中，这里可能需要更新一个隐藏的变量存储轮位ID
            // ((TextView) findViewById(R.id.azlw)).setText(parent.getItemAtPosition(position).toString());
        }
    }

    @Override
    public void onNothingSelected(AdapterView<?> parent) {
        // Do nothing
    }
    /**
     * 判断 EPC 是否在指定的车辆范围内 (十六进制字符串比较)
     * 注意：此方法针对的是完整的 EPC 码字符串比较，而非简单的前缀匹配
     *
     * @param epc  扫描到的 EPC 码
     * @param min  车辆范围最小值 (包含)
     * @param max  车辆范围最大值 (包含)
     * @return true: 是车辆, false: 是轮胎
     */
    private boolean isInRange(String epc, String min, String max) {
        if (epc == null || min == null || max == null) {
            return false;
        }

        // 去除可能的空格并转大写，保证比较一致性
        epc = epc.trim().toUpperCase();
        min = min.trim().toUpperCase();
        max = max.trim().toUpperCase();

        // 逻辑：如果 epc 字符串在 min 和 max 之间（包含），则认为是车辆
        // compareTo 返回值：0相等，1大于，-1小于
        boolean isGreaterOrEqual = epc.compareTo(min) >= 0;
        boolean isLessOrEqual = epc.compareTo(max) <= 0;

        return isGreaterOrEqual && isLessOrEqual;
    }
}