package com.fs.task;


import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.fs.common.core.redis.RedisCache;
import com.fs.company.service.ICompanyService;
import com.fs.course.service.IFsCourseWatchLogService;
import com.fs.erp.domain.ErpDeliverys;
import com.fs.erp.domain.ErpGoods;
import com.fs.erp.domain.ErpOrderQuery;
import com.fs.erp.dto.ErpGoodsQueryRequert;
import com.fs.erp.dto.ErpGoodsQueryResponse;
import com.fs.erp.dto.ErpOrderQueryRequert;
import com.fs.erp.dto.ErpOrderQueryResponse;
import com.fs.erp.service.IErpGoodsService;
import com.fs.erp.service.IErpOrderService;
import com.fs.pay.pay.domain.OrderResult;
import com.fs.pay.pay.dto.OrderQueryDTO;
import com.fs.pay.pay.service.PayService;
import com.fs.qw.service.IQwWorkTaskService;
import com.fs.store.config.StoreConfig;
import com.fs.store.domain.*;
import com.fs.store.dto.ExpressInfoDTO;
import com.fs.store.enums.ShipperCodeEnum;
import com.fs.store.mapper.FsStoreOrderItemMapper;
import com.fs.store.mapper.FsStoreOrderMapper;
import com.fs.store.mapper.FsStorePaymentMapper;
import com.fs.store.mapper.FsStoreProductAttrValueMapper;
import com.fs.store.param.*;
import com.fs.store.service.*;
import com.fs.system.service.ISysConfigService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
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.List;
import java.util.Set;

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

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

    @Autowired
    private IErpOrderService erpOrderService;

    @Autowired
    private PayService ybPayService;
    @Autowired
    private FsStoreOrderMapper fsStoreOrderMapper;

    @Autowired
    private IFsStoreOrderService fsStoreOrderService;

    @Autowired
    private IFsStoreOrderItemService storeOrderItemService;

    @Autowired
    private FsStorePaymentMapper fsStorePaymentMapper;


    @Autowired
    private IErpGoodsService erpGoodsService;
    @Autowired
    private ISysConfigService configService;
    @Autowired
    private FsStoreProductAttrValueMapper fsStoreProductAttrValueMapper;
    @Autowired
    private FsStorePaymentMapper paymentMapper;
    @Autowired
    private IFsStorePaymentService fsStorePaymentService;
    @Autowired
    private ICompanyService companyService;


    @Autowired
    private IFsExpressService expressService;

    @Autowired
    private FsStoreOrderItemMapper itemMapper;

    @Autowired
    private IFsStoreAfterSalesService fsStoreAfterSalesService;

    //每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(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())){
                                //更新商订单状态 删除REDIS
                                orderService.deliveryOrder(orderCode,delivery.getMail_no(),delivery.getExpress_code(),delivery.getExpress_name());
                                redisCache.deleteObject(DELIVERY+":"+extendOrder[1]);
                            }
                        }

                    }
                }
            }
        }

    }


    public void storeProdUpdateCostPrice()
    {
        String json=configService.selectConfigByKey("store.config");
        StoreConfig config=JSONUtil.toBean(json,StoreConfig.class);

        List<FsStoreProductAttrValue> values = fsStoreProductAttrValueMapper.selectFsStoreProductAttrValueList(new FsStoreProductAttrValue());
        for (FsStoreProductAttrValue value : values) {
            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"));
                    System.out.println("代理价格"+divide);
                    System.out.println("成本价"+salesPrice);
                    FsStoreProductAttrValue va = new FsStoreProductAttrValue();
                    va.setCost(salesPrice);
                    va.setAgentPrice(divide);
                    va.setId(value.getId());
                    fsStoreProductAttrValueMapper.updateFsStoreProductAttrValue(va);
                }
            }
            System.out.println(goods);
        }



    }
    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);
                                }
                            }
                        }
                    }
                }


        }

    }

    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);
        }
    }



    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);
            }
        }
    }


    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);
        }

    }


    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);
        }
    }

    public  void deleteCustomer(){

    }




}
