package com.ash.service;

import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.exception.ExcelAnalysisException;
import com.alibaba.excel.exception.ExcelDataConvertException;
import com.alibaba.fastjson.JSONObject;
import com.ash.base.*;
import com.ash.base.excelOpt.ExcelErrorMessage;
import com.ash.entity.WarningInstance;
import com.ash.entity.WarningInstanceAnalysis;
import com.ash.entity.dao.WarningInstanceMapper;
import com.ash.enums.AnalysisStatusEnum;
import com.ash.enums.ConformStatusEnum;
import com.ash.excelData.WarningInstanceExcelData;
import com.ash.listener.WarningInstanceExcelListener;
import com.ash.util.*;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.github.yulichang.query.MPJQueryWrapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Function;
import java.util.stream.Collectors;

@Slf4j
@Service
public class WarningInstanceService {


    @Value("${ash.wiAnalysisUrl}")
    public String wiAnalysisUrl;

    @Resource
    private WarningInstanceMapper warningInstanceMapper;

    @Resource
    private WarningInstanceAnalysisService warningInstanceAnalysisService;

    public Boolean save(WarningInstance data) {
        String uuid = UUIDGenerator.uuid();
        data.setId(uuid);
        int insert = warningInstanceMapper.insert(data);
        return insert > 0;
    }

    public WarningInstance load(String id) {
        return warningInstanceMapper.selectById(id);
    }

    public Boolean saveAll(List<WarningInstance> dataList) {
        if (CollectionUtils.isEmpty(dataList)) {
            throw new AshException(AshErrorCode.ILLEGAL_PARAM, "dataList is empty!");
        }

        int pageSize = 100;
        int pages = (dataList.size() + pageSize - 1) / pageSize;
        int count = 0;
        int fromIndex = 0;
        int toIndex = pageSize;
        List<WarningInstance> sub;
        for (int i = 0; i < pages; i++) {
            if (toIndex > dataList.size()) {
                toIndex = dataList.size();
            }
            log.info("from " + fromIndex + " to " + toIndex + "....");
            sub = dataList.subList(fromIndex, toIndex);
            sub.forEach(t -> {
                String uuid = UUIDGenerator.uuid();
                t.setId(uuid);
            });
            try {
                Integer result = warningInstanceMapper.insertBatchSomeColumn(sub);
                count += result;
            } catch (Exception e) {
                e.printStackTrace();
            }
            fromIndex = toIndex;
            toIndex = toIndex + pageSize;
        }

        return count > 0;
    }

    public Boolean update(WarningInstance data) {
        String id = data.getId();
        if (StringUtils.isBlank(id)) {
            throw new AshException(AshErrorCode.ILLEGAL_PARAM, "id is empty!");
        }
        WarningInstance oldData = warningInstanceMapper.selectById(id);
        if (oldData == null) {
            throw new AshException(AshErrorCode.DATA_NOT_EXIST);
        }

        int result = warningInstanceMapper.updateById(data);
        return result > 0;
    }

    public List<WarningInstance> list(WarningInstance params) {
        QueryWrapper<WarningInstance> queryWrapper = getCondition(params);
        return warningInstanceMapper.selectList(queryWrapper);
    }

    public List<WarningInstance> listUnAnalysis() {
        QueryWrapper<WarningInstance> queryWrapper = new QueryWrapper<>();
        LambdaQueryWrapper<WarningInstance> lambda = queryWrapper.lambda();
        lambda.ne(WarningInstance::getAnalysisStatus,AnalysisStatusEnum.success);
        return warningInstanceMapper.selectList(queryWrapper);
    }



    public Page<WarningInstance> pageByCondition(WarningInstance params, Page<WarningInstance> page) {
        QueryWrapper<WarningInstance> queryWrapper = getCondition(params);
        return warningInstanceMapper.selectPage(page, queryWrapper);
    }

    public int getCount(StatisticsParams params) {
        QueryWrapper<WarningInstance> queryWrapper = new QueryWrapper<>();
        LambdaQueryWrapper<WarningInstance> lambda = queryWrapper.lambda();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        if (params.getStartTime() != null) {
            Date start = DateUtils.weeHours(params.getStartTime(), 0);
            lambda.ge(WarningInstance::getAlarmDate, sdf.format(start));
        }

        if (params.getEndTime() != null) {
            Date end = DateUtils.weeHours(params.getEndTime(), 1);
            lambda.le(WarningInstance::getAlarmDate, sdf.format(end));

        }
        return warningInstanceMapper.selectCount(queryWrapper);
    }

    public List<BarChartVo> statisticsByArea(StatisticsParams params) {
        MPJQueryWrapper<WarningInstance> mpjQueryWrapper = new MPJQueryWrapper<WarningInstance>();
        mpjQueryWrapper.select("wia.area,count(t.id) as field_count")
                .leftJoin("t_ash_warning_instance_analysis wia on t.id=wia.wi_id");

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        if (params.getStartTime() != null) {
            mpjQueryWrapper.ge("t.alarm_date", sdf.format(DateUtils.weeHours(params.getStartTime(), 0)));

        }

        if (params.getEndTime() != null) {
            mpjQueryWrapper.le("t.alarm_date", sdf.format(DateUtils.weeHours(params.getEndTime(), 1)));
        }

        mpjQueryWrapper.groupBy("wia.area");
        mpjQueryWrapper.orderByDesc("field_count");

        List<Map<String, Object>> dataList = warningInstanceMapper.selectJoinMaps(mpjQueryWrapper);
        List<BarChartVo> resultList = new ArrayList<>();
        if (!CollectionUtils.isEmpty(dataList)) {
            AtomicReference<Integer> total = new AtomicReference<>(0);
            resultList = dataList.stream().map(e -> {
                        Integer fieldCount = ObjectValueOption.getObjInt(e.get("field_count"));
                        total.updateAndGet(v -> v + fieldCount);
                        return new BarChartVo(ObjectValueOption.getObjString(e.get("area")), fieldCount.toString());
                    }
            ).collect(Collectors.toList());
            resultList = resultList.stream().filter(e -> StringUtils.isNotBlank(e.getName())).collect(Collectors.toList());
            if (resultList.size() > 7) {
                resultList = resultList.subList(0, 7);
            }

            resultList.forEach(e -> {
                String value = e.getValue();
                Integer iv = Integer.parseInt(value);
                e.setValue(String.format("%.2f", iv * 1.0 / total.get() * 100.0));
            });
        }
        return resultList;
    }

    public List<BarChartVo> statisticsByDate(StatisticsParams params) {
        MPJQueryWrapper<WarningInstance> mpjQueryWrapper = new MPJQueryWrapper<WarningInstance>();
        mpjQueryWrapper.select("DATE_FORMAT(t.alarm_date, '%Y-%m-%d') as alarmDate,count(0) as field_count");

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        if (params.getStartTime() != null) {
            mpjQueryWrapper.ge("t.alarm_date", sdf.format(DateUtils.weeHours(params.getStartTime(), 0)));

        }

        if (params.getEndTime() != null) {
            mpjQueryWrapper.le("t.alarm_date", sdf.format(DateUtils.weeHours(params.getEndTime(), 1)));
        }

        mpjQueryWrapper.groupBy("DATE_FORMAT(t.alarm_date, '%Y-%m-%d')");
        mpjQueryWrapper.orderByAsc("DATE_FORMAT(t.alarm_date, '%Y-%m-%d')");
        List<Map<String, Object>> dataList = warningInstanceMapper.selectJoinMaps(mpjQueryWrapper);
        List<BarChartVo> resultList = new ArrayList<>();
        resultList = dataList.stream().map(e -> {
                    Integer fieldCount = ObjectValueOption.getObjInt(e.get("field_count"));
                    return new BarChartVo(ObjectValueOption.getObjString(e.get("alarmDate")), fieldCount.toString());
                }
        ).filter(e -> StringUtils.isNotBlank(e.getName())).collect(Collectors.toList());
        return resultList;
    }


    public List<BarChartVo> statisticsSequentialByArea(StatisticsParams params) {
        MPJQueryWrapper<WarningInstance> mpjQueryWrapper = new MPJQueryWrapper<WarningInstance>();
        mpjQueryWrapper.select("wia.area,count(t.id) as field_count")
                .leftJoin("t_ash_warning_instance_analysis wia on t.id=wia.wi_id");

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        if (params.getStartTime() != null) {
            mpjQueryWrapper.ge("t.alarm_date", sdf.format(DateUtils.weeHours(params.getStartTime(), 0)));

        }

        if (params.getEndTime() != null) {
            mpjQueryWrapper.le("t.alarm_date", sdf.format(DateUtils.weeHours(params.getEndTime(), 1)));
        }

        mpjQueryWrapper.groupBy("wia.area");
        mpjQueryWrapper.orderByDesc("field_count");

        List<Map<String, Object>> dataList = warningInstanceMapper.selectJoinMaps(mpjQueryWrapper);
        List<BarChartVo> resultList = new ArrayList<>();
        if (!CollectionUtils.isEmpty(dataList)) {
            resultList = dataList.stream().map(e -> {
                        Integer fieldCount = ObjectValueOption.getObjInt(e.get("field_count"));
                        return new BarChartVo(ObjectValueOption.getObjString(e.get("area")), fieldCount.toString());
                    }
            ).filter(e -> StringUtils.isNotBlank(e.getName())).collect(Collectors.toList());

        }
        return resultList;
    }

    private QueryWrapper<WarningInstance> getCondition(WarningInstance params) {
        QueryWrapper<WarningInstance> queryWrapper = new QueryWrapper<>();
        LambdaQueryWrapper<WarningInstance> lambda = queryWrapper.lambda();

        if (StringUtils.isNotBlank(params.getCode())) {
            lambda.like(WarningInstance::getCode, params.getCode());
        }

        if (params.getAnalysisStatus() != null) {
            lambda.eq(WarningInstance::getAnalysisStatus, params.getAnalysisStatus());
        }

        if (params.getReviewStatus() != null) {
            lambda.eq(WarningInstance::getReviewStatus, params.getReviewStatus());
        }

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        if (StringUtils.isNotBlank(params.getStartTime())) {
            try {
                Date start = sdf.parse(params.getStartTime());
                lambda.ge(WarningInstance::getAlarmDate, sdf.format(start));
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }

        if (StringUtils.isNotBlank(params.getEndTime())) {
            try {
                Date end = sdf.parse(params.getEndTime());
                lambda.le(WarningInstance::getAlarmDate, sdf.format(end));
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }

        lambda.orderByDesc(BaseModel::getCreateTime, WarningInstance::getCode);
        return queryWrapper;
    }

    public List<ExcelErrorMessage> importData(MultipartFile file) {
        WarningInstanceExcelListener listener = new WarningInstanceExcelListener();
        try {
            EasyExcel.read(MultipartFileToFileUtils.MultipartFileToFile(file),
                    WarningInstanceExcelData.class, listener).sheet().doRead();
        } catch (ExcelAnalysisException e) {
            return listener.getErrorList();
        } catch (ExcelDataConvertException e) {
            throw e;
        } catch (Exception ex) {
            ex.printStackTrace();
            log.info("导入失败,异常,", ex);
            throw new RuntimeException("导入失败!");
        }

        return null;
    }

    public void analysisByIds(List<String> ids) {
        List<WarningInstance> dataList = warningInstanceMapper.selectBatchIds(ids);
        analysis(dataList);

    }

    public void analysis(List<WarningInstance> dataList) {
        if (CollectionUtils.isEmpty(dataList)) {
            return;
        }
        Map<String, WarningInstance> dataMap = dataList.stream().collect(Collectors.toMap(WarningInstance::getId, Function.identity()));
        for (String id : dataMap.keySet()) {
            WarningInstance cd = dataMap.get(id);
            JSONObject analysisResult = invokeAnalysis(cd);
            if (analysisResult == null) {
                cd.setAnalysisStatus(AnalysisStatusEnum.fail);
                update(cd);
            } else {
                WarningInstanceAnalysis wa = new WarningInstanceAnalysis();
                wa.setWiId(cd.getId());
                wa.setArea(cd.getMunicipalPolice().replaceAll("公安局", ""));
                wa.setAmount(analysisResult.getDouble("value"));
                wa.setSex(analysisResult.getString("gender"));
                wa.setCareer(analysisResult.getString("occupation"));
                wa.setRainageMethod(analysisResult.getString("diversionMethod"));
                wa.setPayMethod(analysisResult.getString("paymentMethod"));
                wa.setConformStatus(ConformStatusEnum.UNCONFIRMED);
                warningInstanceAnalysisService.save(wa);
                cd.setAnalysisStatus(AnalysisStatusEnum.success);
                update(cd);
            }
        }
    }

    private JSONObject invokeAnalysis(WarningInstance cd) {
        try {
            Map<String, String> header = new HashMap<>();
            Map<String, Object> paramsMap = new HashMap<>();
            paramsMap.put("content", cd.getContent());
            paramsMap.put("feedback", cd.getFeedbackContent());
            String toJson = JSONObject.toJSONString(paramsMap);
            StringEntity myEntity = new StringEntity(toJson, ContentType.APPLICATION_JSON);
            String sResult = HttpClientUtils.doPostRequest(wiAnalysisUrl, header, null, myEntity);
            return JSONObject.parseObject(sResult);
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return null;

    }
}