package com.example.northglasserpclient.service.sd.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.northglasserpclient.domain.dto.sd.OrderDTO;
import com.example.northglasserpclient.domain.dto.sd.OrderDetailDTO;
import com.example.northglasserpclient.domain.po.sd.Order;
import com.example.northglasserpclient.domain.po.sd.OrderDetail;
import com.example.northglasserpclient.domain.po.sd.OrderGlassDetail;
import com.example.northglasserpclient.domain.po.sd.OrderProcessDetail;
import com.example.northglasserpclient.mapper.sd.OrderMapper;
import com.example.northglasserpclient.mapper.sd.OrderProcessDetailMapper;
import com.example.northglasserpclient.service.sd.IOrderDetailService;
import com.example.northglasserpclient.service.sd.IOrderGlassDetailService;
import com.example.northglasserpclient.service.sd.IOrderProcessDetailService;
import com.example.northglasserpclient.service.sd.IOrderService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.*;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author guo
 * @since 2025-09-18
 */
@Service
@RequiredArgsConstructor
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> implements IOrderService {

    private final IOrderDetailService orderDetailService;
    private final IOrderProcessDetailService orderProcessDetailService;
    private final IOrderGlassDetailService orderGlassDetailService;
    private final OrderProcessDetailMapper orderProcessDetailMapper;
    @Override
    public List<OrderDTO> getUnfinishedOrder(String customId) {
        List<Order> orders  =  list(
                new LambdaQueryWrapper<Order>()
                        .eq(Order::getCustomerId, customId)
                        .eq(Order::getCreateOrder, 2)
                        .ne(Order::getDelivery, 2)
                        .orderByDesc(Order::getId)
        );

        List<OrderDTO> ordersDTO = JSON.parseObject(
                JSON.toJSONString(orders),
                new TypeReference<List<OrderDTO>>(){}
        );

        //循环所有订单，获取订单按照产品分类进行订单明细 汇总查询
        ordersDTO.forEach(order -> {
            List<OrderDetail> details = orderDetailService.list(
                    new QueryWrapper<OrderDetail>()
                            .select("order_id,order_number,product_id,product_name," +
                                    "sum(quantity) as quantity," +
                                    "sum(warehouse_num+delivery_num) as warehouse_num,"+
                                    "sum(delivery_num) as delivery_num"
                            )
                            .eq("order_id", order.getOrderId())
                            .groupBy("product_id")
            );
            //list转换成DTO,返回前端显示
            List<OrderDetailDTO> detailsDTO = JSON.parseObject(
                    JSON.toJSONString(details),
                    new TypeReference<List<OrderDetailDTO>>(){}
            );
            //循环获取每个产品的完成数
            detailsDTO.forEach(detail -> {





                //获取产品生产订单号例："NG25082706A"做条件,查询生产订单明细表，获取生产总数量
                OrderGlassDetail glassDetail = orderGlassDetailService
                        .getOne(new LambdaQueryWrapper<OrderGlassDetail>()
                                .eq(OrderGlassDetail::getOrderId, detail.getOrderId())
                                .eq(OrderGlassDetail::getOrderNumber, detail.getOrderNumber())
                                .orderByAsc(OrderGlassDetail::getId)
                                .last("limit 1")
                        );
                //给产品信息添加生产数量
                if(glassDetail != null){
                    Integer getReportingWorkNum = orderProcessDetailMapper
                            .getProductionQuantity(detail.getOrderId(),
                                    glassDetail.getProductionId()
                            );

                    detail.setQuantityByProduced(getReportingWorkNum);
                }else{
                    detail.setQuantityByProduced(0);
                }
            });
            Integer deliveryNum = detailsDTO.stream().map(OrderDetail::getDeliveryNum).reduce(Integer::sum).get();
            order.setPercent(deliveryNum/Math.toIntExact(order.getQuantity())*100);
            order.setOrderDetails(detailsDTO);
        });
        return ordersDTO;
    }

    @Override
    public List<OrderDetailDTO> getOrderProgress(String orderId, String productId) {
        //获取此订单 产品所有订单明细
        List<OrderDetail> detailList = orderDetailService.list(
                new LambdaQueryWrapper<OrderDetail>()
                        .eq(OrderDetail::getOrderId, orderId)
                        .eq(OrderDetail::getProductId, productId)
        );
        List<OrderDetailDTO> detailListDTO = JSON.parseObject(
                JSON.toJSONString(detailList),
                new TypeReference<List<OrderDetailDTO>>(){}
        );
        //获取订单生产明细
        detailListDTO.forEach(detail1 -> {
            List<OrderProcessDetail> processDetailsGroupByProcessId = orderProcessDetailService.list(
                    new LambdaQueryWrapper<OrderProcessDetail>()
                            .eq(OrderProcessDetail::getOrderId, detail1.getOrderId())
                            .eq(OrderProcessDetail::getOrderNumber, detail1.getOrderNumber())
                            .groupBy(OrderProcessDetail::getProcessId)
                            .groupBy(OrderProcessDetail::getTechnologyNumber)
                            .orderByAsc(OrderProcessDetail::getOrderNumber)
                            .orderByAsc(OrderProcessDetail::getTechnologyNumber)

            );
            //定义一个map，key为生产工序号+工艺号，value为生产明细
            Map<String,List<OrderProcessDetail>> orderProcessDetailCount = new HashMap<>();
            processDetailsGroupByProcessId.forEach(detail2 -> {
                List<OrderProcessDetail> processDetails = orderProcessDetailService.list(
                        new LambdaQueryWrapper<OrderProcessDetail>()
                                .eq(OrderProcessDetail::getOrderId, detail2.getOrderId())
                                .eq(OrderProcessDetail::getOrderNumber, detail2.getOrderNumber())
                                .eq(OrderProcessDetail::getProcessId, detail2.getProcessId())
                                .eq(OrderProcessDetail::getTechnologyNumber, detail2.getTechnologyNumber())
                );
                orderProcessDetailCount.put(detail2.getProcessId()+"/"+detail2.getTechnologyNumber(),
                        processDetails);

            });
            //给订单明细添加生产明细
            detail1.setOrderProcessDetails(orderProcessDetailCount);


        });
        return detailListDTO;
    }

    @Override
    public Map<String,Object> getFinishedOrder(Map<String,Object> object) {

        List<String> dates = (List<String>) object.get("searchDate");
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(180).toString();
        if(dates !=null && dates.size()==2){
            if(!dates.get(0).isEmpty()){
                startDate = dates.get(0);
            }
            if(!dates.get(1).isEmpty()){
                endDate = dates.get(1);
            }
        }

        //获取此客户所有完成的订单
        List<Order> orders  =  list(
                new LambdaQueryWrapper<Order>()
                        .eq(Order::getCustomerId, object.get("customerId"))
                        .eq(Order::getCreateOrder, 2)
                        .eq(Order::getDelivery, 2)
                        .between(Order::getCreateTime, startDate, endDate)
                        .orderByDesc(Order::getId)
        );
        List<OrderDTO> ordersDTO = JSON.parseObject(
                JSON.toJSONString(orders),
                new TypeReference<List<OrderDTO>>(){}
        );
        Map<String,Object> result = new HashMap<>();
        result.put("orders",ordersDTO);
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        result.put("searchDate",list);

        return result;
    }

    @Override
    public List<OrderDetail> getOrderDetail(String orderId) {
        return orderDetailService.list(new LambdaQueryWrapper<OrderDetail>().eq(OrderDetail::getOrderId,orderId));
    }
}