package com.fs.task;


import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.fs.common.core.domain.R;
import com.fs.common.core.redis.RedisCache;
import com.fs.common.event.TemplateBean;
import com.fs.common.event.TemplateEvent;
import com.fs.common.event.TemplateListenEnum;
import com.fs.company.domain.CompanyUser;
import com.fs.company.mapper.CompanyUserMapper;
import com.fs.company.domain.CompanyUser;
import com.fs.company.service.ICompanyService;
import com.fs.core.security.SecurityUtils;
import com.fs.crm.mapper.CrmCustomerMapper;
import com.fs.erp.domain.ErpDeliverys;
import com.fs.erp.domain.ErpGoods;
import com.fs.erp.domain.ErpOrderItem;
import com.fs.erp.domain.ErpOrderQuery;
import com.fs.erp.dto.*;
import com.fs.erp.service.IErpGoodsService;
import com.fs.erp.service.IErpOrderService;
import com.fs.huifuPay.domain.HuiFuCreateOrder;
import com.fs.huifuPay.domain.HuifuCreateOrderResult;
import com.fs.huifuPay.service.HuiFuService;
import com.fs.pay.pay.domain.CreateWxOrderResult;
import com.fs.pay.pay.domain.OrderResult;
import com.fs.pay.pay.dto.OrderQueryDTO;
import com.fs.pay.pay.dto.WxJspayDTO;
import com.fs.pay.pay.service.PayService;
import com.fs.pay.pay.service.impl.PayApiServiceImpl;
import com.fs.store.config.StoreConfig;
import com.fs.store.domain.*;
import com.fs.store.dto.ExpressInfoDTO;
import com.fs.store.dto.FsStoreCartDTO;
import com.fs.store.dto.StoreProductGroupDTO;
import com.fs.store.enums.OrderInfoEnum;
import com.fs.store.enums.OrderLogEnum;
import com.fs.store.enums.ShipperCodeEnum;
import com.fs.store.mapper.*;
import com.fs.store.param.*;
import com.fs.store.service.*;
import com.fs.store.vo.FsStoreOrderItemVO;
import com.fs.store.vo.FsStoreOrderTuiVO;
import com.fs.store.vo.FsStoreOrderVO;
import com.fs.store.vo.FsUserShareVO;
import com.fs.system.service.ISysConfigService;
import com.sun.media.sound.SF2GlobalRegion;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.annotations.Param;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;

import static com.fs.store.constants.StoreConstants.DELIVERY;

/**
 * 定时任务调度测试
 *
 * @author fs
 */
@Component("storeTask")
public class StoreTask {
    Logger logger = LoggerFactory.getLogger(StoreTask.class);
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private RedisCache redisCache;
    @Autowired
    IFsStoreOrderService orderService;
    @Autowired
    private IFsStoreCouponUserService couponUserService;
    @Autowired
    IFsStoreAfterSalesService afterSalesService;
    @Autowired
    IFsUserService userService;

    @Autowired
    IErpOrderService erpOrderService;

    @Autowired
    PayService ybPayService;
    @Autowired
    private FsStoreOrderMapper fsStoreOrderMapper;

    @Autowired
    private IFsStoreOrderService fsStoreOrderService;

    @Autowired
    private IFsStoreOrderItemService storeOrderItemService;

    @Autowired
    private FsStorePaymentMapper fsStorePaymentMapper;

    @Autowired
    private CrmCustomerMapper crmCustomerMapper;
    @Autowired
    private IErpGoodsService goodsService;
    @Autowired
    private ApplicationEventPublisher publisher;

    public void tt() {
        ErpGoodsStockQueryRequert request = new ErpGoodsStockQueryRequert();
        request.setBarcode("105201");
        ErpGoodsStockQueryResponse response = goodsService.getGoodsStock(request);
        ErpGoodsQueryRequert erpGoodsQueryRequert = new ErpGoodsQueryRequert();
        erpGoodsQueryRequert.setCode("105201");
        ErpGoodsQueryResponse goods = goodsService.getGoods(erpGoodsQueryRequert);

        System.out.println(goods);
        System.out.println(response);
    }

    //每5分钟执行一次
    public void deliveryOp() {
        Set<String> orders = redisTemplate.keys(DELIVERY + ":*");
        for (String extndOrderId : orders) {
            String orderCode = (String) redisTemplate.opsForValue().get(extndOrderId);
            ErpOrderQueryRequert request = new ErpOrderQueryRequert();
            String[] extendOrder = extndOrderId.split(":");
            request.setCode(extendOrder[1]);
            ErpOrderQueryResponse response = erpOrderService.getOrder(request);
            if (CollectionUtils.isNotEmpty(response.getOrders())) {
                for (ErpOrderQuery orderQuery : response.getOrders()) {
                    if (CollectionUtils.isNotEmpty(orderQuery.getDeliverys())) {
                        // 部分发货或者全部发货
                        if (ObjectUtils.equals(orderQuery.getDelivery_state(), 1) || ObjectUtils.equals(orderQuery.getDelivery_state(), 2)) {
                            // 订单状态变更
                            FsStoreOrder order = fsStoreOrderMapper.selectFsStoreOrderByOrderCode(orderCode);
                            orderStatusService.create(order.getId(), OrderLogEnum.DELIVERY_GOODS.getValue(),
                                    OrderLogEnum.DELIVERY_GOODS.getDesc());
                            //更新商订单状态 删除REDIS
                            redisCache.deleteObject(DELIVERY + ":" + extendOrder[1]);

                            for (ErpDeliverys delivery : orderQuery.getDeliverys()) {
                                if (delivery.getDelivery()) {
                                    orderService.deliveryOrder(orderCode, delivery.getMail_no(),
                                            delivery.getExpress_code(), delivery.getExpress_name());
                                }
                            }
                        }
                    }
                }
            }
        }

    }

    @Autowired
    FsUserTuiMoneyRankMapper fsUserTuiMoneyRankMapper;

    private FsUserAddressMapper addressMapper;

    public void addUserTuiMoneyRank() {
        List<FsUserShareVO> fsUserShareVOS1 = fsUserTuiMoneyRankMapper.selectFsUserTuiMoneyRankByType(1);
        fsUserTuiMoneyRankMapper.deleteFsUserTuiMoneyRankByType(1);
        Long id = 1L;
        int rank = 1;
        for (FsUserShareVO vo : fsUserShareVOS1) {
            FsUserTuiMoneyRank userRank = new FsUserTuiMoneyRank();
            userRank.setAvatar(vo.getAvatar());
            userRank.setUserId(vo.getUserId());
            userRank.setTuiMoney(vo.getTuiMoney());
            userRank.setType(1);
            userRank.setId(id);
            userRank.setSort(rank);
            userRank.setNickname(vo.getNickname());
            userRank.setPhone(vo.getPhone());
            fsUserTuiMoneyRankMapper.insertFsUserTuiMoneyRank(userRank);
            rank++;
            id++;
        }


        List<FsUserShareVO> fsUserShareVOS2 = fsUserTuiMoneyRankMapper.selectFsUserTuiMoneyRankByType(2);
        fsUserTuiMoneyRankMapper.deleteFsUserTuiMoneyRankByType(2);
        rank = 1;
        for (FsUserShareVO vo : fsUserShareVOS2) {
            FsUserTuiMoneyRank userRank = new FsUserTuiMoneyRank();
            userRank.setAvatar(vo.getAvatar());
            userRank.setUserId(vo.getUserId());
            userRank.setSort(rank);
            userRank.setTuiMoney(vo.getTuiMoney());
            userRank.setType(2);
            userRank.setId(id);
            userRank.setNickname(vo.getNickname());
            userRank.setPhone(vo.getPhone());
            fsUserTuiMoneyRankMapper.insertFsUserTuiMoneyRank(userRank);
            rank++;
            id++;
        }
        List<FsUserShareVO> fsUserShareVOS3 = fsUserTuiMoneyRankMapper.selectFsUserTuiMoneyRankByType(3);
        fsUserTuiMoneyRankMapper.deleteFsUserTuiMoneyRankByType(3);
        rank = 1;
        for (FsUserShareVO vo : fsUserShareVOS3) {
            FsUserTuiMoneyRank userRank = new FsUserTuiMoneyRank();
            userRank.setAvatar(vo.getAvatar());
            userRank.setUserId(vo.getUserId());
            userRank.setSort(rank);
            userRank.setTuiMoney(vo.getTuiMoney());
            userRank.setType(3);
            userRank.setId(id);
            userRank.setNickname(vo.getNickname());
            userRank.setPhone(vo.getPhone());
            fsUserTuiMoneyRankMapper.insertFsUserTuiMoneyRank(userRank);
            rank++;
            id++;
        }
    }

    @Autowired
    IErpGoodsService erpGoodsService;
    @Autowired
    ISysConfigService configService;
    @Autowired
    private FsStoreProductAttrValueMapper fsStoreProductAttrValueMapper;

    @Autowired
    private IFsStoreProductGroupService storeProductGroupService;

    public void storeProdUpdateCostPrice() {
        String json = configService.selectConfigByKey("store.config");
        StoreConfig config = JSONUtil.toBean(json, StoreConfig.class);
        List<FsStoreProductAttrValue> values = fsStoreProductAttrValueMapper.selectFsStoreProductAttrValueList(new FsStoreProductAttrValue());
        int i = 0;
        for (FsStoreProductAttrValue value : values) {
            try {
                if (StringUtils.isNotEmpty(value.getBarCode())) {
                    ErpGoodsQueryRequert query = new ErpGoodsQueryRequert();
                    query.setCode(value.getBarCode());
                    ErpGoodsQueryResponse goods = erpGoodsService.getGoods(query);
                    List<ErpGoods> items = goods.getItems();
                    if (items != null && items.size() > 0) {
                        ErpGoods erpGoods = items.get(0);
                        BigDecimal salesPrice = erpGoods.getSales_price();
                        if (salesPrice != null && salesPrice.compareTo(BigDecimal.ZERO) != 0) {
                            BigDecimal divide = salesPrice.multiply(new BigDecimal(config.getSalesPriceRate())).divide(new BigDecimal("100"));
                            logger.info("商品id" + value.getId() + "商品成本：" + salesPrice + "代理价" + divide);
                            FsStoreProductAttrValue va = new FsStoreProductAttrValue();
                            va.setCost(salesPrice);
                            va.setPrice(divide);
                            va.setId(value.getId());
                            fsStoreProductAttrValueMapper.updateFsStoreProductAttrValue(va);
                            i++;
                        }
                    }
                } else if (StringUtils.isNotEmpty(value.getGroupBarCode())) {
                    FsStoreProductGroup group = storeProductGroupService.selectFsStoreProductGroupByBarCode(value.getGroupBarCode());
                    if (group != null) {
                        JSONArray jsonArray = JSONUtil.parseArray(group.getProducts());
                        List<StoreProductGroupDTO> productGroupDTOS = JSONUtil.toList(jsonArray, StoreProductGroupDTO.class);
                        if (productGroupDTOS != null) {
                            for (StoreProductGroupDTO dto : productGroupDTOS) {
                                FsStoreProductAttrValue attrValue = fsStoreProductAttrValueMapper.selectFsStoreProductAttrValueById(dto.getId());
                                Integer count = dto.getCount();
                                String barCode = attrValue.getBarCode();
                                ErpGoodsQueryRequert query = new ErpGoodsQueryRequert();
                                query.setCode(barCode);
                                ErpGoodsQueryResponse goods = erpGoodsService.getGoods(query);
                                List<ErpGoods> items = goods.getItems();
                                if (items != null && items.size() > 0) {
                                    ErpGoods erpGoods = items.get(0);
                                    BigDecimal salesPrice = erpGoods.getSales_price();
                                    if (salesPrice != null && salesPrice.compareTo(BigDecimal.ZERO) != 0) {
                                        salesPrice = salesPrice.multiply(new BigDecimal(count));
                                        BigDecimal divide = salesPrice.multiply(new BigDecimal(config.getSalesPriceRate())).divide(new BigDecimal("100"));
                                        logger.info("商品id" + value.getId() + "商品成本：" + salesPrice + "代理价" + salesPrice);
                                        FsStoreProductAttrValue va = new FsStoreProductAttrValue();
                                        va.setCost(salesPrice);
                                        va.setAgentPrice(divide);
                                        va.setId(value.getId());
                                        fsStoreProductAttrValueMapper.updateFsStoreProductAttrValue(va);
                                        i++;
                                    }
                                }

                            }
                        }
                    }

                }
            } catch (Exception e) {
                logger.info("商品更新成本价错误：" + value.getId());
            }


        }
        logger.info("更新商品成本价:" + i);


    }

    public void couponOp() {
        couponUserService.updateFsCouponByExpire();

    }


    //退款自动处理 24小时未审核自动审核通过 每小时执行一次
    public void refundOp() {
        //获取所有退款申请
        List<FsStoreAfterSales> list = afterSalesService.selectFsStoreAfterSalesByDoAudit();
        if (list != null) {
            for (FsStoreAfterSales afterSales : list) {
                //仅退款
                if (afterSales.getServiceType().equals(0)) {
                    FsStoreAfterSalesAudit1Param audit1Param = new FsStoreAfterSalesAudit1Param();
                    audit1Param.setSalesId(afterSales.getId());
                    audit1Param.setOperator("平台");
                    afterSalesService.audit1(audit1Param);
                }
            }
        }
    }


    //每天执行一次
    public void userMoneyOp() {
        List<FsStoreOrder> list = orderService.selectFsStoreOrderListByFinish7Day();
        if (list != null) {
            for (FsStoreOrder order : list) {
                userService.addMoney(order);
            }
        }
    }


    //每30秒执行一次
    public void orderItemSyncOp() {
        List<FsStoreOrder> list = fsStoreOrderService.selectFsStoreOrderItemJson();
        for (FsStoreOrder storeOrder : list) {
            FsStoreOrderItem parmOrderItem = new FsStoreOrderItem();
            parmOrderItem.setOrderId(storeOrder.getId());
            List<FsStoreOrderItem> listOrderItem = storeOrderItemService.selectFsStoreOrderItemList(parmOrderItem);
            if (listOrderItem.size() > 0) {
                String itemJson = JSONUtil.toJsonStr(listOrderItem);
                storeOrder.setItemJson(itemJson);
                fsStoreOrderMapper.uploadItemJson(storeOrder);
            }
        }
    }

    public void returnDeliveryId() {
        List<String> list = fsStoreOrderMapper.selectErpCode();
        for (String s : list) {
            ErpOrderQueryRequert request = new ErpOrderQueryRequert();
            request.setCode(s);
            ErpOrderQueryResponse response = erpOrderService.getOrder(request);
            if (response.getOrders() != null && response.getOrders().size() > 0) {
                for (ErpOrderQuery orderQuery : response.getOrders()) {
                    if (orderQuery.getDeliverys() != null && orderQuery.getDeliverys().size() > 0) {
                        for (ErpDeliverys delivery : orderQuery.getDeliverys()) {
                            if (delivery.getDelivery() && StringUtils.isNotEmpty(delivery.getMail_no())) {
                                FsStoreOrder order = new FsStoreOrder();
                                order.setExtendOrderId(s);
                                order.setDeliveryId(delivery.getMail_no());
                                order.setStatus(2);
                                fsStoreOrderMapper.updateDelivery(order);
                            }
                        }
                    }
                }
            }


        }

    }

    @Autowired
    private IFsExpressService expressService;

    @Deprecated
    public void changeStatus() {
        List<Long> list = fsStoreOrderMapper.selectOrderId();
        for (Long orderId : list) {
            FsStoreOrder order = fsStoreOrderMapper.selectFsStoreOrderById(orderId);
            String lastFourNumber = "";
            if (order.getDeliverySn().equals(ShipperCodeEnum.SF.getValue())) {
                lastFourNumber = order.getUserPhone();
                if (lastFourNumber.length() == 11) {
                    lastFourNumber = StrUtil.sub(lastFourNumber, lastFourNumber.length(), -4);
                }
            }
            ExpressInfoDTO dto = expressService.getExpressInfo(order.getOrderCode(), order.getDeliverySn(), order.getDeliveryId(), lastFourNumber);
            FsStoreOrder map = new FsStoreOrder();
            map.setDeliveryStatus(Integer.parseInt(dto.getState()));
            map.setId(order.getId());
            map.setDeliveryType(dto.getStateEx());
            fsStoreOrderMapper.updateFsStoreOrder(map);
        }
    }

    @Autowired
    private FsStorePaymentMapper paymentMapper;
    @Autowired
    private IFsStorePaymentService fsStorePaymentService;
    @Autowired
    private ICompanyService companyService;

    public void subCompanyMoney() {
        List<Long> list = paymentMapper.selectPaymentIds();
        for (Long paymentId : list) {
            FsStorePayment payment = fsStorePaymentService.selectFsStorePaymentById(paymentId);
            if (payment.getCompanyId() != null && payment.getCompanyId() > 0) {
                companyService.subCompanyPaymentMoney(payment);
            }
        }
    }

    @Autowired
    private FsStoreOrderItemMapper itemMapper;

    public void updateOrderItem() throws ParseException {
        List<Long> ids = itemMapper.selectOrderIdByNoErp();
        for (Long id : ids) {
            fsStoreOrderService.createOmsOrder(id);
        }
    }


    //每天执行一次
    public void syncExpress() {
        List<Long> ids = fsStoreOrderMapper.selectSyncExpressIds();

        for (Long id : ids) {
            FsStoreOrderExpressEditParam param = new FsStoreOrderExpressEditParam();
            param.setOrderId(id);
            fsStoreOrderService.syncExpress(param);
        }

    }

    public void returnPayStatus() {
        List<String> ids = fsStorePaymentMapper.selectPayStatusIds();
        for (String id : ids) {
            OrderQueryDTO o = new OrderQueryDTO();
            o.setUpOrderId(id);
            OrderResult orderResult = ybPayService.getOrder(o);
            if ("0".equals(orderResult.getState())) {
                String[] order = orderResult.getLowOrderId().split("-");
                if (orderResult.getStatus().equals("100")) {
                    switch (order[0]) {
                        case "store":
                            orderService.payConfirm(1, null, order[1], o.getUpOrderId(), orderResult.getBankTrxId(), orderResult.getBankOrderId());
                        case "store_remain":
                            orderService.payRemainConfirm(order[1], o.getUpOrderId(), orderResult.getBankTrxId(), orderResult.getBankOrderId());
                        case "payment":
                            fsStorePaymentService.payConfirm(order[1], o.getUpOrderId(), orderResult.getBankTrxId(), orderResult.getBankOrderId());
                    }

                }
            }

        }

    }

    public void AddTuiMoney() {
        List<Long> ids = fsStoreOrderMapper.selectAddTuiMoney();
        for (Long id : ids) {
            FsStoreOrderAddTuiMoneyParam param = new FsStoreOrderAddTuiMoneyParam();
            param.setOrderId(id);
            fsStoreOrderService.addTuiMoney(param);
        }

    }

    @Autowired
    private IFsStoreAfterSalesService fsStoreAfterSalesService;

    public void selectPayMoneyLessOne() {
        List<FsStoreOrder> list = fsStoreOrderMapper.selectPayMoneyLessOne();
        for (FsStoreOrder order : list) {
            FsStoreAfterSalesParam param = new FsStoreAfterSalesParam();
            param.setOrderCode(order.getOrderCode());
            param.setServiceType(0);
            param.setRefundAmount(order.getPayMoney());
            param.setReasons("超时未处理，自动申请退款");
            List<FsStoreAfterSalesProductParam> productParams = new ArrayList<>();
            List<FsStoreOrderItem> items = fsStoreOrderMapper.selectOrderItem(order.getId());
            for (FsStoreOrderItem item : items) {
                FsStoreAfterSalesProductParam param1 = new FsStoreAfterSalesProductParam();
                param1.setProductId(item.getProductId());
                param1.setNum(item.getNum());
                productParams.add(param1);
            }
            param.setProductList(productParams);
            fsStoreAfterSalesService.autoApplyForAfterSales(order.getUserId(), param);
        }
    }


    @Autowired
    private CompanyUserMapper companyUserMapper;

    public void updateCompanyUserStatus() {
        CompanyUser user = new CompanyUser();
        user.setStatus("0");
        user.setDelFlag("0");
        List<CompanyUser> companyUsers = companyUserMapper.selectCompanyUserList(user);
        for (CompanyUser companyUser : companyUsers) {
            if (SecurityUtils.matchesPassword("123456", companyUser.getPassword())) {
                companyUser.setStatus("1");
                companyUserMapper.updateCompanyUser(companyUser);
                logger.info("密码为123456 停用账号：" + companyUser.getUserId() + ":" + companyUser.getNickName());
            }
        }
    }

    public void deleteCustomer() {

    }

    @Autowired
    private IFsStoreOrderStatusService orderStatusService;

    public void updateExpress() {
        List<FsStoreOrder> list = fsStoreOrderMapper.selectUpdateExpress();
        for (FsStoreOrder order : list) {
            ErpOrderQueryRequert request = new ErpOrderQueryRequert();
            request.setCode(order.getExtendOrderId());
            ErpOrderQueryResponse response = erpOrderService.getOrder(request);
            if (CollectionUtils.isNotEmpty(response.getOrders())) {
                for (ErpOrderQuery orderQuery : response.getOrders()) {
                    // 部分发货或者全部发货
                    if (ObjectUtils.equals(orderQuery.getDelivery_state(), 1) || ObjectUtils.equals(orderQuery.getDelivery_state(), 2)) {
                        // 订单状态变更
                        orderStatusService.create(order.getId(), OrderLogEnum.DELIVERY_GOODS.getValue(),
                                OrderLogEnum.DELIVERY_GOODS.getDesc());

                        redisCache.deleteObject(DELIVERY+":"+order.getExtendOrderId());

                        for (ErpDeliverys delivery : orderQuery.getDeliverys()) {
                            if (delivery.getDelivery()) {
                                orderService.deliveryOrder(order.getOrderCode(), delivery.getMail_no(),
                                        delivery.getExpress_code(), delivery.getExpress_name());
                            }
                        }
                    }
                }
            }
        }
    }






}
