/*  
    表单验证
    form为表单
    rules为需要验证的表单
	rules:{ name: '请输入名称' } name为需要验证的字段
  */
export function rulesFun(form, rules) {
	console.log('-------------------------------')
	let flage = true
	let JSONrules = JSON.stringify(rules)
	if (JSONrules !== JSON.stringify({})) {
		for (let key in rules) {
			if (Array.isArray(form[key]) && form[key].length == 0) {
				uni.showToast({
					title: rules[key],
				})
				flage = false
				break;
			} else if (!form[key] && form[key] !== 0) {
				uni.showToast({
					title: rules[key],
				})
				flage = false
				break;
			}
		}
	}
	return flage
}

/* 手机号验证 */
export function rulesPhone(phoneVal) {
	let phoneReg = /(^1\d{10}$)|(^[0-9]\d{7}$)/;
	if (!phoneReg.test(phoneVal)) {
		uni.showToast({
			title: '请输入正确的手机号',
		})
		return false;
	} else {
		return true
	}
}

/* 身份证验证 */
export function rulesIdCard(IdcardVal) {
	var idCardReg = /^(\d{15}$|^\d{18}$|^\d{17}(\d|X|x))$/;
	if (!idCardReg.test(IdcardVal)) {
		uni.showToast({
			title: '身份证号码格式错误!',
		})
		return false;
	} else {
		return true
	}
}

// 计算
export function calculator(startNum, endNum, operator = '+') {
	if (operator == '+') {
		return (Number(startNum * 1000) + Number(endNum * 1000)) / 1000
	} else if (operator == '-') {
		return (Number(startNum * 1000) - Number(endNum * 1000)) / 1000
	} else if (operator == '/') {
		return (Number(startNum * 1000) / Number(endNum * 1000)) / 1000
	} else if (operator == '*') {
		return (Number(startNum * 1000) * Number(endNum * 1000)) / 1000
	}
}
// timeStr表示时间 separator表示分隔符 type == yaer表示只返回年月日
export function formatDate(timeStr = (new Date()), separator = '-', type) {
	const date = new Date(timeStr)
	let yaer = date.getFullYear()
	let month = date.getMonth() + 1
	let day = date.getDate()
	let hour = date.getHours()
	let minute = date.getMinutes()
	let second = date.getSeconds()
	if (type == 'year') {
		return yaer + separator + month + separator + day
	} else {
		return yaer + separator + month + separator + day + ' ' + hour + ':' + minute + ':' + second
	}
}




// 从解析jwt token里面的信息

function base64Decode(input) {
    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
    let str = input.replace(/=+$/, '');
    let output = '';

    if (str.length % 4 === 1) {
        throw new Error("'atob' failed: The string to be decoded is not correctly encoded.");
    }

    for (let bc = 0, bs, buffer, i = 0; (buffer = str.charAt(i++)); ~buffer &&
        (bs = bc % 4 ? bs * 64 + buffer : buffer,
            bc++ % 4) ?
        output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0) {
        buffer = chars.indexOf(buffer);
    }

    return output;
}

export function parseJWT(token) {
    const parts = token.split('.');
    if (parts.length !== 3) {
        throw new Error('Invalid JWT token');
    }
    const payload = parts[1];
    const decoded = JSON.parse(
        decodeURIComponent(
            base64Decode(payload.replace(/-/g, '+').replace(/_/g, '/').replace(/\s/g, ''))
                .split('')
                .map(c =>
                    `%${('00' + c.charCodeAt(0).toString(16)).slice(-2)}`
                )
                .join('')
        )
    );
    return decoded;
}

// 防抖函数确保在一定时间内只触发一次点击事件
// fn: 要执行的函数
// delay: 防抖的时间间隔（单位为毫秒，默认为500ms）
export function debounce(fn, delay = 500, immediate = false) {
    let timer = null;
    return function (...args) {
        const context = this;
        if (timer) clearTimeout(timer);
        if (immediate) {
            // 如果立即执行，那么只在第一次触发时执行
            const callNow = !timer;
            if (callNow) fn.apply(context, args);
            // 设置一个延迟的定时器，后续的触发将被防抖处理
            timer = setTimeout(() => {
                timer = null;
            }, delay);
        } else {
            // 非立即执行模式，按普通防抖逻辑
            timer = setTimeout(() => {
                fn.apply(context, args);
            }, delay);
        }
    };
}

// 节流函数限制按钮在一段时间内只触发一次（而不是点击结束后再延时执行）
// 节流函数
export function throttle(fn, delay = 1000) {
    let last = 0;
    return function (...args) {
        const now = Date.now();
        if (now - last > delay) {
            last = now;
            fn.apply(this, args);
        }
    };
}