package com.ibeetl.admin.console.service;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.google.gson.Gson;
import com.ibeetl.admin.console.dao.SettingConsoleDao;
import com.ibeetl.admin.console.model.BannerModel;
import com.ibeetl.admin.console.model.ItemModel;
import com.ibeetl.admin.console.model.StorageModel;
import com.ibeetl.admin.console.model.XzxAccountLogModel;
import com.ibeetl.admin.console.rabbitmq.MqConstants;
import com.ibeetl.admin.console.rabbitmq.MqUtil;
import com.ibeetl.admin.core.entity.CoreSetMoney;
import com.ibeetl.admin.core.entity.CoreUser;
import com.ibeetl.admin.core.entity.XzxAccountInfo;
import com.ibeetl.admin.core.service.CoreBaseService;
import com.ibeetl.admin.core.service.CorePlatformService;
import com.ibeetl.admin.core.web.JsonResult;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.tomcat.util.json.JSONParser;
import org.beetl.sql.core.engine.PageQuery;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.configurationprocessor.json.JSONArray;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

@Service
@Transactional
public class SettingConsoleService extends CoreBaseService<CoreSetMoney> {

    Logger log = LoggerFactory.getLogger(this.getClass());
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Autowired
    SettingConsoleDao settingConsoleDao;

    @Autowired
    RedisService redisService;
    /*@Autowired
    MqUtil mqUtil;*/
    @Autowired
    XzxAccountInfoService xzxAccountInfoService;
    @Autowired
    CorePlatformService platformService;
    /**
     * 根据条件查询
     *
     * @param query
     */
    public void queryByCondtion(PageQuery<CoreSetMoney> query) {
        PageQuery<CoreSetMoney> ret = settingConsoleDao.queryByCondtion(query);
        queryListAfter(ret.getList());
    }

    /**
     * 更新字典表 config_type_name 为 金额类型 的值
     * @param money
     */
    @Transactional(rollbackFor = {})
    public void updateMoney(CoreSetMoney money){
        if(!StringUtils.isEmpty(money.getAgentPrice())) {settingConsoleDao.updateAgentPrice(money);}
        if(!StringUtils.isEmpty(money.getTimeInterval())) {settingConsoleDao.updateTimeInterval(money);}
        if(!StringUtils.isEmpty(money.getStartTime())) {settingConsoleDao.updateStratTime(money);}
        if(!StringUtils.isEmpty(money.getEndTime())) {settingConsoleDao.updateEndTime(money);}
        if(!StringUtils.isEmpty(money.getOverdrawPrice())){
            Map<String, Object> m = settingConsoleDao.queryOverdrawPrice();
            settingConsoleDao.updateOverdrawPrice(money);
            // 需要更新所有account表的透支额度,但是不更新已经修改过的用户额度
            List<String> orderIds = settingConsoleDao.queryRKOrderIds(null,null);

            settingConsoleDao.updateAccountOverdrawPrice(money.getOverdrawPrice(), m.get("configValue").toString(),orderIds,"1");
        }
        if(!StringUtils.isEmpty(money.getRechargePrice())){settingConsoleDao.updateRechargePrice(money);}

        if(!StringUtils.isEmpty(money.getOrderTimeout())){
            settingConsoleDao.updateOrderTimeout(money);
        }
        if(!StringUtils.isEmpty(money.getOrderTotal())){
            settingConsoleDao.updateOrderTotal(money);
        }

    }

    /*
    * ====商品分类===============================================================
    */
    public Map<String, Object> querIteml(ItemModel item){
        Map<String, Object> map = new HashMap<>();
        List<ItemModel> list = settingConsoleDao.querIteml(item);
        map.put("data", list);
        map.put("count", settingConsoleDao.queryItemCount(item));
        map.put("code", 0);
        return map;
    }

    @Transactional(rollbackFor = RollbackException.class)
    public int insertItem(ItemModel item){
        item.setItemType(System.currentTimeMillis() + "" + (int) (Math.random()*(10000-10)+10));
        item.setCreateTime(sdf.format(new Date()));
        // 对排序字段进行处理
        setSort(item);
        int i = settingConsoleDao.insertItem(item);
        setSortAggin(item);
        // updateItemForRedis();
        redisService.remove("environmentalInfoList");
        redisService.remove("environmentalInfoListNew");
        redisService.remove("xzx:sys:category");

        return i;
    }
    public int delItem(ItemModel item){
        ItemModel im = new ItemModel();
        im.setLimit(10);
        im.setParentId(item.getId());
        List<ItemModel> list = settingConsoleDao.querIteml(im);
        if(list.size() > 0){
            return 0;
        }
        int i = settingConsoleDao.delItem(item);
        // updateItemForRedis();
        redisService.remove("environmentalInfoList");
        redisService.remove("environmentalInfoListNew");
        redisService.remove("xzx:sys:category");

        return i;
    }

    /**
     * 更新
     * @param item
     * @return
     */
    @Transactional(rollbackFor = RollbackException.class)
    public int updateItem(ItemModel item){
        // 对排序字段进行处理
        setSort(item);
        int i = settingConsoleDao.updateItem(item);
        setSortAggin(item);
        redisService.remove("environmentalInfoList");
        redisService.remove("environmentalInfoListNew");
        redisService.remove("xzx:sys:category");
        // updateItemForRedis();
        return i;
    }

    /**
     * 对排序字段进行处理，排序字段不能出现重复的
     * 当排序字段更新或插入时，后面的需要往下排
     * 处理不好，够用
     * @param item   传入对象
     */
    void setSort(ItemModel item){
        ItemModel im = new ItemModel();
        im.setLimit(1000);
        im.setParentId(item.getParentId());
        List<ItemModel> list = settingConsoleDao.querIteml(im);
        log.info("------list.size() : {} -----", list.size());
        // 找到原始的sort数据
        int originalSort = item.getSort();

        for(ItemModel imx : list){
            if(originalSort <= imx.getSort()){
                imx.setSort(imx.getSort()+1);
            }
        }
        for(ItemModel imx: list){
            settingConsoleDao.updateItem(imx);
        }
    }

    void setSortAggin(ItemModel item){
        ItemModel im = new ItemModel();
        im.setLimit(1000);
        im.setParentId(item.getParentId());
        List<ItemModel> list = settingConsoleDao.querIteml(im);
        list.sort((x, y)->Integer.compare(x.getSort(), y.getSort()));
        int f = 1;
        for(ItemModel itemModel : list){
            itemModel.setSort(f++);
        }
        for(ItemModel itemModel : list){
            settingConsoleDao.updateItem(itemModel);
        }
    }

    /**
     * 更新redis里面的数据
     */
    public void updateItemForRedis(){
        List<ItemModel> list = settingConsoleDao.queryItemAll();
        list = parentUtils(list);
        Gson gson = new Gson();
        String str = gson.toJson(list);
        redisService.set("environmentalInfoList", str);
    }

    // 递归操作父子结构数据
    List<ItemModel> parentUtils(List<ItemModel> parentlist){
        List<ItemModel> list = new ArrayList<>();
        for(ItemModel itemModel :parentlist){
            if(itemModel.getParentId() == null){
                itemModel.setList(childUtils(parentlist, itemModel.getId()));
                list.add(itemModel);
            }
        }
        log.info("----更新redis里面的分类数据：{}", list);
        return list;
    }
    List<ItemModel> childUtils(List<ItemModel> childlist , Long id){
        List<ItemModel> list = new ArrayList<>();
        for(ItemModel itemModel : childlist){
            if(itemModel.getParentId() == id){
                itemModel.setList(childUtils(childlist, itemModel.getId()));
                list.add(itemModel);
            }
        }
        return list;
    }


    class RollbackException extends RuntimeException {
        public RollbackException(String message) {
            super(message);
        }
    }



    // ------仓库管理------------------------------------------

    /**
     * 查询仓库列表
     * @param storageModel
     * @return
     */
    public Map<String, Object> queryStorageList(StorageModel storageModel){
        Map<String, Object> m = new HashMap<>();
        m.put("data", settingConsoleDao.queryStorageList(storageModel));
        m.put("count", settingConsoleDao.queryStorageListCount(storageModel));
        m.put("code", 0);
        return m;
    }

    public List<Map<String,Object>> queryAllStorage(){
        return settingConsoleDao.queryAllStorage();
    }
    /**
     * 添加仓库
     * @param storageModel
     * @return
     */
    public int addStorage(StorageModel storageModel){
        storageModel.setCreateTime(sdf.format(new Date()));
        return settingConsoleDao.addStorage(storageModel);
    }

    /**
     * 更新仓库
     * @param storageModel
     * @return
     */
    public int updateStorage(StorageModel storageModel){
        return settingConsoleDao.updateStorage(storageModel);
    }

    /**
     * 删除仓库
     * @param storageModel
     * @return
     */
    public int delStorage(StorageModel storageModel){
        return settingConsoleDao.delStorage(storageModel);
    }


    // ----banner管理---------------------------------------------
    /**
     * 查询
     * @param bannerModel
     * @return
     */
    public Map<String, Object> queryBannerList(BannerModel bannerModel){
        Map<String, Object> map = new HashMap<>();
        map.put("data", settingConsoleDao.queryBannerList(bannerModel));
        map.put("count", settingConsoleDao.queryBannerListCount(bannerModel));
        map.put("code", 0);
        return map;
    }

    /**
     * 添加
     * @param bannerModel
     * @return
     */
    public JsonResult insertBanner(BannerModel bannerModel){
        bannerModel.setCreateTime(sdf.format(new Date()));
        if(settingConsoleDao.insertBanner(bannerModel) > 0){
            return JsonResult.success();
        }else {
            return JsonResult.failMessage("保存失败");
        }
    }

    /**
     * 更新
     * @param bannerModel
     * @return
     */
    public int updateBanner(BannerModel bannerModel){
        return settingConsoleDao.updateBanner(bannerModel);
    }

    /**
     * 删除
     * @param id
     * @return
     */
    public int delBanner(String id){
        return settingConsoleDao.delBanner(id);
    }

    public void updateOverdrawPriceByUserId(String accountId,String money){
        //修改账户推送队列
        XzxAccountInfo accountInfo = xzxAccountInfoService.queryById(accountId);
        XzxAccountLogModel getAccountLog=getAccountLog(accountInfo,money);
        //mqUtil.send(MqConstants.ACCOUNT_LOG_QUEUE,getAccountLog);
        settingConsoleDao.updateOverdrawPriceByUserId(accountId,money);
    }

       private XzxAccountLogModel getAccountLog(XzxAccountInfo accountInfo,String money){
           XzxAccountLogModel model = new XzxAccountLogModel();
           model.setOrderId("");
           model.setChannelType(9);
           model.setCreateTime(sdf.format(new Date()));
           CoreUser user = platformService.getCurrentUser();
           model.setCreateUserId(Long.toString(user.getId()));
           model.setAccountId(accountInfo.getAccountId());
           model.setOldMoney(accountInfo.getMoney());
           model.setNewMoney(accountInfo.getMoney());
           model.setOldLimit(accountInfo.getOverdraftLimit());
           model.setNewLimit(new BigDecimal(accountInfo.getOverdraftLimit()).add(new BigDecimal(money)).toString());
           model.setOldFixedLimit(accountInfo.getFixedLimit());
           model.setNewFixedLimit(new BigDecimal(accountInfo.getFixedLimit()).add(new BigDecimal(money)).toString());
           return model;
       }
    public void updateLimitByUserId(String accountId,String money){
        //修改账户推送队列
        XzxAccountInfo accountInfo = xzxAccountInfoService.queryById(accountId);
        XzxAccountLogModel getAccountLog=getAccountLog(accountInfo,money);
        //mqUtil.send(MqConstants.ACCOUNT_LOG_QUEUE,getAccountLog);
        settingConsoleDao.updateLimitByUserId(accountId,money);
    }
}