package com.demo.wjj.controller;

import com.demo.wjj.bo.DisplaceDetailBo;
import com.demo.wjj.bo.DisplaceListBo;
import com.demo.wjj.bo.ImgListBo;
import com.demo.wjj.bo.SaveDisplaceBo;
import com.demo.wjj.converter.SaveDisplaceConverter;
import com.demo.wjj.po.DisplaceAudit;
import com.demo.wjj.po.TbImgItem;
import com.demo.wjj.qo.SaveDisplaceQo;
import com.demo.wjj.service.*;
import com.demo.wjj.utils.ApiResult;
import com.demo.wjj.utils.ExecuteResult;
import com.demo.wjj.utils.PageBean;
import com.demo.wjj.utils.Result;
import com.demo.wjj.validator.SaveDisplaceQoValidator;
import com.github.pagehelper.PageInfo;
import com.qiniu.processing.OperationStatus;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * 置换
 *
 * @author wangqing
 * @date 2018.11.13
 */
@RequestMapping("/displace")
@RestController
public class DisplaceController {

    private final Logger LOG = LoggerFactory.getLogger(getClass());

    @Autowired
    private SaveDisplaceQoValidator saveDisplaceQoValidator;
    @Autowired
    private SaveDisplaceConverter saveDisplaceConverter;

    @Autowired
    private DisplaceManage displaceManage;

    @Autowired
    private DisplaceAuditService displaceAuditService;

    @Autowired
    private TbImgItemService tbImgItemService;

    @Autowired
    private TbImgListService tbImgListService;

    @Autowired
    QiNiuService qiNiuService;

    /**
     * 精品机账号
     */
    @Value("ZHXTCS")
    private String excellentAccount;

    @InitBinder
    protected void initBinder(WebDataBinder binder) {
        Object target = binder.getTarget();
        if (target == null) {
            return;
        }
        if (saveDisplaceQoValidator.supports(target.getClass())) {
            binder.addValidators(saveDisplaceQoValidator);
        }

    }

    /**
     * 保存置换
     *
     * @param saveDisplaceQo 置换参数
     * private String is_good;//1-普通2-精品
     * private String storage;//1-完成；2-暂存
     * @return apiResult
     */
    @PostMapping("/save")
    public ApiResult save(@Valid SaveDisplaceQo saveDisplaceQo, BindingResult bindingResult) {
        LOG.info("调用保存置换(/displace/save)接口, saveDisplaceQo:{}", saveDisplaceQo);
        if(saveDisplaceQo.getAgentId().equals(excellentAccount)){
            saveDisplaceQo.setIs_good("2");
        }else{
            saveDisplaceQo.setIs_good("1");
        }

        if(StringUtils.isBlank(saveDisplaceQo.getStorage())){
            saveDisplaceQo.setStorage("1");
        }

        if (CollectionUtils.isNotEmpty(bindingResult.getAllErrors())) {
            LOG.warn("请求参数错误");
            return ApiResult.createFailure();
        }
        final String[] pictureSubfixs = {".BMP", ".JPG", ".JPEG", ".PNG", ".GIF", ".bmp", ".jpg", ".jpeg", ".png", ".gif"};
        try {
            SaveDisplaceBo convert = saveDisplaceConverter.convert(saveDisplaceQo);

            //获取图片列表
            List<SaveDisplaceBo.DisplaceImageList> displaceImageLists = convert.getPicture();

            //便利图片数组 给予分类存储
            for (SaveDisplaceBo.DisplaceImageList displaceImage : displaceImageLists) {
                List<String> picList = new ArrayList<>();
                //转码
                for(String key:displaceImage.getPic()){
                    String keyModel=key;
                    String subfix = key.substring(key.lastIndexOf("."));
                    if (!ArrayUtils.contains(pictureSubfixs, subfix)){
                        OperationStatus operationStatus=qiNiuService.persisted(key);
                        LOG.info("operationStatus======"+operationStatus);
                        LOG.info("operationStatus======"+operationStatus.inputKey);
                        keyModel="weigongcheng_"+key;
                        LOG.info("keyModel======"+keyModel);
                    }
                    picList.add(keyModel);
                    LOG.info("picList======"+picList);
                }
                displaceImage.setPic(null);
                displaceImage.setPic(picList);
                //获取细节分类id
                Integer detailId = displaceImage.getDetailId();
                //detail袭击目录不等于空
                if (detailId != null) {
                    //通过细节分类id查询二级分类
                    TbImgItem tbImgItem = tbImgItemService.findOne(detailId);
                    //查询二级目录
                    List<ImgListBo> imgListBos = tbImgListService.findAll();
                    //细节分类
                    if (tbImgItem != null) {
                        //从数据库中获取二级分类id
                        Integer imgBqId = tbImgItem.getImgBqId();
                        //组装二级识别码
                        String imgBqIdStr = "IMG_"+imgBqId;
                        //遍历每个二级分类 查询当前图片分类是否有匹配的
                        for (ImgListBo imgListBo : imgListBos) {
                            //查看图片分类是否属于二级分类
                            if (imgListBo.getListCode().equals(imgBqIdStr)) {
                                displaceImage.setCode(imgListBo.getListCode());
                            }
                        }
                   /*     switch (imgBqId){
                            case 1 : displaceImage.setCode("IMG_1"); break;
                            case 2 : displaceImage.setCode("IMG_2"); break;
                            case 3 : displaceImage.setCode("IMG_3"); break;
                            case 4 : displaceImage.setCode("IMG_4"); break;
                            case 5 : displaceImage.setCode("IMG_5"); break;
                            case 6 : displaceImage.setCode("IMG_6"); break;
                            case 7 : displaceImage.setCode("IMG_7"); break;
                            default: displaceImage.setCode(""); break;
                        }*/
                    }
                }
            }

            LOG.info("gg组装的图片集合 displaceImageLists{}",displaceImageLists);
            //把修改好的图片放入集合中
            convert.setPicture(displaceImageLists);

            ExecuteResult<Boolean> executeResult = displaceManage.save(convert);
            ApiResult apiResult;
            if (executeResult.isExecuteResult()) {
                apiResult = executeResult.getData() ? ApiResult.createSuccess(null) : ApiResult.createFailure();
            } else {
                Result result = executeResult.getResult();
                if (result != null) {
                    apiResult = new ApiResult(result);
                } else {
                    apiResult = ApiResult.createFailure();
                }
            }
            LOG.info("调用保存置换(/displaceManage/save)接口成功, apiResult:{}", apiResult);
            return apiResult;
        } catch (Exception e) {
            LOG.error("调用保存置换(/displaceManage/save)接口异常", e);
            return ApiResult.createFailure();
        }
    }

    /**
     * 获取未审核置换列表
     *
     * @param agentId 商家id
     * @param openId  微信openId
     * @param request request
     * @return apiResult
     */
    @GetMapping("/queryUndoList")
    public ApiResult queryUndoList(@RequestParam(required = false) String agentId, @RequestParam(required = false) String openId, HttpServletRequest request) {
        LOG.info("调用获取未审核置换列表(/displace/queryUndoList)接口, agentId:{}, openId:{}", agentId, openId);

        if (StringUtils.isBlank(agentId)) {
            LOG.info("agentId为空");
            return ApiResult.createFailure();
        }

        if (StringUtils.isBlank(openId)) {
            LOG.info("微信openId为空");
            return ApiResult.createFailure();
        }

        try {
            PageInfo<DisplaceListBo> pageInfo = displaceAuditService.queryUndoDisplaceList(agentId, openId, PageBean.create(request));
            ApiResult<PageInfo<DisplaceListBo>> apiResult = ApiResult.createSuccess(pageInfo);
            LOG.info("调用获取未审核置换列表(/displace/queryUndoList)接口成功");
            LOG.debug("未审核置换列表, apiResult:{}", apiResult);
            return apiResult;
        } catch (Exception e) {
            LOG.error("调用获取未审核置换列表(/displace/queryUndoList)接口异常", e);
            return ApiResult.createFailure();
        }
    }

    /**
     * 获取已审核置换列表
     *
     * @param agentId 商家id
     * @param openId  微信openId
     * @param request request
     * @return apiResult
     */
    @GetMapping("/queryDoneList")
    public ApiResult queryDoneList(@RequestParam(required = false) String agentId, @RequestParam(required = false) String openId, HttpServletRequest request) {
        LOG.info("调用获取已审核置换列表(/displace/queryDoneList)接口, agentId:{}, openId:{}", agentId, openId);

        if (StringUtils.isBlank(agentId)) {
            LOG.info("agentId为空");
            return ApiResult.createFailure();
        }

        if (StringUtils.isBlank(openId)) {
            LOG.info("微信openId为空");
            return ApiResult.createFailure();
        }

        try {
            PageInfo<DisplaceListBo> pageInfo = displaceAuditService.queryDoneDisplaceList(agentId, openId, PageBean.create(request));
            ApiResult<PageInfo<DisplaceListBo>> apiResult = ApiResult.createSuccess(pageInfo);
            LOG.info("调用获取已审核置换列表(/displace/queryDoneList)接口成功");
            LOG.debug("未审核置换列表, apiResult:{}", apiResult);
            return apiResult;
        } catch (Exception e) {
            LOG.error("调用获取已审核置换列表(/displace/queryDoneList)接口异常", e);
            return ApiResult.createFailure();
        }
    }

    /**
     * 查询被驳回的置换设备数量
     *
     * @param agentId
     * @param openId
     * @return
     */
    @GetMapping("/queryRejectedCount")
    public ApiResult queryRejectedCount(@RequestParam(required = false) String agentId, @RequestParam(required = false) String openId) {
        LOG.info("调用查询被驳回的置换设备数量(/displace/queryRejectedCount)接口, agentId:{}, openId:{}", agentId, openId);
        if (StringUtils.isBlank(agentId)) {
            LOG.info("agentId为空");
            return ApiResult.createFailure();
        }

        if (StringUtils.isBlank(openId)) {
            LOG.info("openId为空");
            return ApiResult.createFailure();
        }

        try {
            final int rejectedDisplaceCount = displaceAuditService.getRejectedDisplaceCount(agentId, openId);
            Map<String, Integer> data = new HashMap<>();
            data.put("count", rejectedDisplaceCount);
            final ApiResult<Map<String, Integer>> apiResult = ApiResult.createSuccess(data);
            LOG.info("调用查询被驳回的置换设备数量(/displace/queryRejectedCount)接口成功, apiResult:{}", apiResult);
            return apiResult;
        } catch (Exception e) {
            LOG.error("调用查询被驳回的置换设备数量(/displace/queryRejectedCount)接口异常", e);
            return ApiResult.createFailure();
        }
    }

    /**
     * 获取置换详情
     *
     * @param id 置换id
     * @return apiResult
     */
    @GetMapping("/getDetails")
    public ApiResult getDetails(@RequestParam(required = false) String id) {
        LOG.info("调用获取置换详情(/displace/getDetails)接口, id:{}", id);
        if (StringUtils.isBlank(id)) {
            LOG.info("id为空");
            return ApiResult.createFailure();
        }

        try {
            DisplaceDetailBo displaceDetail = displaceAuditService.getDisplaceDetail(id);
            ApiResult<DisplaceDetailBo> apiResult = ApiResult.createSuccess(displaceDetail);
            LOG.info("调用获取置换详情(/displace/getDetails)接口成功, apiResult:{}", apiResult);
            return apiResult;
        } catch (Exception e) {
            LOG.error("调用获取置换详情(/displace/getDetails)接口异常", e);
            return ApiResult.createFailure();
        }
    }

    /**
     * 根据类型查询精品设备
     *
     * @param type 1-在售设备”、“2停售设备”、“3成交设备”、“4我的秒杀
     * @return apiResult
     */
    @GetMapping("/getDisplaceGoodBuyList")
    public ApiResult getDisplaceGoodBuyList(@RequestParam(required = false) String type,@RequestParam(required = false) String agentId, @RequestParam(required = false) String openId, HttpServletRequest request){
        LOG.info("根据类型查询设备列表(/displace/getDisplaceList)接口, agentId:{}, openId:{}, type:{}", agentId, openId, type);

        if (StringUtils.isBlank(agentId)) {
            LOG.info("agentId为空");
            return ApiResult.createFailure();
        }

        if (StringUtils.isBlank(openId)) {
            LOG.info("微信openId为空");
            return ApiResult.createFailure();
        }

        try {
            PageInfo<DisplaceListBo> pageInfo = displaceAuditService.queryTypeDisplaceList(agentId, openId, type, PageBean.create(request));
            ApiResult<PageInfo<DisplaceListBo>> apiResult = ApiResult.createSuccess(pageInfo);
            LOG.info("根据类型查询设备列表(/displace/getDisplaceList)接口成功");
            LOG.debug("置换列表, apiResult:{}", apiResult);
            return apiResult;
        } catch (Exception e) {
            LOG.error("根据类型查询设备列表(/displace/getDisplaceList)接口异常", e);
            return ApiResult.createFailure();
        }
    }

    /**
     * 根据类型查询我要卖精品设备
     *
     *
     * @return apiResult
     */
    @GetMapping("/getDisplaceGoodSaleList")
    public ApiResult getDisplaceGoodSaleList(@RequestParam(required = false) String agentId,
                                             @RequestParam(required = false) String openId,
                                             HttpServletRequest request){
        LOG.info("根据类型查询设备列表(/displace/getDisplaceList)接口, agentId:{}, openId:{}", agentId, openId);

        if (StringUtils.isBlank(agentId)) {
            LOG.info("agentId为空");
            return ApiResult.createFailure();
        }

        if (StringUtils.isBlank(openId)) {
            LOG.info("微信openId为空");
            return ApiResult.createFailure();
        }

        try {
            PageInfo<DisplaceListBo> pageInfo = displaceAuditService.getDisplaceGoodSaleList(agentId, openId, PageBean.create(request));
            ApiResult<PageInfo<DisplaceListBo>> apiResult = ApiResult.createSuccess(pageInfo);
            LOG.info("根据类型查询设备列表(/displace/getDisplaceList)接口成功");
            LOG.debug("置换列表, apiResult:{}", apiResult);
            return apiResult;
        } catch (Exception e) {
            LOG.error("根据类型查询设备列表(/displace/getDisplaceList)接口异常", e);
            return ApiResult.createFailure();
        }
    }

    /**
     * 用户报价与保留价比较
     */
    @GetMapping("/judge")
    public ApiResult judge(@RequestParam(required = false) String displaceId){
        if (StringUtils.isBlank(displaceId)) {
            LOG.info("displaceId为空");
            return ApiResult.createFailure();
        }

        try {
            DisplaceAudit displaceAudit = displaceAuditService.getDisplaceAudit(displaceId);
            ApiResult<DisplaceAudit> apiResult = ApiResult.createSuccess(displaceAudit);
            LOG.info("根据置换id用户报价与保留价比较(/displace/judge)接口成功");
            LOG.debug("置换列表, apiResult:{}", apiResult);
            return apiResult;
        } catch (Exception e) {
            LOG.error("根据置换id用户报价与保留价比较(/displace/judge)接口异常", e);
            return ApiResult.createFailure();
        }
    }

    /**
     * 查询暂存列表
     *
     *
     * @return apiResult
     */
    @GetMapping("/getDisplaceStorageList")
    public ApiResult getDisplaceStorageList(@RequestParam(required = false) String storageStatus,
                                            @RequestParam(required = false) String agentId,
                                            @RequestParam(required = false) String openId,
                                            HttpServletRequest request){
        LOG.info("查询暂存列表(/displace/getDisplaceStorageList)接口, agentId:{}, openId:{}", agentId, openId);

        if (StringUtils.isBlank(agentId)) {
            LOG.info("agentId为空");
            return ApiResult.createFailure();
        }

        if (StringUtils.isBlank(openId)) {
            LOG.info("微信openId为空");
            return ApiResult.createFailure();
        }

        try {
            PageInfo<DisplaceListBo> pageInfo = displaceAuditService.getDisplaceStorageList(agentId, openId,storageStatus, PageBean.create(request));
            ApiResult<PageInfo<DisplaceListBo>> apiResult = ApiResult.createSuccess(pageInfo);
            LOG.info("查询暂存列表(/displace/getDisplaceStorageList)接口成功");
            LOG.debug("置换列表, apiResult:{}", apiResult);
            return apiResult;
        } catch (Exception e) {
            LOG.error("查询暂存列表(/displace/getDisplaceStorageList)接口异常", e);
            return ApiResult.createFailure();
        }
    }

    /**
     * 查询待确认置换列表
     *
     */
    @GetMapping("/getDisplaceConfirmList")
    public ApiResult getDisplaceConfirmList(@RequestParam(required = false) String agentId,
                                            @RequestParam(required = false) String openId,
                                            HttpServletRequest request){
        LOG.info("查询暂存列表(/displace/getDisplaceStorageList)接口, agentId:{}, openId:{}", agentId, openId);

        if (StringUtils.isBlank(agentId)) {
            LOG.info("agentId为空");
            return ApiResult.createFailure();
        }

        if (StringUtils.isBlank(openId)) {
            LOG.info("微信openId为空");
            return ApiResult.createFailure();
        }

        try {
            PageInfo<DisplaceListBo> pageInfo = displaceAuditService.getDisplaceConfirmList(agentId, openId, PageBean.create(request));
            ApiResult<PageInfo<DisplaceListBo>> apiResult = ApiResult.createSuccess(pageInfo);
            LOG.info("查询暂存列表(/displace/getDisplaceStorageList)接口成功");
            LOG.debug("置换列表, apiResult:{}", apiResult);
            return apiResult;
        } catch (Exception e) {
            LOG.error("查询暂存列表(/displace/getDisplaceStorageList)接口异常", e);
            return ApiResult.createFailure();
        }
    }
}