/*
 * 获取缓存的值——String类型
 * 返回值字符串  有值返回具体的值，否则返回空字符串
 * @zjf-2020-.gitignore-26
 * */

import { useRouter } from 'vue-router'
import { lang_zn } from '@/assets/language/zh';
import { lang_en } from '@/assets/language/en';

const router = useRouter()


export function getLocalStorageStr(key) {
  if(process.client){
    let val = localStorage.getItem(key);
    return val != undefined && val != null && val ? val : "";
  }
}

/**
 * 装修模块的跳转
 * @params  Object val
 */
export function diyNavToFun(val) {
  if (val.link_type == "url") {
    //跳转链接地址
    if (val.link_value) {
      val.link_value = quillEscapeToHtml(val.link_value);
    }
    window.open(val.link_value, "_blank");
  } else if (val.link_type == "goods") {
    //跳转商品详情页
    // let routeUrl = router.resolve({
    //   path: "/goods/detail",
    //   query: {
    //     productId: val.info.defaultProductId,
    //   },
    // });

      let href  = "/goods/detail/"+ calcProductName(val.info.goodsName) +'_'+ val.info.defaultProductId
      window.open(href, "_blank");
  } else if (val.link_type == "category") {
    // 分类列表
    let routeUrl = router.resolve({
      path: "/goods/list/categoryId-"+val.info.categoryId,
    });

    window.open(routeUrl.href, "_blank");
  } else if (val.link_type == "keyword") {
    // 关键词
    let path = "/goods/list/keyword-"+ val.link_value
    let query = {
      keyword: val.link_value,
    };
    if (val.storeId) {
      query.storeId = val.storeId;
      path+='/storeId-'+val.storeId
    }
    let routeUrl = router.resolve({
      path: path
    });
    window.open(routeUrl.href, "_blank");
  } else if (val.link_type == "topic") {
    //跳转专题页
    let href = `/home/topic?topicId=${val.info.decoId}`
    window.open(href, "_blank");
  } else if (val.link_type == "brand_home") {
    //品牌列表
    let routeUrl = router.resolve({
      path: "/brand",
      query: {},
    });
    window.open(routeUrl.href, "_blank");
  } else if (val.link_type == "store_list") {
    //店铺列表
    let routeUrl = router.resolve({
      path: "/store/list/current-1",
    });
    window.open(routeUrl.href, "_blank");
  } else if (val.link_type == "voucher_center") {
    //领券中心
    let routeUrl = router.resolve({
      path: "/coupon",
    });
    window.open(routeUrl.href, "_blank");
  } else if (val.link_type == "point_center") {
    let routeUrl = router.resolve({
      path: "/point/index",
    });
    window.open(routeUrl.href, "_blank");
  }
}


/*
* 富文本内容反转义（接口返回的富文本内容经过了转义，导致内容无法展示，所以需要反转义）
* @param {String} str 富文本内容
* @zjf-2022-01-07
* */
export function quillEscapeToHtml(str) {
  if (str != undefined) {
      const arrEntities = { 'lt': '<', 'gt': '>', 'nbsp': ' ', 'amp': '&', 'quot': '"' }
      return str.replace(/&(lt|gt|nbsp|amp|quot);/ig, function (all, t) {
          return arrEntities[t]
      })
  } else {
      return '';
  }
}


/*
* 获取当前语言下的数据 —— Object类型
* 返回对象  语言数据对象
* @zjf-2020-12-28
* */
export function getCurLanguage() {
  const language = {
      'zh': lang_zn,
      'en': lang_en,
  }
  const config = useRuntimeConfig()
  if (config.public.appType === 'distributor') {
    return language.zh;
  }
  return language[curLang];
}



/*
* 密码的验证：6～20位，由英文、数字或符号组成的验证
* 验证通过，返回boolean值true，否则返回具体的错误信息
* @zjf-2021-01-06
* */
export function checkPwd(pwd) {
  let tarLang = getCurLanguage();
  if (pwd.length < 6) {
      return tarLang['密码最少6位哦～'];
  } else if (pwd.length > 20) {
      return tarLang['密码最多20位哦～'];
  } else if (!(/[^\u4e00-\u9fa5]/.test(pwd))) {
      return tarLang['密码不可以有中文哦～'];
  } else if (!(/^\S*$/.test(pwd))) {
      return tarLang['密码中不可以有空格哦～'];
  } else {
      return true;
  }
}

/*
* 短信验证码的验证：6位0～9的数字
* 验证通过，返回boolean值true，否则返回具体的错误信息
* @zjf-2021-01-06
* */
export function checkSmsCode(val) {
  let tarLang = getCurLanguage();
  let reg = /^\d{6}$/;
  if (!val) {
      return tarLang['请输入短信验证码'];
  } else if (!reg.test(val)) {
      return tarLang['请输入正确的短信验证码'];
  } else {
      return true;
  }
}



/*
* 邮箱的验证
* 验证通过，返回boolean值true，否则返回具体的错误信息
* @zjf-2021-01-.gitignore
* */
export function checkEmail(email) {
  let tarLang = getCurLanguage();
  let reg = /^([a-zA-Z0-9_-]+[-_.]?)*[a-zA-Z0-9_-]+@([a-zA-Z0-9.-]+[-_.]?)*[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/;
  if (!email) {
      return tarLang['请输入邮箱'];
  } else if (!reg.test(email)) {
      return tarLang['请输入正确的邮箱'];
  } else {
      return true;
  }
}

/*
* 邮箱的验证 非必填只校验格式
* 验证通过，返回boolean值true，否则返回具体的错误信息
* @zjf-2021-01-.gitignore
* */
export function existCheckEmail(email) {
  let tarLang = getCurLanguage();
  let reg = /^([a-zA-Z0-9_-]+[-_.]?)*[a-zA-Z0-9_-]+@([a-zA-Z0-9.-]+[-_.]?)*[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/;
  if (email && !reg.test(email)) {
      return tarLang['请输入正确的邮箱'];
  }
  return true;
}

/*
* 短信图形验证码的验证：4位英文字母和数字
* 验证通过，返回boolean值true，否则返回具体的错误信息
* @zjf-2021-01-07
* */
export function checkImgCode(val) {
  let tarLang = getCurLanguage();
  let reg = /^[a-zA-Z0-9]{4}$/;
  if (!val) {
      return tarLang['请输入图形验证码'];
  } else if (!reg.test(val)) {
      return tarLang['请输入正确的图形验证码'];
  } else {
      return true;
  }
}


/*
* 邮箱验证码的验证：6位0～9的数字
* 验证通过，返回boolean值true，否则返回具体的错误信息
* @zjf-2021-01-06
* */
export function checkEmailCode(val) {
  let tarLang = getCurLanguage();
  let reg = /^\d{4,6}$/;
  if (!val) {
      return tarLang['请输入邮箱验证码'];
  } else if (!reg.test(val)) {
      return tarLang['请输入正确的邮箱验证码'];
  } else {
      return true;
  }
}

export function existCheckPhone(mobile, txt) {
  let tarLang = getCurLanguage();
  let regMobile = /(1[3-9]\d{9}$)/;
  if (mobile && !regMobile.test(mobile)) {
      return txt ? txt : tarLang['请输入正确的手机号'];
  }
  return true;
}


export function checkPhone(mobile, txt) {
  let tarLang = getCurLanguage();
  let regMobile = /(1[3-9]\d{9}$)/;
  if (!mobile) {
      return txt ? txt : tarLang['请输入手机号'];
  } else if (!regMobile.test(mobile)) {
      return txt ? txt : tarLang['请输入正确的手机号'];
  } else {
      return true;
  }
}


/**
 * base64加密
 * @params data String 要加密的字符串
 * @zjf-2021-06-28
 */
 export function base64Encode(data) {
  let b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
  let o1,
      o2,
      o3,
      h1,
      h2,
      h3,
      h4,
      bits,
      i = 0,
      ac = 0,
      enc = '',
      tmp_arr = [];
  if (!data) {
      return data;
  }
  data = utf8Encode(data);
  do {
      o1 = data.charCodeAt(i++);
      o2 = data.charCodeAt(i++);
      o3 = data.charCodeAt(i++);

      bits = o1 << 16 | o2 << 8 | o3;

      h1 = bits >> 18 & 0x3f;
      h2 = bits >> 12 & 0x3f;
      h3 = bits >> 6 & 0x3f;
      h4 = bits & 0x3f;
      tmp_arr[ac++] = b64.charAt(h1) + b64.charAt(h2) + b64.charAt(h3) + b64.charAt(h4);
  } while (i < data.length);

  enc = tmp_arr.join('');

  switch (data.length % 3) {
      case 1:
          enc = enc.slice(0, -2) + '==';
          break;
      case 2:
          enc = enc.slice(0, -1) + '=';
          break;
  }

  return enc;
}

export function utf8Encode(string) {
  string = (string + '').replace(/\r\n/g, '\n').replace(/\r/g, '\n');

  let utftext = '',
      start,
      end;
  let stringl = 0,
      n;

  start = end = 0;
  stringl = string.length;

  for (n = 0; n < stringl; n++) {
      let c1 = string.charCodeAt(n);
      let enc = null;

      if (c1 < 128) {
          end++;
      } else if ((c1 > 127) && (c1 < 2048)) {
          enc = String.fromCharCode((c1 >> 6) | 192, (c1 & 63) | 128);
      } else {
          enc = String.fromCharCode((c1 >> 12) | 224, ((c1 >> 6) & 63) | 128, (c1 & 63) | 128);
      }
      if (enc !== null) {
          if (end > start) {
              utftext += string.substring(start, end);
          }
          utftext += enc;
          start = end = n + 1;
      }
  }

  if (end > start) {
      utftext += string.substring(start, string.length);
  }

  return utftext;
}



//处理产品名中的空格换中横及大写转换小写
export function calcProductName(val){
    let name = ''
    //1.删除特殊字符 2.去除两头空格 3.替换空格为- 4.替换/为-
    name = val ? val.toLowerCase().replace(/[~'!?.<>@#$%^*()（）+=\/\\:]/g,"").replace(/^\s*|\s*$/g,"").replace(/\ /g, "-").replace(/\//g, '-') : ''
    return name
}



//处理商品ID
export function calcProductId(val){
    let a = val.split('_')
    let b = a[a.length - 1]
    return b
}

//处理分类页面的店铺ID字段
export function  calcUrlShopId(val){
    let a = val.split('_')
    let vid = ''
    for(let i  in a){
        if(i > 0) {
            if (a[i].indexOf('v-') > -1) {
                vid = a[i].replace('v-', '')
            }
        }
    }
    return vid
}


//处理分类页面的分类ID字段
export function calcUrlCatId(val){
    let a = val.split('_')
    let cid = ''
    for(let i  in a){
        if(i > 0){
            if(a[i].indexOf('c-') > -1){
                cid = a[i].replace('c-','')
            }
        }
    }
    return cid
}


//处理分类页面的分页页面字段
export function calcUrlPagination(val){
    let a = val.split('_')
    let pid = ''
    for(let i  in a){
        if(i > 0){
            if(a[i].indexOf('p-') > -1){
                pid = a[i].replace('p-','')
            }
        }
    }
    return pid
}

//处理分类页面的关键字
export function calcUrlKeywords(val){
    let a = val.split('_')
    let kid = ''
    for(let i  in a){
        if(i > 0){
            if(a[i].indexOf('k-') > -1){
                kid = a[i].replace('k-','')
            }
        }
    }
    return kid
}


//处理商城的分类URL-PID字段
export function calcMallUrlPid(val){
    let a = val.split('_')
    let pid = ''
    for(let i  in a){
        if(i > 0){
            if(a[i].indexOf('pid-') > -1){
                pid = a[i].replace('pid-','')
            }
        }
    }
    return pid
}

//处理商城的分类URL-GID字段
export function calcMallUrlGid(val){
    let a = val.split('_')
    let gid = ''
    for(let i  in a){
        if(i > 0){
            if(a[i].indexOf('gid-') > -1){
                gid = a[i].replace('gid-','')
            }
        }
    }
    return gid
}

//处理商城的分类URL-分页字段
export function calcMallUrlCur(val){
    let a = val.split('_')
    let current = ''
    for(let i  in a){
        if(i > 0){
            if(a[i].indexOf('cur-') > -1){
                current = a[i].replace('cur-','')
            }
        }
    }
    return current
}

//处理商城的分类URL-品牌ID字段
export function calcMallUrlBrand(val){
    let a = val.split('_')
    let brand = ''
    for(let i  in a){
        if(i > 0){
            if(a[i].indexOf('b-') > -1){
                brand = a[i].replace('b-','')
            }
        }
    }
    return brand
}



//处理商城的分类URL-分页字段
export function calcMallUrlKeyword(val){
    let a = val.split('_')
    let keyword = ''
    for(let i  in a){
        if(i > 0){
            if(a[i].indexOf('keyword-') > -1){
                keyword = a[i].replace('keyword-','')
            }
        }
    }
    return keyword
}



//处理商城的分类URL-获取分类名称
export function calcMallUrlCatName(val){
    let a = val.split('_')
    let current = a[0]
    return current
}


const SPECIAL_CHAR_CLASS = /[~!@#$%^&*()_+`\-={}\[\]\|:;\"'<,>.?\/]/;
const DIGIT_CLASS = /[0-9]/;
const LOWER_CLASS = /[a-z]/;
const UPPER_CLASS = /[A-Z]/;
// 检查所有空格字符（半角/全角）
// - \s 会捕获常见的空格、制表符、换行符等
// - \u3000 是全角空格
const SPACE_REG = /[\s\u3000]/;


// 如果想限制“只能使用上述字符（不允许空格、中文等）”，可启用下行：
// const ALLOWED_ALL = /^[0-9A-Za-z~!@#$%^&*()_+`\-={}\[\]\|:;\"'<,>.?\/]+$/;

export function unifyValidatePassword(pwd) {
  const L = getCurLanguage();
  const reasons = [];

  // 1) 长度校验：8-20
  if (pwd.length < 8) {
    reasons.push(L['register']["密码长度不能小于8位"]);
  } else if (pwd.length > 20) {
    reasons.push(L['register']['密码长度不能超过20位']);
  }

  // 2) 统计字符类别命中数（四类中至少两类）
  const hasDigit = DIGIT_CLASS.test(pwd);
  const hasLower = LOWER_CLASS.test(pwd);
  const hasUpper = UPPER_CLASS.test(pwd);
  const hasSpecial = SPECIAL_CHAR_CLASS.test(pwd);

  const typeCount = [hasDigit, hasLower, hasUpper, hasSpecial].filter(Boolean).length;

  if (typeCount < 2) {
    reasons.push(L['register']['密码必须同时包含数字、字母、特殊字符中的两种']);
  }

  if (SPACE_REG.test(pwd)) {
    reasons.push(L['register']['密码不能包含空格']);
  }

  // 4) 可选：若只想限定在“允许字符集合”内，打开 ALLOWED_ALL 后使用以下判断
  // if (!ALLOWED_ALL.test(pwd)) {
  //   reasons.push("密码包含不被允许的字符。");
  // }

  return {
    ok: reasons.length === 0,
    reasons,
  };
}

