package com.zy.asrs.controller;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.core.annotations.ManagerAuth;
import com.core.common.*;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.entity.param.CheckDTO;
import com.zy.asrs.entity.param.OrderCheckParam;
import com.zy.asrs.entity.result.KeyValueVo;
import com.zy.asrs.service.*;
import com.zy.common.CodeRes;
import com.zy.common.config.AdminInterceptor;
import com.zy.common.utils.BarcodeUtils;
import com.zy.common.utils.QrCode;
import com.zy.common.web.BaseController;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.imageio.ImageIO;
import javax.servlet.http.HttpServletResponse;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.*;

import static jdk.nashorn.api.scripting.ScriptUtils.convert;

@RestController
public class OrderCheckLogController extends BaseController {

    @Autowired
    private OrderService orderService;
    @Autowired
    private OrderDetlService orderDetlService;
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private DocTypeService docTypeService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private WaitPakinService waitPakinService;
    @Autowired
    private OrderLogService orderLogService;

    @Autowired
    private OrderCheckService orderCheckService;

    @Autowired
    private LocCheckService locCheckService;

    @Autowired
    private ManLocDetlService manLocDetlService;

    @Autowired
    private OrderCheckLogService orderCheckLogService;
    @Autowired
    private LocCheckLogService locCheckLogService;

    //    @RequestMapping(value = "/orderCheckLog/nav/list/auth")
//    @ManagerAuth
//    public R navList(@RequestParam(required = false) String orderNo){
//        EntityWrapper<Order> wrapper = new EntityWrapper<>();
//        if (!Cools.isEmpty(orderNo)) {
//            wrapper.like("order_no", orderNo);
//        }
//        wrapper.le("settle", 2).eq("status", 1);
//        wrapper.orderBy("create_time", false);
//        List<Order> orders = orderService.selectList(wrapper);
//        // 保留出库单
//        if (!Cools.isEmpty(orders)) {
//            Iterator<Order> iterator = orders.iterator();
//            while (iterator.hasNext()) {
//                Order order = iterator.next();
//                if (order.getDocType() != null) {
//                    DocType docType = docTypeService.selectById(order.getDocType());
//                    if (docType != null) {
//                        if (docType.getPakout() == 0) {
//                            iterator.remove();
//                        }
//                    }
//                }
//            }
//        }
//        return R.ok().add(orders);
//    }
//
    @RequestMapping(value = "/orderCheckLog/head/page/auth")
    @ManagerAuth
    public R head(@RequestParam(defaultValue = "1")Integer curr,
                  @RequestParam(defaultValue = "10")Integer limit,
                  @RequestParam(required = false)String orderByField,
                  @RequestParam(required = false)String orderByType,
                  @RequestParam Map<String, Object> param){
        EntityWrapper<OrderCheckLog> wrapper = new EntityWrapper<>();
        excludeTrash(param);
        convert(param, wrapper);
        if (!Cools.isEmpty(orderByField)){wrapper.orderBy(humpToLine(orderByField), "asc".equals(orderByType));} else {
            wrapper.orderBy("settle").orderBy("create_time", false);
        }

        return R.ok(orderCheckLogService.selectPage(new Page<>(curr, limit), wrapper));
    }

    //    @RequestMapping(value = "/orderCheckLog/detl/all/auth")
//    @ManagerAuth
//    public R head(@RequestParam String orderNo){
//        List<LocCheck> orderNo1 = locCheckService.selectList(new EntityWrapper<LocCheck>().eq("order_no", orderNo));
//        return R.ok().add(orderNo1);
//    }
//
//    @RequestMapping(value = "/orderCheckLog/form/add/auth")
//    @ManagerAuth(memo = "手动添加订单")
//    @Transactional
//    public R formAdd(@RequestBody OrderCheckParam param){
//
//        OrderCheck orderCheck1 = orderCheckService.selectByNo(param.getOrderNo());
//        OrderLog orderLog = orderLogService.selectByNo(param.getOrderNo());
//        if (orderCheck1 != null) {
//            return R.error("盘点单单据编号已存在");
//        }
//        if (orderLog != null) {
//            return R.error("盘点单单据编号在历史档中已存在");
//        }
//        Date now = new Date();
//        OrderCheck orderCheck = new OrderCheck();
//        orderCheck.setOrderNo(param.getOrderNo());
//        orderCheck.setUuid(String.valueOf(snowflakeIdWorker.nextId()));
//        orderCheck.setOrderTime(DateUtils.convert(now));
//        orderCheck.setStatus(1);
//        orderCheck.setSettle(1L);
//        orderCheck.setDocType(23L);
//        orderCheck.setCreateTime(now);
//        orderCheck.setUpdateTime(now);
//        if (!orderCheckService.insert(orderCheck)) {
//            throw new CoolException("保存盘点单主档失败");
//        }
//        for (ManLocDetl manLocDetl : param.getOrderDetlList()){
//            LocCheck locCheck = new LocCheck();
//            locCheck.setLocNo(manLocDetl.getLocNo());
//            locCheck.setMaktx(manLocDetl.getMaktx());
//            locCheck.setType(1);
//            locCheck.setExamine(0);
//            locCheck.setMatnr(manLocDetl.getMatnr());
//            locCheck.setAnfme(manLocDetl.getAnfme());
//            locCheck.setRealAnfme(0.0);
//            locCheck.setDiffAnfme(0.0);
//            locCheck.setCreateTime(now);
//            locCheck.setUpdateTime(now);
//            locCheck.setOrderNo(param.getOrderNo());
//            if (!locCheckService.insert(locCheck)){
//                return R.error("插入失败");
//            }
//        }
//        return R.ok("盘点单添加成功");
//    }
//
//    @RequestMapping(value = "/orderCheckLog/form/modify/auth")
//    @ManagerAuth(memo = "手动修改订单")
//    @Transactional
//    public R formModify(@RequestBody OrderCheckParam param){
//        OrderCheck orderCheck = orderCheckService.selectByNo(param.getOrderNo());
//        if (orderCheck == null || orderCheck.getStatus() == 0) {
//            return R.error("盘点单不存在");
//        }
//        Date now = new Date();
//        Long userId = getUserId();
//        // 修改主档
//        orderCheck.setUpdateBy(userId);
//        orderCheck.setUpdateTime(now);
//        if (!orderCheckService.updateById(orderCheck)) {
//            throw new CoolException("修改盘点单类型失败");
//        }
//
//        // 修改明细档
////        List<OrderDetl> orderDetls = orderDetlService.selectByOrderId(order.getId());
//        // 1.清空明细档
//        if (!locCheckService.delete(new EntityWrapper<LocCheck>().eq("order_no",orderCheck.getOrderNo())) ) {
//            throw new CoolException("清空盘点单明细失败");
//        }
//        for (ManLocDetl manLocDetl : param.getOrderDetlList()){
//            LocCheck locCheck = new LocCheck();
//            locCheck.setLocNo(manLocDetl.getLocNo());
//            locCheck.setMaktx(manLocDetl.getMaktx());
//            locCheck.setType(1);
//            locCheck.setMatnr(manLocDetl.getMatnr());
//            locCheck.setAnfme(manLocDetl.getAnfme());
//            locCheck.setRealAnfme(0.0);
//            locCheck.setDiffAnfme(0.0);
//            locCheck.setCreateTime(now);
//            locCheck.setUpdateTime(now);
//            locCheck.setOrderNo(param.getOrderNo());
//            if (!locCheckService.insert(locCheck)){
//                return R.error("插入失败");
//            }
//        }
//        return R.ok("盘点单修改成功");
//    }
//
//
//    // ------------------------------------------------------------------------------------------------
//
//    @RequestMapping(value = "/orderCheckLog/{id}/auth")
//    @ManagerAuth
//    public R get(@PathVariable("id") String id) {
//        return R.ok(orderService.selectById(String.valueOf(id)));
//    }
//
    @RequestMapping(value = "/orderCheckLog/list/auth")
    @ManagerAuth
    public R list(@RequestParam(defaultValue = "1")Integer curr,
                  @RequestParam(defaultValue = "10")Integer limit,
                  @RequestParam(required = false)String orderByField,
                  @RequestParam(required = false)String orderByType,
                  @RequestParam Map<String, Object> param){
        EntityWrapper<LocCheckLog> wrapper = new EntityWrapper<>();
        excludeTrash(param);
        Object orderNo = param.get("order_no");
        wrapper.eq("order_no",orderNo);
        Page<LocCheckLog> manLocDetlPage = locCheckLogService.selectPage(new Page<>(curr, limit), wrapper);

        return R.ok(manLocDetlPage);
    }

    private <T> void convert(Map<String, Object> map, EntityWrapper<T> wrapper){
        for (Map.Entry<String, Object> entry : map.entrySet()){
            String val = String.valueOf(entry.getValue());
            if (val.contains(RANGE_TIME_LINK)){
                String[] dates = val.split(RANGE_TIME_LINK);
                wrapper.ge(entry.getKey(), DateUtils.convert(dates[0]));
                wrapper.le(entry.getKey(), DateUtils.convert(dates[1]));
            } else {
                wrapper.like(entry.getKey(), val);
            }
        }
    }
//
//    @RequestMapping(value = "/orderCheckLog/update/auth")
//    @ManagerAuth
//    public R update(Order order){
//        if (Cools.isEmpty(order) || null == order.getId()){
//            return R.error();
//        }
//
//        //订单完结前，判断是否存在作业中数据，存在则不能完结
//        if(order.getSettle() == 4){
//            int wrkCount = wrkDetlService.selectCount(new EntityWrapper<WrkDetl>().eq("order_no",order.getOrderNo()));
//            int pakinCount = waitPakinService.selectCount(new EntityWrapper<WaitPakin>().eq("order_no",order.getOrderNo()));
//            if (wrkCount > 0 || pakinCount > 0) {
//                throw new CoolException("存在作业中数据，不能完结。请检查入库通知档和工作档");
//            }
//        }
//
//        order.setUpdateBy(getUserId());
//        order.setUpdateTime(new Date());
//        if (!orderService.updateById(order)) {
//            throw new CoolException("修改盘点单失败");
//        }
//        return R.ok();
//    }
//
//    @RequestMapping(value = "/orderCheckLog/delete/auth")
//    @ManagerAuth(memo = "手动删除订单")
//    @Transactional
//    public R delete(@RequestParam String orderNo){
//        orderCheckService.remove(orderNo);
////        Order order = orderService.selectById(orderId);
////        if (order != null) {
////            order.setStatus(0);
////        }
////        if (!orderService.updateById(order)) {
////            throw new CoolException("删除订单失败");
////        }
////        orderDetlService.modifyStatus(orderId, 0);
//        return R.ok();
//    }
//
//    @RequestMapping(value = "/orderCheckLog/export/auth")
//    @ManagerAuth
//    public R export(@RequestBody JSONObject param){
//        EntityWrapper<Order> wrapper = new EntityWrapper<>();
//        List<String> fields = JSONObject.parseArray(param.getJSONArray("fields").toJSONString(), String.class);
//        Map<String, Object> map = excludeTrash(param.getJSONObject("order"));
//        convert(map, wrapper);
//        List<Order> list = orderService.selectList(wrapper);
//        return R.ok(exportSupport(list, fields));
//    }
//
//    @RequestMapping(value = "/orderCheckLogQuery/auth")
//    @ManagerAuth
//    public R query(String condition) {
//        EntityWrapper<Order> wrapper = new EntityWrapper<>();
//        wrapper.like("id", condition);
//        Page<Order> page = orderService.selectPage(new Page<>(0, 10), wrapper);
//        List<Map<String, Object>> result = new ArrayList<>();
//        for (Order order : page.getRecords()){
//            Map<String, Object> map = new HashMap<>();
//            map.put("id", order.getId());
//            map.put("value", order.getOrderNo());
//            result.add(map);
//        }
//        return R.ok(result);
//    }
//
//    @RequestMapping(value = "/orderCheckLog/check/column/auth")
//    @ManagerAuth
//    public R query(@RequestBody JSONObject param) {
//        Wrapper<Order> wrapper = new EntityWrapper<Order>().eq(humpToLine(String.valueOf(param.get("key"))), param.get("val"));
//        if (null != orderService.selectOne(wrapper)){
//            return R.parse(BaseRes.REPEAT).add(getComment(Order.class, String.valueOf(param.get("key"))));
//        }
//        return R.ok();
//    }
//
//    @RequestMapping("/orderCheck/in")
//    public R in(@RequestBody JSONObject param){
//        System.out.println("111 = " + 111);
//        return R.ok();
//    }
//
//    @RequestMapping("/orderCheckLog/create/auth")
//    @ManagerAuth
//    public R autoCreate(@RequestBody CheckDTO checkDTO){
//        Double prec = Double.valueOf(checkDTO.getPrec());
//        List<CheckDTO.data> data = checkDTO.getData();
//        EntityWrapper<ManLocDetl> manLocDetlEntityWrapper = new EntityWrapper<>();
//        int count = manLocDetlService.selectCount(manLocDetlEntityWrapper);
//        List<ManLocDetl> countLocDetl = new ArrayList<>();
//        double precDpuble = prec / 100;
//        count = (int)(count * precDpuble);
//        if (checkDTO.getData() == null){
//            countLocDetl = locCheckService.getCountLocDetl(count);
//        }else {
//            for (CheckDTO.data a :data){
//                String matnr = a.getValue();
//                EntityWrapper<ManLocDetl> manLocDetlEntityWrapper2 = new EntityWrapper<>();
//                manLocDetlEntityWrapper2.eq("matnr",matnr);
//                int countfor = manLocDetlService.selectCount(manLocDetlEntityWrapper2);
//                countfor = (countfor * precDpuble)>1? Math.round((float)(countfor * precDpuble)) : 1 ;
//                for (ManLocDetl manLocDetl: locCheckService.getMatnrCountLocDetl(countfor,a.getValue())){
//                    countLocDetl.add(manLocDetl);
//                }
//            }
//        }
//
//        return R.ok().add(countLocDetl);
//    }
//
//    @RequestMapping("/orderCheckLog/create/loc/auth")
//    @ManagerAuth
//    public R autolocCreate(@RequestBody CheckDTO checkDTO){
//        Double prec = Double.valueOf(checkDTO.getPrec());
//        List<CheckDTO.data> data = checkDTO.getData();
//        EntityWrapper<ManLocDetl> manLocDetlEntityWrapper = new EntityWrapper<>();
//        int count = manLocDetlService.selectCount(manLocDetlEntityWrapper);
//        List<ManLocDetl> countLocDetl = new ArrayList<>();
//        double precDpuble = prec / 100;
//        count = (int)(count * precDpuble);
//        if (checkDTO.getData() == null){
//            countLocDetl = locCheckService.getCountLocDetl(count);
//        }else {
//            for (CheckDTO.data a :data){
//                String locno = a.getValue();
//                EntityWrapper<ManLocDetl> manLocDetlEntityWrapper2 = new EntityWrapper<>();
//                manLocDetlEntityWrapper2.eq("loc_no",locno);
//                int countfor = manLocDetlService.selectCount(manLocDetlEntityWrapper2);
//                countfor = (countfor * precDpuble)>1? Math.round((float)(countfor * precDpuble)) : 1 ;
//                for (ManLocDetl manLocDetl: locCheckService.getLocCountLocDetl(countfor,a.getValue())){
//                    countLocDetl.add(manLocDetl);
//                }
//            }
//        }
//
//        return R.ok().add(countLocDetl);
//    }
//
//
//
//
//    @RequestMapping(value = "/orderCheckLog/print/auth")
//    @ManagerAuth(memo = "订单编码打印")
//    public R manPakOutPrint(@RequestParam(value = "param[]") String[] param) {
//        if(Cools.isEmpty(param)) {
//            return R.parse(CodeRes.EMPTY);
//        }
//        List<LocCheck> res = new ArrayList<>();
//        for (String orderNo : param){
//            res = locCheckService.selectList(new EntityWrapper<LocCheck>().eq("order_no", orderNo));
//        }
//        return R.ok().add(res);
//    }
//    @RequestMapping(value = "/orderCheck/code/auth")
////    @ManagerAuth(memo = "物料编码条形码获取(type:1(条形码);2(二维码)")
//    public R manPakOutCodeBarcode(@RequestParam(defaultValue = "2") Integer type
//            , @RequestParam String param
//            , HttpServletResponse response) throws Exception {
//        AdminInterceptor.cors(response);
//        if (Cools.isEmpty(param)){
//            return R.parse(BaseRes.EMPTY);
//        }
//        BufferedImage img;
//        if (type == 1) {
//            img = BarcodeUtils.encode(param);
//        } else {
//            img = QrCode.createImg(param);
//        }
//        if (!ImageIO.write(img, "jpg", response.getOutputStream())) {
//            throw new IOException("Could not write an image of format jpg");
//        }
//        response.getOutputStream().flush();
//        response.getOutputStream().close();
//        return R.ok();
//    }
//
//    @RequestMapping(value = "/orderCheckLog/mxamine")
//    public R mxamine(@RequestBody LocCheck locCheck){
//       locCheck.setDiffAnfme(locCheck.getAnfme()- locCheck.getRealAnfme());
//       locCheck.setExamine(1);
//       locCheck.setType(2);
//       if (!locCheckService.updateById(locCheck)){
//                return R.error("状态更新失败");
//       }
//
//        return R.ok("审核完成！");
//    }
//    @RequestMapping(value = "/orderCheckLog/all/get/loc")
//    public R mxamine(){
//        List<String> list = locCheckService.getLocCount();
//        List<KeyValueVo> keyValueVoList = new ArrayList<>();
//        for (int i=0;i<list.size();i++){
//            KeyValueVo vo = new KeyValueVo();
//            vo.setName(list.get(i));
//            vo.setValue(list.get(i));
//            keyValueVoList.add(vo);
//        }
//        return R.ok(keyValueVoList);
//
//    }


}