package com.deloitte.system.service;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.text.csv.CsvUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONArray;
import com.common.core.constant.GlobalConst;
import com.common.core.enums.ResultCodeEnum;
import com.common.core.exception.BizException;
import com.common.core.service.CryptoService;
import com.common.core.utils.BeanHelper;
import com.common.core.utils.DateUtils;
import com.common.core.utils.DesensitiveUtils;
import com.common.core.utils.IdUtils;
import com.common.core.utils.StringUtils;
import com.common.redis.util.RedisUtil;
import com.deloitte.system.model.CacheList;
import com.deloitte.system.model.CampaignUser;
import com.deloitte.system.model.Contact;
import com.deloitte.system.request.CampaignUserAllDto;
import com.deloitte.system.request.CampaignUserDto;
import com.deloitte.system.request.ContactDto;
import com.deloitte.system.request.OperatorQueryDto;
import com.opencsv.bean.CsvToBean;
import com.opencsv.bean.CsvToBeanBuilder;
import com.opencsv.bean.HeaderColumnNameMappingStrategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

import static com.common.core.constant.GlobalConst.PIPL_UNCONFIRM_INSERT;
import static com.common.core.constant.GlobalConst.PIPL_UNCONFIRM_UPDATE;

@Slf4j
@Service
public class CampaignUserService {

    private String tableName="campaign_user";

    @Autowired
    private CryptoService cryptoService;

    @Autowired
    private IdUtils idWorker;

    @Autowired
    private RedisUtil redisUtil;

    public CampaignUserDto queryForOne(String dataId) {
        CampaignUser campaignUser =CampaignUser.dao.findById(dataId);
        if (!ObjectUtil.isEmpty(campaignUser)){
            CampaignUserDto dto = BeanHelper.copyAs(campaignUser, CampaignUserDto.class);
            return dto;
        }
        return null;

    }

    public List<CampaignUserDto> insertList(List<CampaignUserDto> campaignUserDtoList, String txId) {
        List<CampaignUserDto> respList = new ArrayList<>();
        CacheList<CampaignUserDto> dtoCacheList = new CacheList<>();
        dtoCacheList.setTableName(tableName);
        List<CampaignUserDto> dtoItemList = new ArrayList<>();
        campaignUserDtoList.forEach(e -> {
            String dataId = idWorker.nextId();
            CampaignUserDto cacheItem = BeanHelper.copyAs(e, CampaignUserDto.class);
            cacheItem.setDataId(dataId);
            dtoItemList.add(cacheItem);

            CampaignUserDto target = BeanHelper.copyAs(e, CampaignUserDto.class);
            target.setDataId(dataId);
            CampaignUserDto dto = cryptoService.encryptModelColumns(e);
            dto.setDataId(dataId);
            target.setNameEncrypt(dto.getName());
            target.setPhoneEncrypt(dto.getPhone());
            target.setEmailEncrypt(dto.getEmail());
            DesensitiveUtils.format(target);
            respList.add(target);
        });
        dtoCacheList.setData(dtoItemList);
        String insertJsonString = JSONArray.toJSONString(dtoCacheList);
        String insertKey = PIPL_UNCONFIRM_INSERT + txId;
        boolean redisFlag = redisUtil.set(insertKey, insertJsonString, GlobalConst.DATA_EXPIRE);
        if (!redisFlag){
            throw new BizException("缓存写入失败");
        }
        return respList;
    }

    public List<CampaignUserDto> updateList(List<CampaignUserDto> campaignUserDtoList, String txId) {
        List<CampaignUserDto> respList = new ArrayList<>();
        CacheList<CampaignUserDto> dtoCacheList = new CacheList<>();
        dtoCacheList.setTableName(tableName);
        List<CampaignUserDto> dtoItemList = new ArrayList<>();
        campaignUserDtoList.forEach(e -> {
            CampaignUser campaignUser = CampaignUser.dao.findById(e.getDataId());
            CampaignUserDto cacheItem = BeanHelper.copyAs(e, CampaignUserDto.class);
            dtoItemList.add(cacheItem);
            CampaignUserDto dto = BeanHelper.copyAs(BeanHelper.copy(cacheItem,campaignUser),CampaignUserDto.class);
            CampaignUserDto target = BeanHelper.copyAs(dto, CampaignUserDto.class);
            dto = cryptoService.encryptModelColumns(dto);
            target.setNameEncrypt(dto.getName());
            target.setPhoneEncrypt(dto.getPhone());
            target.setEmailEncrypt(dto.getEmail());
            DesensitiveUtils.format(target);
            respList.add(target);
        });
        dtoCacheList.setData(dtoItemList);
        String updateJsonString = JSONArray.toJSONString(dtoCacheList);
        String updateKey = PIPL_UNCONFIRM_UPDATE + txId;
        boolean redisFlag = redisUtil.set(updateKey, updateJsonString,GlobalConst.DATA_EXPIRE);
        if (!redisFlag){
            throw new BizException("缓存写入失败");
        }
        return respList;
    }

    public Boolean deleteOne(String dataId) {
        CampaignUser campaignUser = CampaignUser.dao.findById(dataId);
        campaignUser.setIsDelete(1);
        return campaignUser.saveOrUpdate();
    }

    public Boolean undeleteOne(String dataId) {
        CampaignUser campaignUser = CampaignUser.dao.findById(dataId);
        campaignUser.setIsDelete(0);
        return campaignUser.saveOrUpdate();
    }

    public List<CampaignUserDto> search(List<String> idList){
        if (CollUtil.isEmpty(idList)) {
            return null;
        }
        StringBuilder queryParam = new StringBuilder();
        queryParam.append("and id in ").append(idList.stream().collect(Collectors.joining(", ", "(", ")")));
        List<CampaignUser> quotesList = CampaignUser.dao.findList(queryParam.toString());
        return quotesList.stream()
                .map(quotes -> BeanHelper.copyAs(quotes, CampaignUserDto.class)).collect(Collectors.toList());

    }
    public List<CampaignUserAllDto> batchUpload(MultipartFile[] files,String txId) {
        List<CampaignUserAllDto> listAll= null;
        try {
            InputStreamReader in = null;
            in = new InputStreamReader(files[0].getInputStream(), FileService.getFilecharset(files[0].getInputStream()));
            HeaderColumnNameMappingStrategy<CampaignUserAllDto> strategy = new HeaderColumnNameMappingStrategy<>();
            strategy.setType(CampaignUserAllDto.class);
            CsvToBean<CampaignUserAllDto> csvToBean = new CsvToBeanBuilder<CampaignUserAllDto>(in)
                    .withSeparator(',')
                    .withQuoteChar('\'')
                    .withMappingStrategy(strategy).build();
            listAll= csvToBean.parse();

            List<CampaignUserDto> userList=BeanHelper.copyAs(listAll,CampaignUserDto.class);
            List<CampaignUserDto> userList2 = this.insertList(userList,txId);
            for (int i = 0; i < listAll.size(); i++) {
                BeanHelper.copy(userList2.get(i),listAll.get(i));
            }
        } catch (Exception e) {
            log.error("CampaignUser batchUpload failed:",e);
            throw new BizException(ResultCodeEnum.AWS_RT_ERROR);
        }
        //日期转换
        /*if(null!=listAll && !listAll.isEmpty()){
            listAll.forEach(e->{
                Date date = DateUtils.convert(e.getDateTime(),DateUtils.DATE_TIME_MINUTE_FORMAT2);
                e.setDateTime(DateUtils.format(date,DateUtils.DATE_TIME_MINUTE_FORMAT1));
            });
        }*/
        return listAll;
    }

    public List<CampaignUserDto> searchListByOperator(List<OperatorQueryDto> queryDtos) {

        StringBuilder queryParam = new StringBuilder();
        for (OperatorQueryDto queryDto: queryDtos) {
            String queryName = queryDto.getName();
            //name驼峰转下划线
            String name = BeanHelper.propertyToColumn(queryName);
            String operator = queryDto.getOperator();
            Object value = queryDto.getValue();
            if(StringUtils.isNotEmpty(operator)){
                if("=".equals(operator)||"!=".equals(operator)){
                    queryParam.append(" and c."+name).append(" "+operator+" ").append("'"+value+"'");
                }else if("like".equals(operator)||"not like".equals(operator)){
                    queryParam.append(" and c."+name).append(" "+operator+" ").append("\'%").append(value).append("%\'");
                }else if("in".equals(operator)||"not in".equals(operator)){
                    List<String> value1 = (ArrayList<String>)value;
                    queryParam.append(" and c."+name).append(" "+operator+" ").append(value1.stream().collect(Collectors.joining("','", "('", "')")));
                }else {
                    throw new BizException("无效的sql请求！");
                }
            }
        }
        queryParam.append(" and c.sf_record_id is not null");
        String sql = "select c.* from campaign_user c WHERE c.is_delete = '0' "+queryParam.toString();
        List<CampaignUser> campaignUserList = CampaignUser.dao.findListBySql(sql);
        return campaignUserList.stream().map(e->BeanHelper.copyAs(e,CampaignUserDto.class)).collect(Collectors.toList());
    }
}