package com.cf.imes.module.executor.dal.mysql.orderBody;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.cf.imes.framework.mybatis.core.mapper.BaseMapperX;
import com.cf.imes.framework.mybatis.core.query.LambdaQueryWrapperX;
import com.cf.imes.module.executor.controller.admin.order.vo.order.OrderModuleRespVO;
import com.cf.imes.module.executor.controller.admin.order.vo.product.OrderRoomBodyRespVO;
import com.cf.imes.module.executor.dal.dataobject.orderBody.OrderBodyDO;
import com.cf.imes.module.executor.dal.dataobject.orderBody.OrderBodyPlateNumDO;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;

import java.util.Collection;
import java.util.List;
import java.util.Set;

/**
 * 订单柜体 Mapper
 *
 * @author 晨丰科技
 */
@Mapper
public interface OrderBodyMapper extends BaseMapperX<OrderBodyDO> {

    int updatePlateNumById(@Param("orderId") Long orderId, @Param("plateNum") Double plateNum);

    int deleteAllByOrderId(@Param("orderId") Long orderId, @Param("bodyId") Long bodyId); // item表数据未作筛选

    List<OrderModuleRespVO> selectModuleByOrderId(@Param("orderId") Long orderId,
                                                  @Param("organId") Long organId,
                                                  @Param("deleted") Integer deleted);

    List<OrderBodyDO> getOrderBodyByOrderId(@Param("orderId") Long orderId, @Param("organId") Long organId);

    // 单个修改删除状态 by orderID
    default int updateOrderDeleted(Long id, Integer deleted, Long organId) {
        LambdaUpdateWrapper<OrderBodyDO> wrapper = new LambdaUpdateWrapper<OrderBodyDO>()
                .set(OrderBodyDO::getDeleted, deleted)
                .eq(OrderBodyDO::getOrderId, id)
                .eq(OrderBodyDO::getOrganId, organId);

        if (deleted == 0)
            wrapper.eq(OrderBodyDO::getDeleted, 1);
        return update(wrapper);
    }

    // 单个修改删除状态 by id
    default int updateDeletedById(Collection<Long> ids, Integer deleted, Long organId, Long orderId) {
        return update(new LambdaUpdateWrapper<OrderBodyDO>()
                .set(OrderBodyDO::getDeleted, deleted)
                .in(OrderBodyDO::getId, ids)
                .eq(OrderBodyDO::getOrganId, organId)
                .eq(OrderBodyDO::getOrderId, orderId));
    }

    default int updateDeletedBody(Collection<Long> ids , Long organId, Long orderId) {
        return update(new LambdaUpdateWrapper<OrderBodyDO>()
                .set(OrderBodyDO::getDeleted, true)
                .eq(OrderBodyDO::getOrganId, organId)
                .eq(OrderBodyDO::getOrderId, orderId)
                .in(OrderBodyDO::getId, ids));
    }


    default int updateNoDeletedBody(Collection<Long> ids , Long organId, Long orderId) {
        return update(new LambdaUpdateWrapper<OrderBodyDO>()
                .set(OrderBodyDO::getDeleted, false)
                .eq(OrderBodyDO::getOrganId, organId)
                .eq(OrderBodyDO::getOrderId, orderId)
                .in(OrderBodyDO::getId, ids));
    }



    default int deletedByOrderId(Long orderId, Long organId) {
        return delete(new LambdaUpdateWrapper<OrderBodyDO>()
                .eq(OrderBodyDO::getOrderId, orderId)
                .eq(OrderBodyDO::getOrganId, organId));
    }


    // 控制是否删除，进行查询
    default List<OrderBodyDO> selectList(Long orderId, Integer deleted, Long organId) {
        return selectList(new LambdaUpdateWrapper<OrderBodyDO>()
                .eq(OrderBodyDO::getOrderId, orderId)
                .eq(OrderBodyDO::getDeleted, deleted)
                .eq(OrderBodyDO::getOrganId, organId));
    }


    List<OrderRoomBodyRespVO> selectRoomAndBody(@Param("orderIds") List<Long> orderIds, @Param("organId") Long organId);

    // 订单柜体记录数量
    default int selectCountByOrderId(Long orderId, Long organId, Integer deleted) {
        return Math.toIntExact(selectCount(new LambdaUpdateWrapper<OrderBodyDO>()
                .eq(OrderBodyDO::getOrderId, orderId)
                .eq(OrderBodyDO::getDeleted, deleted)
                .eq(OrderBodyDO::getOrganId, organId)));
    }



    default int selectBodyCountByDeleted(Long orderId, Long organId , Integer deleted) {
        return Math.toIntExact(selectCount(new LambdaUpdateWrapper<OrderBodyDO>()
                .eq(OrderBodyDO::getOrganId, organId)
                .eq(OrderBodyDO::getOrderId, orderId)
                .eq(OrderBodyDO::getDeleted, deleted)));
    }



    //    按照房间名称查询
    default List<OrderBodyDO> selectByRoomName(Long orderId, String roomName,
                                               Long organId, Integer deleted) {
        return selectList(new LambdaUpdateWrapper<OrderBodyDO>()
                .eq(OrderBodyDO::getOrderId, orderId)
                .eq(OrderBodyDO::getRoomName, roomName)
                .eq(OrderBodyDO::getDeleted, deleted)
                .eq(OrderBodyDO::getOrganId, organId));
    }

    //    按照房间id和柜体名称查询
    default OrderBodyDO selectByRoomIdAndBodyName(Long orderId, Long roomId,
                                                  String bodyName, Long organId, Integer deleted) {
        return selectOne(new LambdaUpdateWrapper<OrderBodyDO>()
                .eq(OrderBodyDO::getOrderId, orderId)
                .eq(OrderBodyDO::getRoomId, roomId)
                .eq(OrderBodyDO::getName, bodyName)
                .eq(OrderBodyDO::getDeleted, deleted)
                .eq(OrderBodyDO::getOrganId, organId));
    }

    //    根据房间id查找OrderBodyDO的id
    default List<Long> selectBodyIdByRoomId(Long orderId, Set<Long> roomIds, Long organId, Integer deleted) {
        return selectList(new LambdaQueryWrapper<OrderBodyDO>()
                .eq(OrderBodyDO::getOrderId, orderId)
                .in(OrderBodyDO::getRoomId, roomIds)
                .eq(OrderBodyDO::getOrganId, organId)
                .eq(OrderBodyDO::getDeleted, deleted)
                .select(OrderBodyDO::getId)).stream()
                .map(OrderBodyDO::getId)
                .toList();
    }


    default List<Long> selectNoDeletedBodyId(Long orderId, Set<Long> roomIds, Long organId) {
        return selectList(new LambdaQueryWrapper<OrderBodyDO>()
                .eq(OrderBodyDO::getOrganId, organId)
                .eq(OrderBodyDO::getOrderId, orderId)
                .in(OrderBodyDO::getRoomId, roomIds)
                .eq(OrderBodyDO::getDeleted, false)
                .select(OrderBodyDO::getId)).stream()
                .map(OrderBodyDO::getId)
                .toList();
    }


    default List<Long> selectDeletedBodyId(Long orderId, Set<Long> roomIds, Long organId) {
        return selectList(new LambdaQueryWrapper<OrderBodyDO>()
                .eq(OrderBodyDO::getOrganId, organId)
                .eq(OrderBodyDO::getOrderId, orderId)
                .in(OrderBodyDO::getRoomId, roomIds)
                .eq(OrderBodyDO::getDeleted, true)
                .select(OrderBodyDO::getId)).stream()
                .map(OrderBodyDO::getId)
                .toList();
    }




    //    根据订单进行删除
    default int deleteByOrderId(Long orderId, Long organId) {
        return delete(new LambdaQueryWrapperX<OrderBodyDO>()
                .eq(OrderBodyDO::getOrganId, organId)
                .eqIfPresent(OrderBodyDO::getOrderId, orderId));
    }

    // 批量删除
    default int deleteBatch(Collection<?> orderId) {
        return delete(new LambdaQueryWrapperX<OrderBodyDO>()
                .in(OrderBodyDO::getOrderId, orderId));
    }


    List<OrderBodyDO> selectPlanBodyRoomDataSource(@Param("filed")  String filed,@Param("bodyIds") List<Long> bodyIds,@Param("organId")  Long organId);



    default List<OrderBodyDO> selectOrderBodyList(List<Long> bodyIds,List<Long> orderIds, Long organId) {
        return selectList(new LambdaQueryWrapperX<OrderBodyDO>()
                .eq(OrderBodyDO::getOrganId, organId)
                .eq(OrderBodyDO::getDeleted,false)
                .in(OrderBodyDO::getOrderId,orderIds)
                .in(OrderBodyDO::getId, bodyIds)
                .select(OrderBodyDO::getId,OrderBodyDO::getName,OrderBodyDO::getRoomName));
    }

    /**
     * 查询柜体下的板件数量和面积
     *
     * @param orderBodyIds
     * @return
     */
    List<OrderBodyPlateNumDO> selectPlateNumAndArea(@Param("orderBodyIds") Collection<Long> orderBodyIds, @Param("delete") Boolean delete);

    /**
     * 物理删除订单材质
     *
     * @return
     */
    int physicalDeleteByOrderIds(@Param("ids") List<Long> ids);
}