package com.syzb.business.service;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DatePattern;
import cn.hutool.core.date.LocalDateTimeUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.syzb.business.entity.AppOrder;
import com.syzb.business.entity.ModuleUser;
import com.syzb.business.mapper.AppOrderMapper;
import com.syzb.business.mapper.ModuleUserMapper;
import com.syzb.business.vo.BusinessModuleUserVO;
import com.syzb.business.vo.BusinessOrderVO;
import com.syzb.common.constant.IsOrNot;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;

@Service
public class BusinessDataService {

    private LocalDateTime INIT_SYNC_TIME = LocalDateTime.of(2025, 1, 1, 0, 0, 0);

    @Resource
    private BusinessApiService businessApiService;

    @Resource
    private AppOrderMapper appOrderMapper;

    @Resource
    private ModuleUserMapper moduleUserMapper;

    @Transactional(rollbackFor = Exception.class)
    public void syncOrder() {
        QueryWrapper<AppOrder> wrapper = Wrappers.<AppOrder>query()
                .select("max(update_time) as update_time");
        AppOrder appOrder = appOrderMapper.selectOne(wrapper);
        LocalDateTime startTime = INIT_SYNC_TIME;
        if (appOrder != null && appOrder.getUpdateTime() != null) {
            startTime = appOrder.getUpdateTime();
        }
        LocalDateTime endTime = LocalDateTime.now();
        List<BusinessOrderVO> orderList = businessApiService.getOrderList(startTime, endTime);
        if (CollUtil.isNotEmpty(orderList)) {
            for (BusinessOrderVO order : orderList) {
                Integer orderId = order.getOrderId();
                AppOrder existOrder = appOrderMapper.selectById(orderId);
                if (existOrder == null) {
                    appOrderMapper.insert(convertOrder(order, true));
                } else {
                    AppOrder updateOrder = convertOrder(order, false);
                    if (!isEquals(existOrder, updateOrder)) {
                        appOrderMapper.updateById(updateOrder);
                    }
                }
            }
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void syncModuleUser() {
        QueryWrapper<ModuleUser> wrapper = Wrappers.<ModuleUser>query()
                .select("max(update_time) as update_time");
        ModuleUser moduleUser = moduleUserMapper.selectOne(wrapper);
        LocalDateTime startTime = INIT_SYNC_TIME;
        if (moduleUser != null && moduleUser.getUpdateTime() != null) {
            startTime = moduleUser.getUpdateTime();
        }
        LocalDateTime endTime = LocalDateTime.now();
        Set<Integer> moduleIds = getModuleIds();
        for (Integer moduleId : moduleIds) {
            List<BusinessModuleUserVO> moduleUserList = businessApiService.getModuleUserList(moduleId, startTime, endTime);
            if (CollUtil.isNotEmpty(moduleUserList)) {
                for (BusinessModuleUserVO moduleUserVO : moduleUserList) {
                    Integer id = moduleUserVO.getId();
                    ModuleUser existModuleUser = moduleUserMapper.selectById(id);
                    if (existModuleUser == null) {
                        moduleUserMapper.insert(convertModuleUser(moduleUserVO, true));
                    } else {
                        ModuleUser updateModuleUser = convertModuleUser(moduleUserVO, false);
                        if (!isEquals(existModuleUser, updateModuleUser)) {
                            moduleUserMapper.updateById(updateModuleUser);
                        }
                    }
                }
            }
        }
    }

    private Set<Integer> getModuleIds() {
        // TODO
        Set<Integer> set = new HashSet<>();
        set.add(1000);
        return set;
    }

    private AppOrder convertOrder(BusinessOrderVO order, boolean isNew) {
        AppOrder appOrder = new AppOrder();
        appOrder.setOrderId(order.getOrderId());
        appOrder.setProductName(order.getProductName());
        appOrder.setOrderDay(order.getOrderDay());
        appOrder.setCurrentPrice(order.getCurrentPrice());
        appOrder.setOrderState(order.getOrderState());
        appOrder.setPayStatus(order.getReceivedAmount() == null || order.getReceivedAmount().compareTo(BigDecimal.ZERO) == 0 ? IsOrNot.NOT.value : IsOrNot.IS.value);
        appOrder.setOriginalPrice(order.getOriginalPrice());
        appOrder.setIsOpen(order.getIsOpen());
        appOrder.setReceivedAmount(order.getReceivedAmount());
        appOrder.setCreateTime(LocalDateTimeUtil.parse(order.getCreateTime(), DatePattern.NORM_DATETIME_FORMATTER));
        appOrder.setUserId(order.getUserId().toString());
        appOrder.setMobile(order.getMobile());
        appOrder.setUmId(order.getUmId());
        appOrder.setBatchId(order.getBatchId());
        appOrder.setSku(order.getSku());
        appOrder.setChannel(order.getChannel());
        appOrder.setDepartmentId(order.getDepartmentId());
        appOrder.setOpenTime(LocalDateTimeUtil.parse(order.getOpenTime(), DatePattern.NORM_DATETIME_FORMATTER));
        appOrder.setSuspendTime(LocalDateTimeUtil.parse(order.getSuspendTime(), DatePattern.NORM_DATETIME_FORMATTER));
        appOrder.setSuspendRemark(order.getSuspendRemark());
        appOrder.setRemainingDay(order.getRemainingDay());
        appOrder.setReceivedAmountTime(LocalDateTimeUtil.parse(order.getReceivedAmountTime(), DatePattern.NORM_DATETIME_FORMATTER));
        appOrder.setStopType(order.getStopType());
        appOrder.setStopTime(LocalDateTimeUtil.parse(order.getStopTime(), DatePattern.NORM_DATETIME_FORMATTER));
        appOrder.setOrderTime(LocalDateTimeUtil.parse(order.getOrderTime(), DatePattern.NORM_DATETIME_FORMATTER));
        appOrder.setExtInfo(order.getExtInfo());
        appOrder.setRemark(order.getRemark());
        appOrder.setUpdateTime(LocalDateTimeUtil.parse(order.getUpdateTime(), DatePattern.NORM_DATETIME_FORMATTER));
        appOrder.setActivityName(order.getActivityName());
        appOrder.setHasPdf(order.getHasPdf());
        appOrder.setCanSign(order.getCanSign());
        if (StrUtil.isNotBlank(order.getExtInfo())) {
            JSONObject jsonObject = JSONObject.parseObject(order.getExtInfo());
            appOrder.setProductId(jsonObject.getInteger("productId"));
            appOrder.setProductType(jsonObject.getInteger("productType"));
            appOrder.setSaleUserId(jsonObject.getInteger("saleUserId"));
        }
        if (isNew) {
            appOrder.setInsertTime(LocalDateTime.now());
        } else {
            appOrder.setModifyTime(LocalDateTime.now());
        }
        return appOrder;
    }

    private ModuleUser convertModuleUser(BusinessModuleUserVO moduleUserVO, boolean isNew) {
        ModuleUser moduleUser = new ModuleUser();
        moduleUser.setId(moduleUserVO.getId());
        moduleUser.setUserId(moduleUserVO.getUserId());
        moduleUser.setModuleId(moduleUserVO.getModuleId());
        moduleUser.setEndTime(LocalDateTimeUtil.parse(moduleUserVO.getEndTime(), DatePattern.NORM_DATETIME_FORMATTER));
        moduleUser.setCreateTime(LocalDateTimeUtil.parse(moduleUserVO.getCreateTime(), DatePattern.NORM_DATETIME_FORMATTER));
        moduleUser.setUpdateTime(LocalDateTimeUtil.parse(moduleUserVO.getUpdateTime(), DatePattern.NORM_DATETIME_FORMATTER));
        if (isNew) {
            moduleUser.setInsertTime(LocalDateTime.now());
        } else {
            moduleUser.setModifyTime(LocalDateTime.now());
        }
        return moduleUser;
    }

    private boolean isEquals(AppOrder a, AppOrder b) {
        return Objects.equals(a.getOrderId(), b.getOrderId())
                && Objects.equals(a.getProductName(), b.getProductName())
                && Objects.equals(a.getOrderDay(), b.getOrderDay())
                && isEquals(a.getCurrentPrice(), b.getCurrentPrice())
                && Objects.equals(a.getOrderState(), b.getOrderState())
                && isEquals(a.getOriginalPrice(), b.getOriginalPrice())
                && Objects.equals(a.getIsOpen(), b.getIsOpen())
                && isEquals(a.getReceivedAmount(), b.getReceivedAmount())
                && Objects.equals(a.getCreateTime(), b.getCreateTime())
                && Objects.equals(a.getUserId(), b.getUserId())
                && Objects.equals(a.getMobile(), b.getMobile())
                && Objects.equals(a.getUmId(), b.getUmId())
                && Objects.equals(a.getBatchId(), b.getBatchId())
                && Objects.equals(a.getSku(), b.getSku())
                && Objects.equals(a.getChannel(), b.getChannel())
                && Objects.equals(a.getDepartmentId(), b.getDepartmentId())
                && Objects.equals(a.getOpenTime(), b.getOpenTime())
                && Objects.equals(a.getSuspendTime(), b.getSuspendTime())
                && Objects.equals(a.getSuspendRemark(), b.getSuspendRemark())
                && Objects.equals(a.getRemainingDay(), b.getRemainingDay())
                && Objects.equals(a.getReceivedAmountTime(), b.getReceivedAmountTime())
                && Objects.equals(a.getStopType(), b.getStopType())
                && Objects.equals(a.getStopTime(), b.getStopTime())
                && Objects.equals(a.getOrderTime(), b.getOrderTime())
                && Objects.equals(a.getExtInfo(), b.getExtInfo())
                && Objects.equals(a.getRemark(), b.getRemark())
                && Objects.equals(a.getUpdateTime(), b.getUpdateTime())
                && Objects.equals(a.getActivityName(), b.getActivityName())
                && Objects.equals(a.getHasPdf(), b.getHasPdf())
                && Objects.equals(a.getCanSign(), b.getCanSign())
                && Objects.equals(a.getProductId(), b.getProductId())
                && Objects.equals(a.getProductType(), b.getProductType())
                && Objects.equals(a.getSaleUserId(), b.getSaleUserId());
    }

    private boolean isEquals(ModuleUser a, ModuleUser b) {
        return Objects.equals(a.getId(), b.getId())
                && Objects.equals(a.getUserId(), b.getUserId())
                && Objects.equals(a.getModuleId(), b.getModuleId())
                && Objects.equals(a.getEndTime(), b.getEndTime())
                && Objects.equals(a.getCreateTime(), b.getCreateTime())
                && Objects.equals(a.getUpdateTime(), b.getUpdateTime());
    }

    private boolean isEquals(BigDecimal a, BigDecimal b) {
        return a == null ? b == null : a.compareTo(b) == 0;
    }

}