boursecu_user/src/utils/inputRules.ts

/*
export function inputRules(title?: string) {
    if (title) {
        return [required(title)]
    } else {
        return [required]
    }
}

export function inputLenRules(len: number, title?: string) {
    if (title) {
        return [
            required(title),
            lenthValidation(len)
        ]
    } else {
        return [
            required,
            lenthValidation(len)
        ]
    }
}
*/

/*export const persianValidation = computed(() => {
  const temp = inputRules()
  temp.push({ pattern: /^[A-Za-z]*$/, message: 'فقط حروف انگلیسی مجاز است' })
  return temp
})*/

import {computed, ref} from 'vue'
import type {Rule} from 'ant-design-vue/es/form'
import {useWalletStore} from "@/store/walletStore";
import { isCashLikeDealMethod, isMainMetalWalletDealMethod, getInsufficientCashWalletMessage, getInsufficientGoldWalletMessage } from '@/utils/productDealMethod'
import { getCashWalletBalance } from '@/utils/productAssets'
import { persianToEnglishDigits } from '@/utils/persianDigits'

export const mobileValidation = (title?: string): Rule => {
    const label = title ?? 'شماره تلفن'
    return {
        transform: (value) => persianToEnglishDigits(String(value ?? '').trim()),
        validator: (_rule, value) => {
            const normalized = persianToEnglishDigits(String(value ?? '').trim())
            if (!normalized) {
                return Promise.resolve()
            }
            if (!/^09\d{9}$/.test(normalized)) {
                return Promise.reject(`${label} باید با 09 شروع شود و 11 رقم باشد`)
            }
            return Promise.resolve()
        },
        trigger: ['change', 'blur'],
    }
}

export const required = (title?: string) => {
    if (title) {
        return {required: true, message: `پر کردن ${title} الزامی است`}
    } else {
        return {required: true, message: `پر کردن مورد بالا الزامی است`}
    }
}
// function checkCodeMeli(code)
// {
//
//     let L=code.length;
//     if(L<8 || parseInt(code,10)==0) return false;
//     code=('0000'+code).substr(L+4-10);
//     if(parseInt(code.substr(3,6),10)==0) return false;
//     let c=parseInt(code.substr(9,1),10);
//     let s=0;
//     for(let i=0;i<9;i++)
//         s+=parseInt(code.substr(i,1),10)*(10-i);
//     s=s%11;
//     return (s<2 && c==s) || (s>=2 && c==(11-s));
//
// }
export const cardNumberValidation = (title?: string) => {
    return { len: 16, message: `شماره کارت باید 16 رقم باشد` }
}

const isValidNationalCode = (code) => {
    if (code.length !== 10 || /(\d)(\1){9}/.test(code)) return false

    let sum = 0,
        chars = code.split(''),
        lastDigit,
        remainder

    for (let i = 0; i < 9; i++) sum += +chars[i] * (10 - i)

    remainder = sum % 11
    lastDigit = remainder < 2 ? remainder : 11 - remainder

    return +chars[9] === lastDigit
}
export const requireNationalCode = (code?: string) => {
    return {
        required: true,
        transform: (value) => persianToEnglishDigits(String(value ?? '').trim()),
        validator: validateNCode,
        trigger: 'change',
    }
}

async function validateNCode(rule: Rule, value: any) {
    const normalized = persianToEnglishDigits(String(value ?? '').trim())
    if (!normalized) {
        return Promise.reject('وارد کردن کد ملی الزامیست')
    }
    if (isValidNationalCode(normalized)) return Promise.resolve()
    else return Promise.reject('کد ملی وارد شده نامعتبر است')
}

export function inputLenRules(len: number, title?: string) {
    if (title) {
        return [
            {required: true, message: `پر کردن ${title} الزامی است`},
            {len: len, message: `تعداد کاراکتر باید ${len} عدد باشد`}
        ]
    } else {
        return [
            {required: true, message: 'پر کردن مورد بالا الزامی است'},
            {len: len, message: `تعداد کاراکتر باید ${len} عدد باشد`}
        ]
    }
}

export const persianValidation = computed(() => {
    return {
        pattern: /^[A-Za-z]*$/,
        message: 'فقط حروف انگلیسی مجاز است'
    }
})

export const isValidPersian = () => {
    return {
        pattern: /^[\u0600-\u06FF\s]+$/,
        message: 'فقط حروف فارسی مجاز است'
    }
};

export const lengthValidation = (len: number) => {
    return {len: len, message: `تعداد کاراکتر باید ${len} عدد باشد`}
}

export const justNumber = () => {
    return {
        required: true,
        type: 'regexp',
        pattern: /\d+/g,
        message: 'لطفا اطلاعات را به صورت عدد و نقطه وارد کنید'
    }
}
const walletCash = useWalletStore()
let priceP = 0
let methodP = 'cash'
let amountP =0
let isBuyP=true
let NumP=0
let groupTypeP: string | undefined
let meltedBalanceP = 0
const checkNumber = async (_rule: Rule, value: number | string) => {
    const normalizedRaw = persianToEnglishDigits(String(value ?? '').trim())
    if (!normalizedRaw) {
        return Promise.reject('تعداد محصول را مشخص کنید');
    }
    const numericValue = Number(normalizedRaw)
    if (!Number.isFinite(numericValue)) {
        return Promise.reject('تعداد محصول را مشخص کنید');
    }
    if (numericValue % 1 !== 0) {
        return Promise.reject('استفاده از اعداد اعشاری مجاز نمی باشد')
    }
if (isBuyP){
    const availableCash = getCashWalletBalance(walletCash?.walletInfo)
    if (!availableCash && isCashLikeDealMethod(methodP)){
        return Promise.reject(getInsufficientCashWalletMessage(groupTypeP))
    }
    if (!meltedBalanceP && isMainMetalWalletDealMethod(methodP)){
        return Promise.reject(getInsufficientGoldWalletMessage(groupTypeP, methodP))
    }
    if (priceP * numericValue > availableCash && isCashLikeDealMethod(methodP))
        return Promise.reject(getInsufficientCashWalletMessage(groupTypeP))
    if (amountP * numericValue > meltedBalanceP && isMainMetalWalletDealMethod(methodP))
        return Promise.reject(getInsufficientGoldWalletMessage(groupTypeP, methodP))
    else
        return Promise.resolve();
}else {
    if (numericValue > NumP)
        return Promise.reject('موجودی محصول ناکافی است')
    else
        return Promise.resolve();
    }
}

export const justNumber2 = (
  price: number,
  method?: string,
  amount?: number,
  isBuy?: boolean,
  groupType?: string,
  meltedBalance?: number,
) => {
    priceP = price
    methodP = method
    amountP=amount
    isBuyP=isBuy
    groupTypeP = groupType
    meltedBalanceP = meltedBalance ?? 0
    return {
        required: true,
        transform: (value) => persianToEnglishDigits(String(value ?? '').trim()),
        validator: checkNumber,
        trigger: 'change'
    }
}

export const justNumber3 = (price: number, Num?:number ,isBuy?:boolean) => {
    priceP = price
    NumP=Num
    isBuyP=isBuy
    return {
        required: true,
        transform: (value) => persianToEnglishDigits(String(value ?? '').trim()),
        validator: checkNumber,
        trigger: 'change'
    }
}

export const ruleNumber = () => {
    console.log('445455')
    return {
        required: true,
        message: 'لطفا نحوه خرید',
        trigger: 'change'
    }
}

export const guideTypePassword = ref<{}>({
    text: '',
    color: ''
})

export const passwordRules = () => {
    return [
        {
            transform: (value) => persianToEnglishDigits(String(value ?? '')),
            validator: (rule: Rule, value: any) => {
                const normalized = persianToEnglishDigits(String(value ?? ''))
                if (normalized.length < 6) {
                    return Promise.reject('رمز عبور حداقل 6 رقم')
                }
                const lengthCriteria = normalized.length >= 8
                const letterCriteria = /[A-Za-z]/.test(normalized)
                const numberCriteria = /\d/.test(normalized)
                const specialCharacterCriteria = /[@$!%*#?&]/.test(normalized)
                const criteriaMet = [
                    lengthCriteria,
                    letterCriteria,
                    numberCriteria,
                    specialCharacterCriteria
                ].filter(Boolean).length
                if (criteriaMet === 4) {
                    guideTypePassword.value = {
                        text: 'سطح : قوی',
                        color: 'text-green'
                    }
                    return Promise.resolve();
                } else if (criteriaMet === 3) {
                    guideTypePassword.value = {
                        text: 'سطح : متوسط',
                        color: 'midLevel'
                    }
                    return Promise.resolve();
                } else {
                    guideTypePassword.value = {
                        text: 'سطح : ضعیف',
                        color: 'week'
                    }
                    return Promise.resolve();
                }
            }
        }
    ]
}

export const englishNumberRule = () => {
    return {
        validator: (_: any, value: string | number) => {
            const str = persianToEnglishDigits(value)
            if (!str) return Promise.resolve()
            const isEnglishDigitsOnly = /^[0-9]+$/.test(str)
            if (!isEnglishDigitsOnly) {
                return Promise.reject('لطفاً فقط از اعداد انگلیسی استفاده کنید')
            }
            return Promise.resolve()
        },
        trigger: ['change', 'blur'],
    }
}