// NFC工具类 - 优化版，适配安卓平板环境
// 包路径定义
const package_TECH_DISCOVERED = 'android.nfc.action.TECH_DISCOVERED';
const package_TAG_DISCOVERED = 'android.nfc.action.TAG_DISCOVERED';
const package_NDEF_DISCOVERED = 'android.nfc.action.NDEF_DISCOVERED';

// 全局变量
let nfcAdapter = null; // NFC适配器实例
let mainActivity = null; // 主Activity实例
let pendingIntent = null; // 用于NFC前台调度的PendingIntent
let currentPromiseResolve = null; // 当前Promise的resolve函数引用
let currentPromiseReject = null; // 当前Promise的reject函数引用
let isNFCInitialized = false; // NFC初始化状态
let noNFC = false; // 无NFC功能标识
let timeoutId = null; // 超时定时器ID
let isListening = false; // 是否正在监听状态

// 支持的NFC技术列表 - 优化以适配更多平板设备
let techListsArray = [
    ['android.nfc.tech.IsoDep'],
    ['android.nfc.tech.NfcA'],
    ['android.nfc.tech.NfcB'],
    ['android.nfc.tech.NfcF'],
    ['android.nfc.tech.NfcV'],
    ['android.nfc.tech.NdefFormatable'],
    ['android.nfc.tech.MifareClassic'],
    ['android.nfc.tech.MifareUltralight']
];

/**
 * NFC工具类 - 处理安卓平台NFC卡片读取
 */
export default {
    /**
     * 初始化NFC功能并监听NFC状态
     * @param {number} timeoutMs - 超时时间（毫秒），默认30秒
     * @returns {Promise<string>} 返回读取到的NFC卡片ID
     */
    listenNFCStatus: function(timeoutMs = 30000) {
        console.log("NFC: 开始监听NFC状态，超时时间:" + timeoutMs + "ms");

        // 先停止之前的监听（如果存在）
        this.stopNFCListening();

        // 使用Promise封装NFC读取过程
        return new Promise((resolve, reject) => {
            try {
                // 保存当前Promise的引用
                currentPromiseResolve = resolve;
                currentPromiseReject = reject;
                isListening = true;

                // 获取主Activity
                if (!mainActivity) {
                    mainActivity = plus.android.runtimeMainActivity();
                }

                // 初始化NFC适配器
                if (!this._initializeNFC()) {
                    // 如果初始化失败且是因为设备不支持NFC或NFC未开启，则直接reject
                    if (noNFC) {
                        reject(new Error('设备不支持NFC或NFC功能未开启'));
                    } else {
                        reject(new Error('NFC初始化失败'));
                    }
                    return;
                }

                // 设置NFC前台调度
                if (!this._setupForegroundDispatch()) {
                    reject(new Error('NFC前台调度设置失败'));
                    return;
                }

                // 设置超时
                timeoutId = setTimeout(() => {
                    if (isListening && currentPromiseReject === reject) {
                        console.log('NFC: 读取超时');
                        const errorMsg = 'NFC读取超时，请重试';
                        this._cleanupResources();
                        reject(new Error(errorMsg));
                    }
                }, timeoutMs);

            } catch (error) {
                console.error('NFC: 监听NFC状态时发生错误:', error);
                this._cleanupResources();
                reject(new Error('NFC操作异常: ' + error.message));
            }
        });
    },

    /**
     * 停止NFC监听
     */
    stopNFCListening: function() {
        console.log('NFC: 停止监听NFC状态');
        this._cleanupResources();

        if (currentPromiseReject) {
            const reject = currentPromiseReject;
            currentPromiseReject = null;
            // 不抛出错误，而是安静地停止监听
        }
    },

    /**
     * 清理NFC资源
     * @private
     */
    _cleanupResources: function() {
        try {
            // 清除超时定时器
            if (timeoutId) {
                clearTimeout(timeoutId);
                timeoutId = null;
            }

            // 禁用前台调度
            if (nfcAdapter && mainActivity) {
                try {
                    nfcAdapter.disableForegroundDispatch(mainActivity);
                    console.log('NFC: 已禁用前台调度');
                } catch (e) {
                    console.warn('NFC: 禁用前台调度时出错:', e);
                }
            }

            // 重置状态
            isListening = false;
            currentPromiseResolve = null;
            currentPromiseReject = null;
        } catch (error) {
            console.error('NFC: 清理资源时发生错误:', error);
        }
    },

    /**
     * 初始化NFC适配器
     * @private
     * @returns {boolean} 初始化是否成功
     */
    _initializeNFC: function() {
        try {
            // 如果已经初始化，则直接返回成功
            if (isNFCInitialized && nfcAdapter) {
                return true;
            }

            // 导入必要的类
            const NfcAdapter = plus.android.importClass('android.nfc.NfcAdapter');

            // 获取NFC适配器实例
            nfcAdapter = NfcAdapter.getDefaultAdapter(mainActivity);

            // 检查设备是否支持NFC
            if (nfcAdapter == null) {
                console.warn('NFC: 设备不支持NFC');
                noNFC = true;
                return false;
            }

            // 检查NFC是否已启用
            if (!nfcAdapter.isEnabled()) {
                console.warn('NFC: NFC功能未启用');
                noNFC = true;
                return false;
            }

            // 设置初始化状态为成功
            isNFCInitialized = true;
            noNFC = false;
            console.log('NFC: 初始化成功');
            return true;
        } catch (error) {
            console.error('NFC: 初始化失败:', error);
            return false;
        }
    },

    /**
     * 设置NFC前台调度 - 优化以适配平板大屏和不同Android版本
     * @private
     * @returns {boolean} 设置是否成功
     */
    _setupForegroundDispatch: function() {
        try {
            // 导入必要的类
            const Intent = plus.android.importClass('android.content.Intent');
            const PendingIntent = plus.android.importClass('android.app.PendingIntent');
            const IntentFilter = plus.android.importClass('android.content.IntentFilter');
            const NfcAdapter = plus.android.importClass('android.nfc.NfcAdapter');

            // 创建Intent和PendingIntent
            const intent = new Intent(mainActivity, mainActivity.getClass());
            intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP);

            // 适配不同Android版本的PendingIntent标志
            let flags = PendingIntent.FLAG_UPDATE_CURRENT;

            // 检查Android版本，适配Android 12+
            try {
                const Build = plus.android.importClass('android.os.Build');
                if (Build.VERSION.SDK_INT >= 31) { // Android 12 (API 31)
                    flags = PendingIntent.FLAG_MUTABLE;
                    console.log('NFC: 检测到Android 12+，使用FLAG_MUTABLE标志');
                }
            } catch (e) {
                console.log('NFC: 无法检测Android版本，使用默认标志');
            }

            pendingIntent = PendingIntent.getActivity(mainActivity, 0, intent, flags);

            // 创建多个IntentFilter以提高平板设备上的识别率
            const ndef = new IntentFilter(package_TECH_DISCOVERED);
            const tag = new IntentFilter(package_TAG_DISCOVERED);
            const ndefDiscovered = new IntentFilter(package_NDEF_DISCOVERED);

            try {
                ndef.addDataType('*/*');
                ndefDiscovered.addDataType('*/*');
            } catch (e) {
                console.warn('NFC: 添加数据类型失败:', e);
            }

            const intentFiltersArray = [ndef, tag, ndefDiscovered];

            // 移除旧的监听器，避免重复添加
            try {
                plus.globalEvent.removeEventListener('newintent', this._handleNewIntent);
            } catch (e) {
                // 忽略错误
            }

            // 设置全局事件监听器
            plus.globalEvent.addEventListener('newintent', this._handleNewIntent.bind(this));

            // 启用前台调度 - 优化平板设备上的NFC识别
            nfcAdapter.enableForegroundDispatch(mainActivity, pendingIntent, intentFiltersArray, techListsArray);
            console.log('NFC: 前台调度设置成功，已添加多种Intent过滤器');
            return true;
        } catch (error) {
            console.error('NFC: 前台调度设置失败:', error);
            return false;
        }
    },

    /**
     * 处理新的NFC Intent - 优化以支持多种NFC Intent类型
     * @private
     */
    _handleNewIntent: function() {
        try {
            console.log('NFC: 接收到新的Intent');

            // 导入必要的类
            const NfcAdapter = plus.android.importClass('android.nfc.NfcAdapter');

            // 获取当前Intent
            const intent = mainActivity.getIntent();
            const action = intent.getAction();

            // 检查是否是NFC相关的Intent - 支持多种NFC Intent类型
            if (action === package_TECH_DISCOVERED ||
                action === package_TAG_DISCOVERED ||
                action === package_NDEF_DISCOVERED) {

                console.log('NFC: 检测到NFC卡片，动作类型:', action);

                // 读取NFC ID
                const nfcId = this._readNFCId(intent, NfcAdapter);

                // 如果成功读取到ID且Promise仍在等待，则解析Promise
                if (nfcId && currentPromiseResolve && isListening) {
                    console.log('NFC: 成功读取到ID:', nfcId);
                    const resolve = currentPromiseResolve;

                    // 清理资源
                    this._cleanupResources();

                    // 延迟解析Promise，确保资源完全清理
                    setTimeout(() => {
                        resolve(nfcId);
                    }, 100);
                }
            }
        } catch (error) {
            console.error('NFC: 处理Intent时发生错误:', error);
            if (currentPromiseReject && isListening) {
                const reject = currentPromiseReject;
                this._cleanupResources();
                reject(new Error('处理NFC数据时出错: ' + error.message));
            }
        }
    },

    /**
     * 读取NFC卡片ID - 优化以适配安卓平板
     * @private
     * @param {android.content.Intent} intent - Intent对象
     * @param {android.nfc.NfcAdapter} adapter - NfcAdapter类
     * @returns {string} NFC卡片ID的十六进制字符串
     */
    _readNFCId: function(intent, adapter) {
        try {
            // 获取NFC ID字节数组 - 尝试多种方式获取
            let bytesId = null;

            // 主要方式
            bytesId = intent.getByteArrayExtra(adapter.EXTRA_ID);

            // 如果失败，尝试其他方式
            if (!bytesId || bytesId.length === 0) {
                try {
                    // 获取标签对象
                    const tag = intent.getParcelableExtra(adapter.EXTRA_TAG);
                    if (tag) {
                        bytesId = tag.getId();
                        console.log('NFC: 通过Tag对象获取ID');
                    }
                } catch (e) {
                    console.warn('NFC: 尝试通过Tag对象获取ID失败:', e);
                }
            }

            if (!bytesId || bytesId.length === 0) {
                console.warn('NFC: 未读取到ID字节数组');
                return null;
            }

            // 转换为十六进制字符串
            const hexId = this.byteArrayToHexString(bytesId);
            console.log('NFC: 读取到ID:', hexId, '长度:', bytesId.length);

            // 尝试获取更多卡片信息，增强平板使用体验
            try {
                const tag = intent.getParcelableExtra(adapter.EXTRA_TAG);
                if (tag) {
                    const Tag = plus.android.importClass('android.nfc.Tag');
                    const techList = tag.getTechList();
                    console.log('NFC: 卡片支持的技术:', techList);
                }
            } catch (e) {
                console.log('NFC: 获取卡片技术信息失败:', e);
            }

            return hexId;
        } catch (error) {
            console.error('NFC: 读取ID时发生错误:', error);
            return null;
        }
    },

    /**
     * 检查NFC是否可用
     * @returns {Object} 包含支持状态和启用状态的对象
     */
    checkNfcAvailability: function() {
        try {
            const main = plus.android.runtimeMainActivity();
            const NfcAdapter = plus.android.importClass('android.nfc.NfcAdapter');
            const adapter = NfcAdapter.getDefaultAdapter(main);

            if (adapter === null) {
                return {
                    supported: false,
                    enabled: false,
                    error: '设备不支持NFC'
                };
            }

            const isEnabled = adapter.isEnabled();
            return {
                supported: true,
                enabled: isEnabled,
                error: isEnabled ? null : 'NFC未启用'
            };
        } catch (error) {
            console.error('NFC: 检查可用性失败:', error);
            return {
                supported: false,
                enabled: false,
                error: error.message || '检查失败'
            };
        }
    },

    /**
     * 将字节数组转换为十六进制字符串
     * @param {Uint8Array|Array} inarray - 字节数组
     * @returns {string} 十六进制字符串
     */
    byteArrayToHexString: function(inarray) {
        const hex = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"];
        let out = "";

        for (let j = 0; j < inarray.length; j++) {
            const inn = inarray[j] & 0xff;
            const i = (inn >>> 4) & 0x0f;
            out += hex[i];
            const k = inn & 0x0f;
            out += hex[k];
        }

        return out;
    },

    /**
     * 清理NFC资源
     */
    cleanupNFC: function() {
        try {
            // 使用私有清理方法
            this._cleanupResources();

            // 移除事件监听器
            try {
                plus.globalEvent.removeEventListener('newintent', this._handleNewIntent);
                console.log('NFC: 已移除newintent事件监听器');
            } catch (e) {
                console.warn('NFC: 移除事件监听器时出错:', e);
            }

            // 重置初始化状态
            isNFCInitialized = false;
            console.log('NFC: 资源已完全清理');
        } catch (error) {
            console.error('NFC: 清理资源时发生错误:', error);
        }
    }
};