//               该文件中包含客户端需要处理的函数和事件
var showInfo;
var arrResult;
var mDebug = "0";
var mOperate = "";
var turnPage = new turnPageClass();
var mWFlag = 0;
`turnPage`.pageLineNum = 200;
var turnPage1 = new turnPageClass();


/**
 * 宽松校验整数（接受数字或字符串形式的整数）
 * @param {*} value - 待校验的值
 * @returns {boolean}
 */
function isIntegers(value) {
    // 1. 直接是数字且为整数
    if (Number.isInteger(value)) return true;
    // 2. 是字符串且内容为整数（允许前后空格，如 ' 42 '）
    if (typeof value === 'string') {
        const str = value.trim();
        return str !== '' && !isNaN(str) && Number.isInteger(Number(str));
    }
    return false;
}
/**
 * 宽松校验 DOUBLE 类型（接受数字或字符串形式的浮点数）
 * @param {*} value - 待校验的值
 * @returns {boolean}
 */
function isDoubles(value, decimalPlaces = Infinity) {
    // 1. 直接是数字类型（包括浮点数、Infinity，排除NaN）
    if (typeof value === 'number' && !isNaN(value)) {
        // 检查小数位数是否符合要求
        const str = value.toString();
        if (decimalPlaces === 0) {
            // 如果是整数，直接校验是否为整数
            return Number.isInteger(value);
        }
        if (str.includes('.')) {
            const decimalPart = str.split('.')[1];
            return decimalPart.length <= decimalPlaces;
        }
        return true; // 没有小数点时，也符合要求
    }

    // 2. 是字符串且内容可解析为有效的非NaN数字
    if (typeof value === 'string') {
        const str = value.trim();
        // 允许科学计数法（如 "1.23e4"）、正负号、小数点
        if (str !== '' && !isNaN(Number(str)) && isFinite(Number(str))) {
            const parsedValue = Number(str);
            // 检查小数位数是否符合要求
            const strParsed = parsedValue.toString();
            if (decimalPlaces === 0) {
                // 如果是整数，直接校验是否为整数
                return Number.isInteger(parsedValue);
            }
            if (strParsed.includes('.')) {
                const decimalPart = strParsed.split('.')[1];
                return decimalPart.length <= decimalPlaces;
            }
            return true; // 没有小数点时，也符合要求
        }
    }

    return false;
}
/**
 * 校验时间字符串格式是否为 HH:mm:ss 且数值有效
 * @param {string} timeStr - 待校验的时间字符串
 * @returns {boolean}
 */
function isValidTimes(timeStr) {
    // 1. 正则校验基本格式
    const timeRegex = /^(0[0-9]|1[0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])$/;
    if (!timeRegex.test(timeStr)) return false;

    // 2. 拆分并数值校验（正则已保证范围，此处可省略）
    const [hours, minutes, seconds] = timeStr.split(':').map(Number);
    return (
        hours >= 0 && hours <= 23 &&
        minutes >= 0 && minutes <= 59 &&
        seconds >= 0 && seconds <= 59
    );
}

function isBetween(value1, value2, value3) {
    // 如果 value1 是 null，则不进行任何比较，直接返回 true
    if (value1 === null) return false;
    // 如果 value2 是 null，则只检查 value1 是否小于 value3
    if (value2 === null){
        if(value1 > value3){
            return false;
        }
        return true;
    }
    // 如果 value3 是 null，则只检查 value1 是否大于 value2
    if (value3 === null){
        if(value1 < value2){
            return false;
        }
        return true;
    }
    if(value1 < value2 || value1 > value3){
        return false
    }
    // 如果所有值都不是 null，则检查 value1 是否在 value2 和 value3 之间
    return  true;
}

function isTime1Later(timeStr1, timeStr2) {
    const time1 = new Date(`1970-01-01T${timeStr1}`);
    const time2 = new Date(`1970-01-01T${timeStr2}`);
    return time1 > time2;
}
function validateTwoDecimal(input) {
    // 转换为字符串处理
    const str = String(input);

    // 正则表达式校验：
    // ^-? - 可选负号开头
    // \d+ - 至少一位数字
    // (\.\d{1,2})? - 可选的小数点和1-2位小数
    // $ - 字符串结束
    const regex = /^-?\d+(\.\d{1,2})?$/;

    // 校验是否是有效数字
    if (!regex.test(str)) {
        return false;
    }

    // 额外检查转换为数字后是否有效
    const num = parseFloat(str);
    return !isNaN(num);
}
function compareValues(a, b, operator = '>') {
    // 转换为数字类型
    const numA = Number(a);
    const numB = Number(b);

    // 校验是否为有效数字
    if (isNaN(numA)) throw new Error(`"${a}" 不是有效数字`);
    if (isNaN(numB)) throw new Error(`"${b}" 不是有效数字`);

    switch (operator) {
        case '>':  return numA > numB;
        case '>=': return numA >= numB;
        case '<':  return numA < numB;
        case '<=': return numA <= numB;
        case '==': return numA == numB;  // 宽松相等
        case '===': return numA === numB; // 严格相等
        default: throw new Error(`不支持的比较运算符: ${operator}`);
    }
}
function validateNumberFormat(input, maxIntegerLength, maxDecimalLength) {
    if (typeof input !== 'string' || input.trim() === '') {
        return false;
    }

    // 去除前后空格
    input = input.trim();

    // 检查是否为有效数字格式（允许负数）
    if (!/^-?\d*\.?\d+$/.test(input)) {
        return false;
    }

    // 分割整数部分和小数部分
    const parts = input.split('.');
    const integerPart = parts[0].replace('-', ''); // 去除负号
    const decimalPart = parts[1] || '';

    // 校验整数部分长度
    if (integerPart.length > maxIntegerLength) {
        return false;
    }

    // 允许0或-0
    if (integerPart === '0' && decimalPart === '') {
        return true;
    }

    // 不允许只有负号的情况（除了-0）
    if (integerPart === '' && input.startsWith('-') && !input.startsWith('-0')) {
        return false;
    }

    // 校验小数部分长度
    if (decimalPart.length > maxDecimalLength) {
        return false;
    }

    // 不允许单独的小数点
    if (input.endsWith('.') && decimalPart === '') {
        return false;
    }

    // 不允许前导零（除非是0或0.x）
    if (integerPart.length > 1 && integerPart.startsWith('0') && !integerPart.startsWith('0.')) {
        return false;
    }

    return true;
}