package com.izouma.awesomeadmin.service.impl;

import com.izouma.awesomeadmin.constant.AppConstant;
import com.izouma.awesomeadmin.dao.OrderAlbumMapper;
import com.izouma.awesomeadmin.dao.OrderAlbumRepairMapper;
import com.izouma.awesomeadmin.dao.OrderRepairMapper;
import com.izouma.awesomeadmin.dao.UserOrderDetailMapper;
import com.izouma.awesomeadmin.dto.Page;
import com.izouma.awesomeadmin.dto.Result;
import com.izouma.awesomeadmin.model.*;
import com.izouma.awesomeadmin.service.OrderImageService;
import com.izouma.awesomeadmin.service.UserOrderDetailService;
import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * service接口实现类
 */
@Service
public class UserOrderDetailServiceImpl implements UserOrderDetailService {
    /*generatedStart*/
    private static Logger logger = Logger.getLogger(UserOrderDetailServiceImpl.class);

    @Autowired
    private UserOrderDetailMapper userOrderDetailMapper;
    /*generatedEnd*/

    @Autowired
    private OrderImageService orderImageService;

    @Autowired
    private OrderAlbumMapper orderAlbumMapper;

    @Autowired
    private OrderRepairMapper orderRepairMapper;

    @Autowired
    private OrderAlbumRepairMapper orderAlbumRepairMapper;

    /*generatedStart*/
    @Override
    public List<UserOrderDetail> getUserOrderDetailList(UserOrderDetail record) {
        logger.info("getUserOrderDetailList");
        try {
            return userOrderDetailMapper.queryAllUserOrderDetail(record);
        } catch (Exception e) {
            logger.error("getUserOrderDetailList", e);
        }
        return null;
    }

    @Override
    public List<UserOrderDetail> getUserOrderDetailByPage(Page page, UserOrderDetail record) {
        logger.info("getUserOrderDetailByPage");
        try {
            Map<String, Object> parameter = new HashMap<String, Object>();
            parameter.put("record", record);
            parameter.put(AppConstant.PAGE, page);

            return userOrderDetailMapper.queryUserOrderDetailByPage(parameter);
        } catch (Exception e) {
            logger.error("getUserOrderDetailByPage", e);
        }
        return null;
    }

    @Override
    public UserOrderDetail getUserOrderDetailById(String id) {
        logger.info("getUserOrderDetailyId");
        try {
            return userOrderDetailMapper.selectByPrimaryKey(Integer.valueOf(id));
        } catch (Exception e) {
            logger.error("getUserOrderDetailById", e);
        }
        return null;
    }

    @Override
    public UserOrderDetail getUserOrderDetail(UserOrderDetail record) {
        logger.info("getUserOrderDetail");
        try {
            return userOrderDetailMapper.queryUserOrderDetail(record);
        } catch (Exception e) {
            logger.error("getUserOrderDetail", e);
        }
        return null;
    }

    @Override
    public boolean createUserOrderDetail(UserOrderDetail record) {
        logger.info("createUserOrderDetail");
        try {
            int updates = userOrderDetailMapper.insertSelective(record);
            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("createUserOrderDetail", e);
        }
        return false;
    }

    @Override
    public boolean deleteUserOrderDetail(UserOrderDetail record) {
        logger.info("deleteUserOrderDetail");
        try {
            int updates = userOrderDetailMapper.delete(record);
            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("deleteUserOrderDetail", e);
        }
        return false;
    }

    @Override
    public boolean updateUserOrderDetail(UserOrderDetail record) {
        logger.info("updateUserOrderDetail");
        try {
            int updates = userOrderDetailMapper.updateByPrimaryKeySelective(record);
            if (updates > 0) {
                return true;
            }
        } catch (Exception e) {
            logger.error("updateUserOrderDetail", e);
        }
        return false;
    }
    /*generatedEnd*/


    @Override
    public Result checkImageAndAlbum(String orderId, String repairId, String albumRepairId) {

        logger.info("checkImageAndAlbum：检测数量");
        try {
            UserOrderDetail resultOrder = new UserOrderDetail();

            UserOrderDetail userOrder = new UserOrderDetail();
            userOrder.setId(Integer.valueOf(orderId));
            userOrder = userOrderDetailMapper.queryUserOrderDetail(userOrder);
            if (userOrder != null) {


                resultOrder.setQuantity(userOrder.getQuantity());
                resultOrder.setAlbumQuantity(userOrder.getAlbumQuantity());

                OrderImage orderImage = orderImageService.checkImageNum(orderId, repairId);

                if (orderImage != null) {
                    resultOrder.setTotalImage(orderImage.getTotalNum());
                    resultOrder.setNeedImage(orderImage.getNeedNum());
                }

                OrderAlbum orderAlbum = new OrderAlbum();
                orderAlbum.setOrderId(orderId);
                orderAlbum.setBaseRepairId(albumRepairId);

                orderAlbum = orderAlbumMapper.checkAlbumNum(orderAlbum);

                if (orderAlbum != null) {
                    if (StringUtils.isNotBlank(albumRepairId)) {

                        resultOrder.setTotalAlbum(orderAlbum.getTotalNum());
                        resultOrder.setNeedAlbum(orderAlbum.getNeedNum());
                    } else {
                        resultOrder.setTotalAlbum(userOrder.getAlbumQuantity());
                        resultOrder.setNeedAlbum(userOrder.getAlbumQuantity() - orderAlbum.getTotalNum());
                    }
                }


            }

            return new Result(true, resultOrder);

        } catch (Exception e) {
            logger.error("refundFail：checkImageAndAlbum异常", e);
        }
        return new Result(false, "checkImageAndAlbum失败");
    }

    @Override
    public Result checkRepairImageAndAlbum(String orderId, String repairId, String albumRepairId) {

        logger.info("checkRepairImageAndAlbum：检测数量");
        try {
            UserOrderDetail resultOrder = new UserOrderDetail();

            UserOrderDetail userOrder = new UserOrderDetail();
            userOrder.setId(Integer.valueOf(orderId));
            userOrder = userOrderDetailMapper.queryUserOrderDetail(userOrder);
            if (userOrder != null) {


                OrderImage orderImage = orderImageService.checkRepairImageNum(orderId, repairId);

                if (orderImage != null) {
                    resultOrder.setTotalImage(orderImage.getTotalNum());
                    resultOrder.setNeedImage(orderImage.getNeedNum());
                    resultOrder.setFailImage(orderImage.getFailNum());
                }

                OrderAlbum orderAlbum = new OrderAlbum();
                orderAlbum.setOrderId(orderId);
                orderAlbum.setBaseRepairId(albumRepairId);

                orderAlbum = orderAlbumMapper.checkRepairAlbumNum(orderAlbum);

                if (orderAlbum != null) {
                    resultOrder.setTotalAlbum(orderAlbum.getTotalNum());
                    resultOrder.setNeedAlbum(orderAlbum.getNeedNum());
                    resultOrder.setFailAlbum(orderAlbum.getFailNum());
                }


            }

            return new Result(true, resultOrder);

        } catch (Exception e) {
            logger.error("checkRepairImageAndAlbum异常", e);
        }
        return new Result(false, "checkRepairImageAndAlbum失败");
    }

    @Override
    public Result updateImageAndAlbumRepair(UserOrderDetail record) {

        logger.info("updateImageAndAlbumRepair：检测数量");
        try {

            if (record.getImageRepairId() != null && record.getImageRepairStatus() != null) {

                OrderRepair orderRepair = new OrderRepair();
                orderRepair.setId(record.getImageRepairId());
                orderRepair.setStatusFlag(record.getImageRepairStatus());
                orderRepairMapper.updateByPrimaryKeySelective(orderRepair);
            }
            if (record.getAlbumRepairId() != null && record.getAlbumRepairStatus() != null) {

                OrderAlbumRepair orderAlbumRepair = new OrderAlbumRepair();
                orderAlbumRepair.setId(record.getAlbumRepairId());
                orderAlbumRepair.setStatusFlag(record.getAlbumRepairStatus());
                orderAlbumRepairMapper.updateByPrimaryKeySelective(orderAlbumRepair);
            }


            return new Result(true, "更新成功");

        } catch (Exception e) {
            logger.error("updateImageAndAlbumRepair异常", e);
        }
        return new Result(false, "updateImageAndAlbumRepair失败");
    }

    @Override
    public Result confirm(UserOrderDetail record) {

        logger.info("confirm：确认完成订单");
        try {
            UserOrderDetail userOrder = userOrderDetailMapper.selectByPrimaryKey(record.getId());
            if (userOrder != null) {

                boolean confirmFlag = false;


                if (AppConstant.OrderAlbumStatus.WAIT_ACCEPT == userOrder.getAlbumStatus() ||
                        AppConstant.OrderAlbumStatus.REWORK_ACCEPT == userOrder.getAlbumStatus()) {//修图完成

                    confirmFlag = true;
                    record.setAlbumStatus(AppConstant.OrderAlbumStatus.FINISH);


                }


                if (confirmFlag) {

                    userOrderDetailMapper.updateByPrimaryKeySelective(record);

                }
            }

            return new Result(true, "confirm：确认完成成功");

        } catch (Exception e) {
            logger.error("confirm：确认完成异常", e);
        }
        return new Result(false, "confirm：确认完成失败");
    }

    /**
     * 返修
     *
     * @param record
     * @return
     */
    @Override
    public boolean repair(UserOrderDetail record) {

        logger.info("repair");
        try {

            if (record.getId() != null && record.getId() > 0) {
                if ("order_image".equals(record.getAcceptType()) || "image_album".equals(record.getAcceptType())) {

                    record.setAlbumStatus(AppConstant.OrderAlbumStatus.REWORK);
                    OrderRepair orderRepair = new OrderRepair();
                    orderRepair.setOrderId(record.getId() + "");
                    orderRepairMapper.repairByOrderId(orderRepair);

                }

                if ("order_album".equals(record.getAcceptType()) || "image_album".equals(record.getAcceptType())) {

                    record.setAlbumStatus(AppConstant.OrderAlbumStatus.REWORK);
                    OrderAlbumRepair orderAlbumRepair = new OrderAlbumRepair();
                    orderAlbumRepair.setOrderId(record.getId() + "");
                    orderAlbumRepairMapper.repairByOrderId(orderAlbumRepair);
                }

                int updates = userOrderDetailMapper.updateByPrimaryKeySelective(record);
                if (updates > 0) {
                    return true;
                }
            }


        } catch (Exception e) {
            logger.error("repair", e);
        }

        return false;
    }

}