var regeneratorRuntime = require('runtime.js');
module.exports = {
    zhqty_bz_fun(zhqty_bz,be,zhqty_bz_arr){
        let zhqty_bz_flag =true;
        for(let i=0;i<zhqty_bz.length;i++){
            let item=zhqty_bz[i];
            let bz_num = be * item['zhqty']; //超量倍增
            let num = item['num'] - item['zhqty']; //购买数量减去超量
            if (bz_num > num) {
                zhqty_bz_flag=false;

                var be=0;
                if (num % vv.zhqty == 0) {
                    be = num / vv.zhqty;
                } else {
                    be = Math.floor(num / vv.zhqty)
                }
                item.be=item;

                zhqty_bz_arr.push(item);
                // zhqty_bz.splice(i,1)
            }
        }
        return zhqty_bz_flag;
    },
    //-- 判断组合购有没有满足，只有在检查的时候，要用新的 ---
    ch_zh_ok(act,gdlist,c_goods,th,item_act_map,is_need_ck_num,need_ok){

        //-- 寻找一下 --
        function get_num(ite) {
            for (let v1 in c_goods) {
                var vh = c_goods[v1];
                if (vh.goods_id == ite.goods_id) {
                    return vh;
                }
            }
            return 0;
        }

        var goods =gdlist;
        var all_num=0;
        var need_to_buy=0;
        var all_zhqty=0;
        //-- 是综合考虑到组合购的总数量和限购数量 --
        var min_can_buy=-1;
        var aid=act.id;

        let no_in_arr = []; //剩余的未加入组合购
        let out_arr = []; //超出活动限购的商品放入
        let zhqty_bz = []; //超量

        //-- 判断组合购的总数量是不是到了 --
        if(act.zh_num>0){
            //如果是在全选的情况下，那么就需要in_zhact_new来控制数量
            var need_ck=0;
            if(is_need_ck_num){
                need_ck=th.data.in_zhact_new[aid]?th.data.in_zhact_new[aid]:0;
            }
            if(need_ck+act.zh_buy_num>=act.zh_num ){
                if(!need_ok) {
                    item_act_map.is_no_ok = 1;
                }else{
                    return false;
                }
            }else{
                min_can_buy= act.zh_num-act.zh_buy_num-need_ck;
            }
        }

        //-- 判断组合购的限购是不是到了 --
        if(act.buy_limit>0){
            var need_ck0=0;
            if(is_need_ck_num){
                need_ck0=th.data.in_zhact_new[aid]?th.data.in_zhact_new[aid]:0;
            }
            var min_can_buy0=0;
            if(need_ck0+item_act_map.buyed>=act.buy_limit){
                if(!need_ok) {
                    item_act_map.is_no_ok = 1;
                }else{
                    return false;
                }


            }else{
                min_can_buy0=act.buy_limit-item_act_map.buyed-need_ck;
            }
            if(min_can_buy>0){
                if(min_can_buy0<min_can_buy) min_can_buy=min_can_buy0;
            }else{
                min_can_buy=min_can_buy0;
            }
        }


        for (var i in goods) {
            var item = goods[i];
            var cart_num = get_num(item).goods_num;
            var zh_b_num = get_num(item).zh_b_num;
            if (!cart_num) {
                if (item.zhqty) {
                    need_to_buy += item.zhqty;
                }
                continue;
            }

            item.cart_num = cart_num;
            //-- 当商品有购买的时候,以及有限购的时候 --
            if (item.buyqty > 0) {
                var cbuy = item.buyqty - zh_b_num;
                var key = item.goods_id + "." + act.id;
                if (is_need_ck_num && th.data.in_zhact_gdmap_new[key]) {
                    var cbuy = item.buyqty - zh_b_num - th.data.in_zhact_gdmap_new[key];
                }
                //当可买的数量为0
                if (cbuy <= 0) {
                    item.num = 0;
                    out_arr.push({
                        goods_id: item.goods_id,
                        num: cart_num
                    })
                } else {
                    if (cbuy >= cart_num) item.num = cart_num;
                    else {
                        item.num = cbuy;
                        out_arr.push({
                            goods_id: item.goods_id,
                            num: cart_num - cbuy
                        })
                    }
                }
            } else {
                item.num = cart_num;
            }

            if (item.num) {
                all_num += item.num;
                //当有起购数的控制的时候
                if (item.zhqty) {

                    zhqty_bz.push(item);

                    all_zhqty += item.zhqty;
                    if (item.num < item.zhqty) {
                        need_to_buy += item.zhqty - item.num;
                    }
                    if (item.num > item.zhqty) {
                        for (let i = 0; i < item.num - item.zhqty; i++) {
                            no_in_arr.push({
                                goods_id: item.goods_id,
                            })
                        }
                    }
                }
                else {
                    for (let j = 0; j < item.num; j++) {
                        no_in_arr.push({
                            goods_id: item.goods_id,
                        })
                    }
                }
            } else {
                if (item.zhqty) {
                    need_to_buy += item.zhqty;
                }
            }
        }
        //当满足组合的要求：总数要满足，起购数要满足
        if (all_num >= act.zhbuyqty && !need_to_buy) {
            //默认数量是1
            var act_num=1;
            function sortData(a, b) {
                return a.price - b.price
            }
            if (no_in_arr.length > 0) no_in_arr.sort(sortData);
            if (act.zhbuyqty > all_zhqty) {
                for (let n = 0; n < act.zhbuyqty - all_zhqty; n++) {
                    no_in_arr.pop();
                }
            }

            //看一下剩下的数量有没有满足组合购的要求，以及要不要倍增
            if (act.is_bz && no_in_arr.length >= act.zhbuyqty) {

                var bz_num_ok = 0; //超量倍增是否满足
                var zhqty_len = 0; //几个超量倍增
                var delete_num = 0;
                //看一下是几倍
                let be = parseInt(no_in_arr.length / act.zhbuyqty);
                //如果有总数控制的时候
                if (min_can_buy>0) {
                    var be1 = min_can_buy - 1;
                    if (be1 < be) be = be1;
                }
                if(be) {
                    if (act.is_bzyh && zhqty_bz.length > 0) {

                        let zhqty_bz_arr = [];
                        let zhqty_bz_flag = this.zhqty_bz_fun(zhqty_bz, be, zhqty_bz_arr);
                        if (zhqty_bz_flag) {
                            for (let i = 0; i < zhqty_bz.length; i++) {
                                var vv = zhqty_bz[i];
                                for (let j = 0; j < be * vv['zhqty']; j++) {
                                    let index = no_in_arr.findIndex(i => {
                                        return vv.goods_id === i.goods_id
                                    })
                                    if (index > -1) {
                                        delete_num++
                                        no_in_arr.splice(index, 1)
                                    }
                                }
                            }
                        } else {
                            zhqty_len = 1;
                            let min_bz_num = Math.min.apply(Math, zhqty_bz_arr.map(function (o) {
                                return o['be'];
                            }));
                            let new_arr = zhqty_bz_arr.filter(ii => {
                                return ii['be'] == min_bz_num;
                            })
                            //-- 要看一下倍数还有没有 ---
                            be = new_arr[0].be;
                            //如果有总数控制的时候
                            if (min_can_buy>0) {
                                var be1 = min_can_buy - 1;
                                if (be1 < be) be = be1;
                            }
                            if(be){
                                for (let i = 0; i < zhqty_bz.length; i++) {
                                    let item1 = zhqty_bz[i];
                                    for (let j = 0; j < be * item1['zhqty']; j++) {
                                        let index = no_in_arr.findIndex(i => {
                                            return item1.goods_id === i.goods_id
                                        })
                                        if (index > -1) {
                                            no_in_arr.splice(index, 1)
                                        }
                                    }
                                }
                                act_num+=be;
                            }
                        }
                    }
                    if (!zhqty_len) {
                        let pop_num = be * act.zhbuyqty - delete_num;
                        for (var m = 0; m < pop_num; m++) {
                            no_in_arr.pop();
                        }
                        act_num+=be;
                    }
                }
            }

            //-- 参与活动的金额要返回回去 --
            item_act_map.act_num=act_num;
            let goods_map = {};
            //算一下剩余的商品
            if (no_in_arr.length) {
                for (let ii in no_in_arr) {
                    let item = no_in_arr[ii];
                    if (goods_map[item.goods_id]) {
                        var num = goods_map[item.goods_id];
                        goods_map[item.goods_id] = ++num;
                    } else {
                        goods_map[item.goods_id] = 1;
                    }
                }
            }
            //超量的部分也要计算一下
            if (out_arr.length) {
                for (var m in out_arr) {
                    if (goods_map[item.goods_id]) {
                        var num = goods_map[item.goods_id];
                        num += item.num
                        goods_map[item.goods_id] = num;
                    } else {
                        goods_map[item.goods_id] = item.num;
                    }
                }
            }

            //-- 组合购的商品限购的数组控制 --
            var in_zhact_gdmap={};
            //商品的列表
            for (var u in goods) {
                var ite = goods[u];
                var cart_num = get_num(ite).goods_num;

                if (ite.buyqty > 0 && cart_num > 0) {
                    var key = ite.goods_id + "." + act.id;
                    if(goods_map[ite.goods_id]){
                        cart_num-=goods_map[ite.goods_id];
                    }
                    if(cart_num>0){
                        if (in_zhact_gdmap[key]) {
                            in_zhact_gdmap[key] += ite.num;
                        } else {
                            in_zhact_gdmap[key] = ite.num;
                        }
                    }

                }
            }
            item_act_map.in_zhact_gdmap=in_zhact_gdmap;
            return true;
        }

        if(!need_ok) {
            item_act_map.is_no_ok=1;
            return true;
        }

        return false;
    },
    //-- 判读一下促销分组的问题 --
    //-- is_need_ck_num 是多门店计算的时候，数量是不是要累家计算,主要是拿来计算限购 --
    //-- need_ok是判断要不要满足条件，这是在cart2的时候，才会赋值成1 --
    async cart_cx_group(th,goods,car_item,is_need_ck_num,need_ok,func,is_no_change){

        var os= getApp().globalData.setting;
        //更改活动的时候，就不能再重新计算活动，只有再加减数量和选择商品的时候，就要重新计算活动
        if(th.data.change_act || (car_item.show_can_cx && Object.keys(car_item.show_can_cx).length>0)){
            var show_can_cx=car_item.show_can_cx;
            for(var k in show_can_cx){
                var k_item=show_can_cx[k];
                var ck_prom_type=null;
                //-- 如果是多活动，先把活动按照后台的顺序排序一下，
                //-- 同时确定一下商品最终要用什么活动来购买计算。  --就是要进行切换 --
                if(k_item.act_arr.length>1){
                    var json_d =th.data.json_d;
                    var auto_promote_sale=json_d.auto_promote_sale;
                    var sort_type='';

                    if(!auto_promote_sale){
                        sort_type='prom_type';
                    }else{
                        var auto_promote_sale=auto_promote_sale.split(',');
                        //-- 循环处理 --
                        k_item.act_arr.map(function (e){
                            var fd=auto_promote_sale.indexOf(e.prom_type+'');
                            e.sort=fd;
                        })
                        sort_type='sort';
                    }
                    //-- 排序一下,进行升序 --
                    function comp(a, b) {
                        return a[sort_type]-b[sort_type]; //升序
                    }
                    //活动要排序一下
                    k_item.act_arr.sort(comp);

                    //确定一下活动,先看一下有没有选择的活动
                    ck_prom_type=k_item.act_arr.find(function (el){
                        return el.sele;
                    })

                }
                //-- 此时已经确定了商品的活动是什么类型的，可以确定购物车中商品的具体活动进行金额的计算 --
                if(!ck_prom_type) ck_prom_type=k_item.act_arr[0];

                //-- 此时要把购物车中的商品确定活动 --
                for (var b=0; b<ck_prom_type.goods.length;b++){
                    //-- 开始查找 --
                    var fg=goods.findIndex(function (g_item){
                        return g_item.goods_id==ck_prom_type.goods[b].goods_id && [0,3,5,7,10].indexOf(g_item.prom_type)>-1;
                    })
                    if(fg>-1){

                        goods[fg].goods_price = goods[fg].init_goods_price;
                        goods[fg].prom_type=ck_prom_type.prom_type;
                        goods[fg].prom_id=ck_prom_type.prom_id;

                        if(ck_prom_type.prom_type==3){
                            let ffd=th.data.in_yhact[ck_prom_type.prom_id];
                            let f_price =  goods[fg].goods_price;
                            if (ffd.discount_field != undefined) {
                                switch (ffd.discount_field) {
                                    case 0:
                                        f_price = goods[fg].goods_price;
                                        break;
                                    case 1:
                                        f_price = goods[fg].shop_price;
                                        break;
                                    case 2:
                                        f_price = goods[fg].goods_market_price;
                                        break;
                                }
                            }
                            goods[fg].goods_price = f_price;
                        }
                    }
                }

                //-- 如果是要控制数量的时候，也就是全选的时候，或者加减号的时候 --
                if(ck_prom_type && is_need_ck_num && !ck_prom_type.is_no_ok){
                    var t_pid=ck_prom_type.prom_id;
                    switch (ck_prom_type.prom_type){
                        case 3:
                            if(!th.data.in_yhact_new[t_pid]) th.data.in_yhact_new[t_pid]=0;
                            th.data.in_yhact_new[t_pid]++;
                            break;
                        case 7:
                            if(!th.data.in_zhact_new[t_pid]) th.data.in_zhact_new[t_pid]=0;
                            th.data.in_zhact_new[t_pid]+=ck_prom_type.act_num;
                            //-- 数组的优化 --
                            var nei_gd_map=ck_prom_type.in_zhact_gdmap;
                            if(nei_gd_map){
                                for (var vg in nei_gd_map) {
                                    if (!th.data.in_zhact_gdmap_new[vg]) th.data.in_zhact_gdmap_new[vg] = 0;
                                    th.data.in_zhact_gdmap_new[vg] += nei_gd_map[vg];
                                }
                            }
                            break;
                    }
                }
            }



            func(show_can_cx);
            return false;
        }

        //-- 促销活动对象表,最初的map表，包含活动类型，活动id，goods商品 ---
        var cx_act_map=[];
        for(var i=0; i<goods.length;i++){

            //商品的价格要还原,只有在购物车时候有init_goods_price,因为购物车要还原
            if(goods[i].init_goods_price!=undefined)
                goods[i].goods_price=goods[i].init_goods_price;
            //进行深拷贝
            var c_item=JSON.parse(JSON.stringify(goods[i]));
            //没有选中
            if(!c_item.selected) continue;
            //如果是秒杀之类是商品
            if([1,2,4,6,8,9].indexOf(c_item.prom_type)>-1) continue;
            //如果是搭配的时候商品
            if(c_item.is_collocation) continue;

            //-- 把活动进行规整 --
            var more_cx=c_item.more_cx;
            if(!more_cx) continue;
            for (var j=0;j<more_cx.length;j++){
                var n_item=more_cx[j];
                //--- 当是组合购的时候，这个地方要开始计算限购 is_need_ck_num=1--
                if(n_item.prom_type==7 && is_need_ck_num){
                    //判断是不是限购
                    var zh_gd_fd=n_item.gdlist.find((e1)=>{
                       return e1.goods_id==c_item.goods_id && e1.buyqty>0
                    })

                    var  in_zhact_gdmap_new=th.data.in_zhact_gdmap_new;
                    var key = c_item.goods_id + "." + n_item.prom_id;

                    //如果是组合购
                    if(zh_gd_fd && in_zhact_gdmap_new[key] && in_zhact_gdmap_new[key]>=zh_gd_fd.buyqty){
                       continue;
                    }
                }


                var key=n_item.prom_type+'-'+n_item.prom_id;
                var fd=cx_act_map.find(function (e){
                    return e.key==key;
                })
                if(fd){
                    fd.goods.push(c_item);
                }else{
                    var p_item={key:key,prom_type:n_item.prom_type,prom_id:n_item.prom_id,goods:[],act:n_item};
                    if(n_item.prom_type==7){
                        p_item.zh_pro=n_item.zh_pro;
                    }
                    p_item.goods.push(c_item);
                    cx_act_map.push(p_item);
                }
            }

            if(th.data.is_cart){
                goods[i].prom_type=0;
                goods[i].prom_id=0;
            }

        }
        //-- 如果活动数量大于1个，那么活动就要排序一下，有商品种类数最多排再前面，降序进行排列 --
        if(cx_act_map.length>1){
            //门店分类要排序下
            function compare(a, b) {
                var value1 = a.goods.length;
                var value2 = b.goods.length;
                return value2 - value1;
            }
            cx_act_map.sort(compare);
        }
        //-- 能够进行最后计算的活动(包含切换) --
        var can_calc_cx=[];
        //-- 此时对数组的活动进行判断，看能不能达到购买数量的条件 --
        for(var ii=0;ii<cx_act_map.length;ii++){

            var item_act_map=cx_act_map[ii];
            //如果活动有交集的时候，商品数量一样多（不是完全相同时，就是参与的商品有交集），就按照后台确定的活动顺序
            //如果活动商品数量少的和  活动数量多的 有交集，那么数量少的不显示，也不计算
            //如果活动的商品一样（那就是多活动切换），优先计算的活动按照后台确定的活动顺序
            if(!this.check_ok_cx_pro(item_act_map,can_calc_cx)){
                continue;
            }
            switch(item_act_map.prom_type){
                case 3:
                    //活动ID
                    var aid=item_act_map.prom_id;
                    var need_num=0;
                    //-- 这个时候要判断是不是要判断优惠促销多门店的时候的限购 --
                    if(is_need_ck_num){
                        need_num=th.data.in_yhact_new[aid]?th.data.in_yhact_new[aid]:0;
                    }
                    //-- 判断优惠促销要不要限购 --
                    var fd=th.data.in_yhact[aid];
                    if(!fd && th.data.yhcx_act_map && th.data.yhcx_act_map[aid] ){
                        fd=th.data.yhcx_act_map[aid];
                        th.data.in_yhact[aid]=fd;
                    }
                    if(!fd) {
                        var fd_res = await getApp().request.promiseGet('/api/weshop/promgoods/get/' + os.stoid + '/' + aid, {})
                        if (fd_res && fd_res.data.code == 0) {
                            fd = fd_res.data.data;
                            th.data.in_yhact[aid]=fd;
                        }
                    }
                    //如果有限购的时候，也要计算一下
                    if (fd && fd['limit_num'] > 0){
                        // 优惠的促销的限购要反写进去不和
                        item_act_map.limit_num=fd['limit_num'];
                        if(fd.hasOwnProperty('buyed')){
                            item_act_map.buyed= fd.buyed;
                        }else{
                            //-- 获取已经购买了多少件 --
                            var url = "/api/weshop/ordergoods/getUserBuyPromNum?store_id="+os.stoid+"&user_id="
                                +getApp().globalData.user_id+"&prom_type=3&prom_id="+aid;
                            await getApp().request.promiseGet(url, {}).then(rh => {
                                if(rh.data.code==0){
                                    item_act_map.buyed=rh.data.data.userbuynum;
                                    fd.buyed=rh.data.data.userbuynum;
                                    th.data.in_yhact[aid].buyed=rh.data.data.userbuynum;
                                }
                            })
                        }

                        if(item_act_map.buyed+need_num>=fd['limit_num']){
                            continue; //-- 进行下一个循环 --
                        }
                    }



                    var fir_act=item_act_map.act.fir_act;
                    var t_goods=item_act_map.goods;
                    var all_num=0;
                    var all_pri=0;
                    for(var f=0;f<t_goods.length;f++){
                        all_num+=t_goods[f].goods_num;

                        if(is_no_change!=1) {
                            //-- 优惠促销取价的优化 --
                            let f_price = t_goods[f].goods_price;
                            if (fd.discount_field != undefined) {
                                switch (fd.discount_field) {
                                    case 0:
                                        f_price = t_goods[f].goods_price;
                                        break;
                                    case 1:
                                        f_price = t_goods[f].shop_price;
                                        break;
                                    case 2:
                                        f_price = t_goods[f].goods_market_price;
                                        break;
                                }
                            }
                            t_goods[f].goods_price = f_price;
                        }

                        all_pri+=t_goods[f].goods_num*t_goods[f].goods_price;
                    }
                    var yh_ok=1;
                    switch (fir_act.prom_type){
                        case 0:
                          if(all_pri<fir_act.condition) {
                            yh_ok=0;
                          }
                          break;
                        case 1:
                          if(all_num<fir_act.condition) {
                            yh_ok=0;
                          }
                          break;
                    }
                    //-- 如果有满足优惠条件的时候 --
                    if(yh_ok){
                       can_calc_cx.push(item_act_map)
                    }else{
                        if(!need_ok){
                            item_act_map.is_no_ok=1;
                            can_calc_cx.push(item_act_map);
                        }
                    }
                    break

                case 7:
                    //-- 活动列表 --
                    var zhact_gdlist=item_act_map.act.gdlist;
                    var zh_goods=item_act_map.goods;
                    //--- 要循环计算一下商品的已购数量 ---
                    for(var h=0;h<zh_goods.length;h++){
                        if(zh_goods[h].zh_b_num) continue;
                        var ky=item_act_map.prom_id+"."+zh_goods[h].goods_id;
                        if(th.data.in_zh_gd_buy_map[ky]){
                            zh_goods[h].zh_b_num=th.data.in_zh_gd_buy_map[ky];
                        }else{
                            //-- 商品的限购 --
                            var promgoodsbuynum = 0;
                            var res=await getApp().request.promiseGet("/api/weshop/ordergoods/getUserBuyGoodsNum", {
                                data: {
                                    store_id: os.stoid,
                                    user_id: getApp().globalData.user_id,
                                    goods_id: zh_goods[h].goods_id,
                                    prom_type: 7,
                                    prom_id: item_act_map.prom_id, isnew:1
                                },
                            })
                            if(res.data.code==0 && res.data.data && res.data.data.promgoodsbuynum){
                                promgoodsbuynum = res.data.data.promgoodsbuynum;
                            }
                            zh_goods[h].zh_b_num=promgoodsbuynum;
                            th.data.in_zh_gd_buy_map[ky]=promgoodsbuynum;
                        }
                    }

                    //-- 放到参与组合优惠促销的map中 --
                    th.data.zuhe_map_good[item_act_map.prom_id] = zhact_gdlist;
                    if(!car_item.zh_prom_goods) car_item.zh_prom_goods={};
                    car_item.zh_prom_goods[item_act_map.prom_id] = zhact_gdlist;

                    //-- 兼容购物车和确认订单的页面 --
                    var ob=th.data.zuhe_map;
                    if(!ob) ob=th.data.zhhe_act_map;

                    var zh_pro0 = ob[item_act_map.prom_id];
                    if(zh_pro0.hasOwnProperty('buyed')){
                        item_act_map.buyed=zh_pro0.buyed;
                    }else {
                        //-- 获取活动信息 --
                        var url = "/api/weshop/ordergoods/getUserBuyPromNum?store_id="+os.stoid+"&user_id="
                            +getApp().globalData.user_id+"&prom_type=7&prom_id="+zh_pro0.id;
                        await getApp().request.promiseGet(url, {}).then(rh => {
                            if(rh.data.code==0){
                                item_act_map.buyed=rh.data.data.userbuynum;
                                zh_pro0.buyed=rh.data.data.userbuynum;
                            }
                        })
                    }

                    //当满足组合的要求：总数要满足，起购数要满足
                    if(this.ch_zh_ok(zh_pro0,zhact_gdlist,zh_goods,th,item_act_map,is_need_ck_num,need_ok)){
                        can_calc_cx.push(item_act_map)
                    }
                    break;
                default:
                    can_calc_cx.push(item_act_map);
            }

        }

        //-- 此时来给满足条件的活动进行分组~~相同参与商品和数量的归纳再一起， --
        //-- 同时相同商品数量的活动，还要看取那一个来进行计算金额。  默认的时候是按照后台的顺序。--
        //-- 有选择的时候，就按照切换选择了什么就按照什么来计算 --
        //-- can_calc_cx的元素（item_act_map）最后是放到act_arr里面去了 --
        var show_can_cx={};
        if(can_calc_cx.length){
            for(var p=0;p<can_calc_cx.length;p++){
                var ch_map=[];
                can_calc_cx[p].goods.map(function (gd){
                    ch_map.push(gd.goods_id);
                })
                //ch_map.sort();
                //-- 先找一下，有没有参与的商品一模一样的 --
                var fd=show_can_cx[ch_map.join()];
                if(fd){
                    //-- 把数组添加进去 --ch_map
                    fd.act_arr.push(can_calc_cx[p])
                }else{
                    var e={ch_map:ch_map,act_arr:[]};
                    if(ch_map.length>1){
                        e.is_duo_gd=1;
                    }
                    e.act_arr.push(can_calc_cx[p]);
                    show_can_cx[ch_map.join()]=e;
                }
            }
        }

        for(var k in show_can_cx){
            var k_item=show_can_cx[k];
            var ck_prom_type=null;
            //-- 如果是多活动，先把活动按照后台的顺序排序一下，
            //-- 同时确定一下商品最终要用什么活动来购买计算。  --就是要进行切换 --
            if(k_item.act_arr.length>1){
                var json_d =th.data.json_d;
                var auto_promote_sale=json_d.auto_promote_sale;
                var sort_type='';

                if(!auto_promote_sale){
                    sort_type='prom_type';
                }else{
                    var auto_promote_sale=auto_promote_sale.split(',');
                    //-- 循环处理 --
                    k_item.act_arr.map(function (e){
                        var fd=auto_promote_sale.indexOf(e.prom_type+'');
                        e.sort=fd;
                    })
                    sort_type='sort';
                }
                //-- 排序一下,进行升序 --
                function comp(a, b) {
                    return a[sort_type]-b[sort_type]; //升序
                }
                //活动要排序一下
                k_item.act_arr.sort(comp);

                //-- 看一下是不是组合购 -- 点击 --如果是从活动链接过来的，点亮 --,新增优化2024-1-20
                if(th.data.from_act_link){
                    var fd_idx=k_item.act_arr.findIndex(function (eh){
                        return eh.prom_type==th.data.from_act_link.prom_type && eh.prom_id==th.data.from_act_link.prom_id;
                    })

                    if(fd_idx>-1) {
                        ck_prom_type= k_item.act_arr[fd_idx];
                        for (var idf = 0; idf < k_item.act_arr.length; idf++) {
                            if(fd_idx==idf){
                                k_item.act_arr[idf].sele=1;
                            }else{
                                k_item.act_arr[idf].sele=0;
                            }
                        }
                    }
                }

                //确定一下活动,先看一下有没有选择的活动
                ck_prom_type=k_item.act_arr.find(function (el){
                    return el.sele;
                })

                //-- 看一下是不是购物车已经选择好了，购物车选择好了，再确认订单页面也应该是购物车选择的结果,这个也很重要 --
                if(!ck_prom_type && th.data && ! th.data.is_cart){
                    for(var ij=0;ij<k_item.act_arr.length;ij++){
                         var act_gd=k_item.act_arr[ij].goods[0];
                         if(act_gd.prom_type==k_item.act_arr[ij].prom_type){
                             k_item.act_arr[ij].sele=1;
                             ck_prom_type= k_item.act_arr[ij];
                             k_item.cur_act=ck_prom_type;
                             k_item.sele_prom_type=ck_prom_type.prom_type;
                         }
                    }
                }
            }

            //-- 此时已经确定了商品的活动是什么类型的，可以确定购物车中商品的具体活动进行金额的计算 --
            if(!ck_prom_type){
                ck_prom_type=k_item.act_arr[0];
                k_item.act_arr[0].sele=1;
                //-- 把当前活动进行赋值 --
                k_item.cur_act=ck_prom_type;
                k_item.sele_prom_type=ck_prom_type.prom_type;
            }

            //-- 如果是要控制数量的时候，也就是全选的时候，或者加减号的时候 --
            if(is_need_ck_num && !ck_prom_type.is_no_ok){
                var t_pid=ck_prom_type.prom_id;
                switch (ck_prom_type.prom_type){
                    case 3:
                        if(!th.data.in_yhact_new[t_pid]) th.data.in_yhact_new[t_pid]=0;
                        th.data.in_yhact_new[t_pid]++;
                        break;
                    case 7:
                        if(!th.data.in_zhact_new[t_pid]) th.data.in_zhact_new[t_pid]=0;
                        th.data.in_zhact_new[t_pid]+=ck_prom_type.act_num;
                        //-- 数组的优化 --
                        var nei_gd_map=ck_prom_type.in_zhact_gdmap;
                        if(nei_gd_map){
                            for (var vg in nei_gd_map) {
                                if (!th.data.in_zhact_gdmap_new[vg]) th.data.in_zhact_gdmap_new[vg] = 0;
                                th.data.in_zhact_gdmap_new[vg] += nei_gd_map[vg];
                            }
                        }
                        break;
                }
            }
            //-- 此时要把购物车中的商品确定活动 --
            for (var b=0; b<ck_prom_type.goods.length;b++){
                //-- 开始查找 --
                var fg=goods.findIndex(function (g_item){
                    return g_item.goods_id==ck_prom_type.goods[b].goods_id && [0,3,5,7,10].indexOf(g_item.prom_type)>-1;
                })
                if(fg>-1){
                    goods[fg].prom_type=ck_prom_type.prom_type;
                    goods[fg].prom_id=ck_prom_type.prom_id;

                    if(ck_prom_type.prom_type==3 && (is_no_change!=2 || ck_prom_type.is_no_ok!=1) ){
                        let ffd=th.data.in_yhact[ck_prom_type.prom_id];
                        let f_price =  goods[fg].goods_price;
                        if (ffd.discount_field != undefined) {
                            switch (ffd.discount_field) {
                                case 0:
                                    f_price = goods[fg].goods_price;
                                    break;
                                case 1:
                                    f_price = goods[fg].shop_price;
                                    break;
                                case 2:
                                    f_price = goods[fg].goods_market_price;
                                    break;
                            }
                        }
                        goods[fg].goods_price = f_price;
                    }
                }
            }
        }
        //-- 显示到前端，并切换 --
        //th.setData({show_can_cx})
        //--- 调用回调函数 ---
        func(show_can_cx);

    },
    //-- 查看活动参与的商品是不是有重复交集的地方，是不是一样的商品数量，can_calc_cx这个数组也是按照商品的数量降序排列的--
    check_ok_cx_pro(item_act_map,can_calc_cx){
        //-- 加入第一个，返回真 --
        if(!can_calc_cx.length) return true;
        var th_goods=item_act_map.goods;
        for(var i=0;i<can_calc_cx.length;i++){
            var can_goods=can_calc_cx[i].goods;
            //计算一下有交集的数量,没有交集，OK
            var num=this.hasJiao(can_goods,th_goods);
            if(!num) continue;
            //计算一下俩个shu
            if(can_goods.length==th_goods.length && can_goods.length==num){
                return true;
            }
            if(can_goods.length>th_goods.length){
                return false;
            }
        }
        return true;
    },
    //-- 判断是不是有交集,返回交集的数量 --
    hasJiao(arr1, arr2){
        var num=0;
        arr1.map(function (e){
            var idx=arr2.findIndex(function (g){
                return g.goods_id==e.goods_id;
            })
            if(idx>-1) num++;
        })
        return num;
    },


}