package com.xzx.gc.system.controller;


import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.convert.Convert;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.NumberUtil;
import com.xzx.gc.common.Result;
import com.xzx.gc.common.constant.Constants;
import com.xzx.gc.common.constant.OrderEnum;
import com.xzx.gc.common.utils.BusinessUtil;
import com.xzx.gc.entity.CityPartner;
import com.xzx.gc.entity.PlatformReport;
import com.xzx.gc.model.MapDto;
import com.xzx.gc.model.order.*;
import com.xzx.gc.system.service.CityPartnerService;
import com.xzx.gc.system.service.PlatformReportService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
import java.util.stream.Collectors;

@RestController
@Api(tags = {"平台报表管理"})
@Validated
@Slf4j
public class PlatformReportController {


    @Autowired
    private PlatformReportService platformReportService;

    @Autowired
    private CityPartnerService cityPartnerService;

    @Autowired
    private BusinessUtil businessUtil;

    @PostMapping("/platformReport/find")
    @ApiOperation(value = "平台总览")
    public Result<List<PlatformReportDto>> find() {
        List<PlatformReportDto> list = CollUtil.newArrayList();

        //按时间统计
        List<PlatformReport> byIndicatorType = platformReportService.findByIndicatorType(OrderEnum.按时间统计.getValue());

        /*
        用户量
         */
        //按用户量筛选
        List<PlatformReport> users = byIndicatorType.stream().filter(x -> OrderEnum.用户量.getValue().equals(x.getReportType().toString())).collect(Collectors.toList());
        //总数
        double sum = users.stream().mapToDouble(x -> Convert.toDouble(x.getIndicator())).sum();
        PlatformReportDto platformReportDto = new PlatformReportDto();
        platformReportDto.setAllNum(Convert.toStr(Convert.toInt(sum)));
        //日环比 日环比计算方法： (本日回收金额/昨日回收金额 — 1 )× 100%  正值为增长率  负值为下降率
        platformReportDto.setRatio(platformReportService.getRatio(users));
        //类型
        platformReportDto.setType(OrderEnum.用户量.getValue());
        list.add(platformReportDto);

        /*
        下单量
         */
        List<PlatformReport> orderNums = byIndicatorType.stream().filter(x -> OrderEnum.总下单量.getValue().equals(x.getReportType().toString())).collect(Collectors.toList());
        //总数
        sum = orderNums.stream().mapToDouble(x -> Convert.toDouble(x.getIndicator())).sum();
        platformReportDto = new PlatformReportDto();
        platformReportDto.setAllNum(Convert.toStr(Convert.toInt(sum)));
        //日环比 日环比计算方法： (本日回收金额/昨日回收金额 — 1 )× 100%  正值为增长率  负值为下降率
        platformReportDto.setRatio(platformReportService.getRatio(orderNums));
        //类型
        platformReportDto.setType(OrderEnum.总下单量.getValue());
        list.add(platformReportDto);

        /*
        交易金额
         */
        List<PlatformReport> orderMoneys = byIndicatorType.stream().filter(x -> OrderEnum.总交易金额.getValue().equals(x.getReportType().toString())).collect(Collectors.toList());
        //总数
        sum = orderMoneys.stream().mapToDouble(x -> Convert.toDouble(x.getIndicator())).sum();
        platformReportDto = new PlatformReportDto();
        platformReportDto.setAllNum(businessUtil.changeMoney(Convert.toStr(sum)));
        //日环比 日环比计算方法： (本日回收金额/昨日回收金额 — 1 )× 100%  正值为增长率  负值为下降率
        platformReportDto.setRatio(platformReportService.getRatio(orderMoneys));
        //类型
        platformReportDto.setType(OrderEnum.总交易金额.getValue());
        list.add(platformReportDto);


        /*
        打包站回收金额
         */
        List<PlatformReport> dbzMoneys = byIndicatorType.stream().filter(x -> OrderEnum.打包站回收金额.getValue().equals(x.getReportType().toString())).collect(Collectors.toList());
        //总数
        sum = dbzMoneys.stream().mapToDouble(x -> Convert.toDouble(x.getIndicator())).sum();
        platformReportDto = new PlatformReportDto();
        platformReportDto.setAllNum(businessUtil.changeMoney(Convert.toStr(sum)));
        //日环比 日环比计算方法： (本日回收金额/昨日回收金额 — 1 )× 100%  正值为增长率  负值为下降率
        platformReportDto.setRatio(platformReportService.getRatio(dbzMoneys));
        //类型
        platformReportDto.setType(OrderEnum.打包站回收金额.getValue());
        list.add(platformReportDto);


        /*
        投诉
         */
        List<PlatformReport> complaints = byIndicatorType.stream().filter(x -> OrderEnum.投诉总量.getValue().equals(x.getReportType().toString())).collect(Collectors.toList());
        //总数
        sum = complaints.stream().mapToDouble(x -> Convert.toDouble(x.getIndicator())).sum();
        platformReportDto = new PlatformReportDto();
        platformReportDto.setAllNum(Convert.toStr(Convert.toInt(sum)));
        //日环比 日环比计算方法： (本日回收金额/昨日回收金额 — 1 )× 100%  正值为增长率  负值为下降率
        platformReportDto.setRatio(platformReportService.getRatio(complaints));
        //类型
        platformReportDto.setType(OrderEnum.投诉总量.getValue());
        list.add(platformReportDto);

        /*
        未提现
         */
        List<PlatformReport> moneys = byIndicatorType.stream().filter(x -> OrderEnum.未提现总额.getValue().equals(x.getReportType().toString())).collect(Collectors.toList());
        //总数
        if(CollUtil.isNotEmpty(moneys)) {
            sum = Convert.toDouble(CollUtil.getFirst(moneys).getIndicator());
        }else {
            sum=0;
        }
        platformReportDto = new PlatformReportDto();
        platformReportDto.setAllNum(businessUtil.changeMoney(Convert.toStr(sum)));
        //日环比 日环比计算方法： (本日回收金额/昨日回收金额 — 1 )× 100%  正值为增长率  负值为下降率
        platformReportDto.setRatio(platformReportService.getRatio(moneys));
        //类型
        platformReportDto.setType(OrderEnum.未提现总额.getValue());
        list.add(platformReportDto);


         /*
        已提现
         */
        List<PlatformReport> withdraws = byIndicatorType.stream().filter(x -> OrderEnum.已提现总额.getValue().equals(x.getReportType().toString())).collect(Collectors.toList());
        //总数
        sum = withdraws.stream().mapToDouble(x -> Convert.toDouble(x.getIndicator())).sum();
        platformReportDto = new PlatformReportDto();
        platformReportDto.setAllNum(businessUtil.changeMoney(Convert.toStr(sum)));
        //日环比 日环比计算方法： (本日回收金额/昨日回收金额 — 1 )× 100%  正值为增长率  负值为下降率
        platformReportDto.setRatio(platformReportService.getRatio(withdraws));
        //类型
        platformReportDto.setType(OrderEnum.已提现总额.getValue());
        list.add(platformReportDto);


        return Result.success(list);

    }


    @PostMapping("/platformReport/detail")
    @ApiOperation(value = "平台总览详情")
    public Result<PlatformReportDetailDto>  findDetail(@RequestBody PlatformReportParamDto platformReportParamDto) {
        String timeType = platformReportParamDto.getTimeType();
        String type = platformReportParamDto.getType();
        List<PlatformReport> list;
        boolean chanageMoneyFlag=false;
        if(OrderEnum.用户量.getValue().equals(type)){
            list=platformReportService.findByTypeAndTimeType(OrderEnum.用户量.getValue(),OrderEnum.按时间统计.getValue(),timeType);
        }else if(OrderEnum.总下单量.getValue().equals(type)){
            list=platformReportService.findByTypeAndTimeType(OrderEnum.总下单量.getValue(),OrderEnum.按时间统计.getValue(),timeType);
        }else if(OrderEnum.总交易金额.getValue().equals(type)){
            list=platformReportService.findByTypeAndTimeType(OrderEnum.总交易金额.getValue(),OrderEnum.按时间统计.getValue(),timeType);
            chanageMoneyFlag=true;
        }else if(OrderEnum.打包站回收金额.getValue().equals(type)){
            list=platformReportService.findByTypeAndTimeType(OrderEnum.打包站回收金额.getValue(),OrderEnum.按时间统计.getValue(),timeType);
        }else if(OrderEnum.投诉总量.getValue().equals(type)){
            list=platformReportService.findByTypeAndTimeType(OrderEnum.投诉总量.getValue(),OrderEnum.按时间统计.getValue(),timeType);
        }else if(OrderEnum.未提现总额.getValue().equals(type)){
            list=platformReportService.findByTypeAndTimeType(OrderEnum.未提现总额.getValue(),OrderEnum.按时间统计.getValue(),timeType);
            chanageMoneyFlag=true;
        }else if(OrderEnum.已提现总额.getValue().equals(type)){
            list=platformReportService.findByTypeAndTimeType(OrderEnum.已提现总额.getValue(),OrderEnum.按时间统计.getValue(),timeType);
        }else {
            list=new ArrayList<>();
        }
        PlatformReportDetailDto platformReportDetailDto = new PlatformReportDetailDto();

        //波浪图数据
        List<MapDto> mapList=CollUtil.newArrayList();
        for (PlatformReport platformReport : list) {
            MapDto mapDto=new MapDto();
            mapDto.setKey(platformReport.getCreateTime());
            if(chanageMoneyFlag){
                mapDto.setValue(businessUtil.changeMoney(platformReport.getIndicator()));
            }else {
                mapDto.setValue(platformReport.getIndicator());
            }
            mapList.add(mapDto);
        }
        platformReportDetailDto.setList(mapList);

        //日均数或3天等
        double sum = list.stream().mapToDouble(x -> Convert.toDouble(x.getIndicator())).sum();
        if(chanageMoneyFlag){
            platformReportDetailDto.setAverageNum(businessUtil.changeMoney(Convert.toStr(sum)));
        }else {
            platformReportDetailDto.setAverageNum(Convert.toStr(Convert.toInt(sum)));
        }
        //最后统计时间
        if(CollUtil.isNotEmpty(list)) {
            platformReportDetailDto.setTime(CollUtil.getLast(list).getCreateTime());
        }else {
            platformReportDetailDto.setTime(DateUtil.yesterday().toDateStr());
        }

        return Result.success(platformReportDetailDto);
    }



    @PostMapping("/platformReport/partner/find")
    @ApiOperation(value = "合伙人总览")
    public Result<List<PlatformReportPartnerResDto>> findByPartner(@RequestBody  PlatformReportPartnerDto platformReportPartnerDto) {
        List<PlatformReportPartnerResDto> list = CollUtil.newArrayList();

        String type = platformReportPartnerDto.getType();

        //按合伙人统计
        List<PlatformReport> byIndicatorType = platformReportService.findByType(type,OrderEnum.按合伙人统计.getValue());

        //按合伙人分组  注意-1的情况
        List<List<PlatformReport>> userIdList = CollUtil.groupByField(byIndicatorType, "userId");

        //设置合伙人名称等
        List<String> partnerIds=CollUtil.newArrayList();
        for (List<PlatformReport> platformReports : userIdList) {
            BigDecimal allNum=BigDecimal.ZERO;
            String userId = platformReports.get(0).getUserId();
            PlatformReportPartnerResDto obj=new PlatformReportPartnerResDto();
            if(Constants.DEFAULT_ID.equals(userId)){
                obj.setName(Constants.DEFAULT_NAME);
            }else {
                String partnerName = cityPartnerService.queryById(Convert.toLong(userId)).getPartnerName();
                obj.setName(partnerName);
            }
            //总数
            double sum;
            if(OrderEnum.未提现总额.getValue().equals(type)){
                sum = platformReports.stream().filter(x->DateUtil.yesterday().toDateStr().equals(x.getCreateTime())).mapToDouble(x -> Convert.toDouble(x.getIndicator())).sum();
            }else {
                sum = platformReports.stream().mapToDouble(x -> Convert.toDouble(x.getIndicator())).sum();
            }
            allNum=NumberUtil.add(allNum,sum);
            obj.setAllNum(Convert.toStr(allNum));
            //日环比
            String ratio = platformReportService.getRatio(platformReports);
            obj.setRatio(ratio);
            list.add(obj);

            partnerIds.add(platformReports.get(0).getUserId());
        }

        //查询所有合伙人
        List<CityPartner> noDel;

        if(OrderEnum.打包站回收金额.getValue().equals(type)){
            noDel= cityPartnerService.findByTypeWithDel(OrderEnum.打包站.getValue());
        }else {
            noDel= cityPartnerService.findByTypeWithDel(OrderEnum.合伙人.getValue());
        }

        noDel=noDel.stream().filter(x->!partnerIds.contains(x.getId()+"")).collect(Collectors.toList());
        //根据名称去重
        noDel= noDel.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(() -> new TreeSet<>(Comparator.comparing(o -> o.getPartnerName()))), ArrayList::new));
        for (CityPartner cityPartner : noDel) {
            PlatformReportPartnerResDto obj=new PlatformReportPartnerResDto();
            obj.setName(cityPartner.getPartnerName());
            obj.setAllNum("0");
            obj.setRatio("+100.00%");
            list.add(obj);
        }

        //按指标数升序
        CollUtil.sort(list, (o1, o2) -> {
            if(Convert.toBigDecimal(o1.getAllNum()).compareTo(Convert.toBigDecimal(o2.getAllNum()))>0){
                return -1;
            }else if(Convert.toBigDecimal(o1.getAllNum()).compareTo(Convert.toBigDecimal(o2.getAllNum()))==0){
                return 0;
            }else {
                return 1;
            }
        });
        return Result.success(list);

    }


}