package com.ruoyi.webapi.controller;


import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.ruoyi.common.config.RuoYiConfig;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.file.FileUploadUtils;
import com.ruoyi.manager.domain.*;
import com.ruoyi.manager.service.*;
import com.ruoyi.webapi.doman.APKVersion;
import com.ruoyi.webapi.doman.BindingSubmitBeen;
import com.ruoyi.webapi.doman.ReceiptSubmitBeen;
import com.ruoyi.webapi.service.ApiService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * Created by wangh on 2020/7/17-15:18。
 */
@RestController
@RequestMapping("/api")
public class ApiController extends BaseController {
    @Autowired
    ApiService service;
    @Autowired
    private IBaseManufacturerService baseManufacturerService;
    @Autowired
    private IBaseBasketInfoService baseBasketInfoService;
    @Autowired
    private IRecordBasketRepairService recordBasketRepairService;
    @Autowired
    private IRecordtRfidBindingService recordtRfidBindingService;
    @Autowired
    private ILedgerInstantBindingService ledgerInstantBindingService;//货物实时绑定信息
    @Autowired
    private IRecordCargoBindingService recordCargoBindingService;//货物绑定记录
    @Autowired
    private IRecordDeliveryTaskService recordDeliveryTaskService;//交货任务
    @Autowired
    private IRecordDeliveryTaskBaseketService recordDeliveryTaskBaseketService;//交货详情
    @Autowired
    private IRecordDeliveryTaskImgService recordDeliveryTaskImgService;//交货图片
    @Autowired
    private IRecordBasketRepairSparePartsService recordBasketRepairSparePartsService;//维修备件
    @Autowired
    private IRecordBasketCheckTaskService recordBasketCheckTaskService;//盘点任务
    @Autowired
    private IRecordBasketCheckContentService recordBasketCheckContentService;//盘点内容
    @Autowired
    private IBaseAirCodeService baseAirCodeService;
    @Autowired
    private IRecordDeliveryTaskWaybillService recordDeliveryTaskWaybillService;//进港接货

    @PostMapping("/findBindingList")
    public AjaxResult findBindingList(String epc) {
        List<String> codes = service.findBindingList(epc);
        if (codes == null || codes.isEmpty()) return AjaxResult.error("没有运单绑定该资产");

        return AjaxResult.success(codes);
    }

    @PostMapping("/deleteBindingList")
    public AjaxResult deleteBindingList(String objids) {
        int i = ledgerInstantBindingService.deleteLedgerInstantBindingByObjids(objids);
        if (i > 0) return AjaxResult.success("全部解绑成功");

        return AjaxResult.error();
    }

    @PostMapping("/deleteBindingItem")
    public AjaxResult deleteBindingItem(Long ledgerId) {
        // int i = service.deleteBindingItem(epc, code);
        int i = ledgerInstantBindingService.deleteLedgerInstantBindingByObjid(ledgerId);
        if (i == 1) return AjaxResult.success("解绑成功");
        return AjaxResult.error();
    }

    @PostMapping("/deleteLocationCode")
    public AjaxResult deleteLocationCode(String dbCode, String hkCode) {
        int i = service.delectLocationInfoRemarkByDbCode(dbCode, hkCode);
        if (i == 1) return AjaxResult.success();
        return AjaxResult.error();
    }

    @PostMapping("/blueToothSubmit")
    public AjaxResult blueToothSubmit(String locationCode, String hkCode) {
        int i = service.blueToothSubmit(locationCode, hkCode);
        if (i > 0) {
            return AjaxResult.success();
        }
        return AjaxResult.error("库位没有维护");
    }

    // 接货查询
    @PostMapping("/jion/select")
    public AjaxResult jionSelect(String user) {
        // List<LedgerInstantBinding> list = service.jionSelect(user);
        LedgerInstantBinding query = new LedgerInstantBinding();
        query.setCreateBy(user);
        List<LedgerInstantBinding> list = ledgerInstantBindingService.selectList(query);
        if (list == null || list.isEmpty()) return AjaxResult.error("账号无绑定记录");
        return AjaxResult.success(list);
    }

    // 交货任务生成
    @Transactional
    @PostMapping("/delivery/createTask")
    public AjaxResult createDeliveryTask(String json, String airCode, String gps, String user, String type, List<MultipartFile> files) {
        // 生成任务编码
        int taskNumber = recordDeliveryTaskService.countNowDateTaskNumber();
        taskNumber++;
        String taskCode = "Task" + DateUtils.dateTime() + String.format("%03d", taskNumber);
        // 插入任务
        recordDeliveryTaskService.insertRecordDeliveryTask(new RecordDeliveryTask() {{
            setTaskCode(taskCode);
            setCreateBy(user);
            setAirCode(airCode);
            setGpsLocation(gps);
            setTaskType(type);
        }});

        if (files != null && !files.isEmpty()) {
            String filePath = RuoYiConfig.getUploadPath() + "/task";
            for (MultipartFile file : files) {
                try {
                    // 插入图片
                    recordDeliveryTaskImgService.insertRecordDeliveryTaskImg(new RecordDeliveryTaskImg() {{
                        setTaskCode(taskCode);
                        setImgPath(FileUploadUtils.upload(filePath, file));
                    }});
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        if (type.equals("0")) {
            // 出港
            // 插入资产到任务表
            List<LedgerInstantBinding> ledgerInstantBindings = JSONArray.parseArray(json, LedgerInstantBinding.class);
            recordDeliveryTaskBaseketService.insertRecordDeliveryTaskBaseket(taskCode, ledgerInstantBindings);
            // ledgerInstantBindingService.deleteLedgerInstantByBasket(ids);// 删除实时绑定记录
            // 更新状态
            List<Long> ids = ledgerInstantBindings.stream().map(LedgerInstantBinding::getBasketId).collect(Collectors.toList());
            ledgerInstantBindingService.updateTaskStatebyBasketID(ids);
        } else if (type.equals("1")) {
            List<String> stringList = JSONArray.parseArray(json, String.class);
            recordDeliveryTaskBaseketService.insertRecordDeliveryTaskWaybill(taskCode, stringList);
        }
        return AjaxResult.success();
    }

    //交货提交
    @PostMapping("/join/jiaoSubmit")
    public AjaxResult joinJiaoSubmit(@RequestBody ReceiptSubmitBeen been) {
        int i = service.joinSelectByUser(been);
        if (i == 0) {
            return AjaxResult.success();
        }
        return AjaxResult.error();

    }

    //接货提交
    @PostMapping("/join/shouSubmit")
    public AjaxResult joinJieSubmit(@RequestBody ReceiptSubmitBeen been) {
        int i = service.joinShouSubmit(been);
        if (i >= been.getList().size()) {
            return AjaxResult.success();
        }
        return AjaxResult.error();

    }

    // 查询货框下的货物
    @PostMapping("/delivery/sanEpcQueryBasket")
    public AjaxResult deliverySanEpcQueryBasket(String epc) {
        BaseBasketInfo baseBasketInfo = baseBasketInfoService.selectBaseBasketInfoByEpc(epc);
        if (baseBasketInfo == null) return AjaxResult.error("RFID查询失败，没有维护该资产");
        LedgerInstantBinding ledgerInstantBinding = ledgerInstantBindingService.deliverySanEpcQueryBasketbyBasketId(baseBasketInfo.getObjId());
        if (ledgerInstantBinding == null) return AjaxResult.error("查询失败，没有绑定条码");
        return AjaxResult.success(ledgerInstantBinding);
    }

    // 远程接货扫描epc
    @PostMapping("/receipt/scanEpc")
    public AjaxResult ReceiptScanEpc(@RequestParam(name = "epc", required = false, defaultValue = "") String epc, @RequestParam(name = "waybillNumber", required = false, defaultValue = "") String waybillNumber) {
        Long objId = null;

        if (epc != null && !epc.equals("")) {
            BaseBasketInfo baseBasketInfo = baseBasketInfoService.selectBaseBasketInfoByEpc(epc);
            if (baseBasketInfo == null) return AjaxResult.error("RFID查询失败，没有维护该资产");
            objId = baseBasketInfo.getObjId();

        }

        //查询资产是否绑定任务
        RecordDeliveryTaskBaseket recordDeliveryTaskBaseket = new RecordDeliveryTaskBaseket();
        recordDeliveryTaskBaseket.setBasketId(objId);
        recordDeliveryTaskBaseket.setWaybillNumber(waybillNumber);
        RecordDeliveryTaskBaseket select1 = recordDeliveryTaskBaseketService.selectRecordDeliveryTaskBaseketByBasket(recordDeliveryTaskBaseket);
        if (select1 == null) return AjaxResult.error("资产未绑定任务或任务已完成");
        // 查询所有资产
        List<RecordDeliveryTaskBaseket> list = recordDeliveryTaskBaseketService.selectRecordDeliveryTaskBaseketList(select1);
        // 查询所有图片
        RecordDeliveryTaskImg recordDeliveryTaskImg = new RecordDeliveryTaskImg();
        recordDeliveryTaskImg.setTaskCode(select1.getTaskCode());
        List<RecordDeliveryTaskImg> imgList = recordDeliveryTaskImgService.selectRecordDeliveryTaskImgList(recordDeliveryTaskImg);
        // 封装返回数据
        Map<String, Object> map = new HashMap<>();
        map.put("taskCode", select1.getTaskCode());
        map.put("baseketList", list);
        map.put("imgList", imgList);
        return AjaxResult.success(map);
    }

    // 进港接货扫描
    @PostMapping("/receipt/selectTaskByWaybillCode")
    public AjaxResult ReceiptScanEpc(String waybillNumber) {
        List<RecordDeliveryTaskWaybill> list = recordDeliveryTaskWaybillService.selectTaskWaybillList(waybillNumber);
        if (list == null || list.isEmpty()) return AjaxResult.error("集装器/散斗代码查询失败，暂无任务");
        String taskCode = list.get(0).getTaskCode();
        // 查询所有图片
        RecordDeliveryTaskImg recordDeliveryTaskImg = new RecordDeliveryTaskImg();
        recordDeliveryTaskImg.setTaskCode(taskCode);
        List<RecordDeliveryTaskImg> imgList = recordDeliveryTaskImgService.selectRecordDeliveryTaskImgList(recordDeliveryTaskImg);
        // 封装返回数据
        Map<String, Object> map = new HashMap<>();
        map.put("taskCode", taskCode);
        // List<RecordDeliveryTaskBaseket> baseketList=new ArrayList<>(list.size());
        // list.forEach(t->{
        //     baseketList.add(new RecordDeliveryTaskBaseket(){{
        //         setTaskCode(taskCode);
        //         setWaybillNumber(waybillNumber);
        //     }});
        // });
        map.put("baseketList", list);
        map.put("imgList", imgList);
        return AjaxResult.success(map);
    }

    // 进港接货确认
    @Transactional
    @PostMapping("/receiveInTask/submit")
    public AjaxResult receiveInTaskSubmit(String json, String gps, String taskCode, String user) {
        List<LedgerInstantBinding> list = JSONArray.parseArray(json, LedgerInstantBinding.class);
        list.forEach(item -> {

            String cargoFrameEpc = item.getCargoFrameEpc();
            String waybillNumber = item.getWaybillNumber();
            Long basketId = item.getBasketId();
            // 插入资产绑定关系
            int i = service.insertLedgerBinding(cargoFrameEpc, waybillNumber, user, basketId);

            // 插入资产绑定记录
            recordCargoBindingService.insertRecordCargoBinding(new RecordCargoBinding() {{
                setBasketId(basketId);
                setCargoFrameEpc(cargoFrameEpc);
                setWaybillNumber(waybillNumber);
                setCreateBy(user);
                setLocationInfo(gps);
            }});
            // 插入任务子表
            recordDeliveryTaskWaybillService.updateRecord(taskCode,waybillNumber,cargoFrameEpc,basketId);
        });

        recordDeliveryTaskService.closeTaskByReceipt(taskCode, user, gps);//关闭任务
        return AjaxResult.success();
    }

    // 出港接货
    @PostMapping("/receipt/submit")
    public AjaxResult receiptSubmit(@RequestBody ReceiptSubmitBeen been) {
        int i = service.joinShouSubmit(been);
        String taskCode = been.getTaskCode();
        String user = been.getUser();
        recordDeliveryTaskService.closeTaskByReceipt(taskCode, user, been.getReceiveGpsLocation());//关闭任务

        return AjaxResult.success();
    }

    /**
     * 查询所有生产厂家
     */
    @PostMapping("/manufacturerList")
    public AjaxResult manufacturerList() {
        List<BaseManufacturer> list = baseManufacturerService.selectBaseManufacturerList(new BaseManufacturer());
        if (list == null || list.isEmpty()) return AjaxResult.error("没有维护生产厂家");
        return AjaxResult.success(list);
    }

    /**
     * 新增保存资产信息
     */
    @PostMapping("/saveBasketInfo")
    public AjaxResult saveBasketInfo(@RequestBody BaseBasketInfo baseBasketInfo) {
        int tagCount = baseBasketInfoService.selectCountBasketByEpc(baseBasketInfo.getBasketEpc());
        if (tagCount > 0) {
            return AjaxResult.error("RFID标签1已绑定");
        }
        tagCount = baseBasketInfoService.selectCountBasketByEpc(baseBasketInfo.getBasketEpc2());
        if (tagCount > 0) {
            return AjaxResult.error("RFID标签2已绑定");
        }
        List<BaseBasketInfo> list = baseBasketInfoService.checkBasketInfoBySteelGradeAndSelfCode(baseBasketInfo);
        if (list != null && !list.isEmpty()) {
            return AjaxResult.error("钢号或自编号已存在");
        }

        baseBasketInfo.setUpdatedTime(new Date());
        int i = 0;
        if (baseBasketInfo.getObjId() == null) {
            i = baseBasketInfoService.insertBaseBasketInfo(baseBasketInfo);
        } else {
            baseBasketInfo.setUpdatedBy(baseBasketInfo.getCreatedBy());
            baseBasketInfo.setCreatedBy(null);
            i = baseBasketInfoService.updateBaseBasketInfo(baseBasketInfo);
        }
        if (i > 0) return AjaxResult.success();
        return AjaxResult.error();
    }

    /**
     * 新增保存维修记录
     */
    @PostMapping("/saveRepairInfo")
    public AjaxResult saveRepairInfo(@RequestBody RecordBasketRepair recordBasketRepair) {

        int i = recordBasketRepairService.insertRecordBasketRepair(recordBasketRepair);
        if (i > 0) {
            Long objId = recordBasketRepair.getObjId();
            List<RecordBasketRepairSpareParts> list = recordBasketRepair.getList();
            recordBasketRepairSparePartsService.insertRecordBasketRepairSpareParts(list, objId);
        }
        return AjaxResult.error();
    }

    /**
     * 通过RFID查询资产
     */
    @PostMapping("/findBasketInfoByEpc")
    public AjaxResult findBasketInfoByEpc(String epc) {
        BaseBasketInfo baseBasketInfo = baseBasketInfoService.selectBaseBasketInfoByEpc(epc);
        if (baseBasketInfo == null) return AjaxResult.error("没有维护该资产");
        return AjaxResult.success(baseBasketInfo);
    }

    // 维修验收查询资产
    @PostMapping("/repair/checkBasketSelectByEpc")
    public AjaxResult repairCheckBasketSelectByEpc(String epc) {
        BaseBasketInfo baseBasketInfo = baseBasketInfoService.selectBaseBasketInfoByEpc(epc);
        if (baseBasketInfo == null) return AjaxResult.error("没有维护该资产");
        // 查询主表
        RecordBasketRepair recordBasketRepair = recordBasketRepairService.selectRepairByBasketId(baseBasketInfo.getObjId(), 0);
        if (recordBasketRepair == null) {
            return AjaxResult.error("查询失败，暂未找到该资产待验收记录");
        }
        // 查询子表
        List<RecordBasketRepairSpareParts> recordBasketRepairSpareParts = recordBasketRepairSparePartsService.selectRecordBasketRepairSparePartsList(new RecordBasketRepairSpareParts() {{
            setRepairId(recordBasketRepair.getObjId());
        }});
        recordBasketRepair.setList(recordBasketRepairSpareParts);
        return AjaxResult.success(recordBasketRepair);
    }

    @PostMapping("/repair/overRepairSubmit")
    public AjaxResult overRepairSubmit(Long objId, String userName) {
        recordBasketRepairService.updateRecordBasketRepair(new RecordBasketRepair() {{
            setObjId(objId);
            setRepairState(1L);
            setUpdateBy(userName);
            setUpdateTime(new Date());
        }});
        return AjaxResult.success();
    }

    /**
     * 通过资产编号查询资产
     */
    @GetMapping("/getBasketInfoBySearchCode")
    public AjaxResult getBasketInfoBySearchCode(String searchCode) {
        List<BaseBasketInfo> baseBasketInfo = baseBasketInfoService.selectBaseBasketInfoBySearchCode2(searchCode);
        if (baseBasketInfo == null) return AjaxResult.error("没有维护该资产");
        return AjaxResult.success(baseBasketInfo);
    }

    /**
     * 提交绑定记录
     */
    @PostMapping("/submitBindingRecord")
    public AjaxResult submitBindingRecord(Long baseBasketId, String basketEpc, String basketEpc2, String localWeight, String createdBy, List<MultipartFile> files) {
        int tagCount = baseBasketInfoService.selectCountBasketByEpc(basketEpc);
        if (tagCount > 0) {
            return AjaxResult.error("RFID标签1已绑定");
        }
        tagCount = baseBasketInfoService.selectCountBasketByEpc(basketEpc2);
        if (tagCount > 0) {
            return AjaxResult.error("RFID标签2已绑定");
        }
        // 验证钢号与自编号重复
        String filePath = RuoYiConfig.getUploadPath();
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < files.size(); i++) {
            String fileName = null;
            try {
                fileName = FileUploadUtils.upload(filePath, files.get(i));
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
            // System.out.println("上传路径="+fileName);
            stringBuilder.append(fileName);
            if (i != files.size() - 1) {
                stringBuilder.append(",");
            }

        }

        // 新增绑定记录
        RecordtRfidBinding recordtRfidBinding = new RecordtRfidBinding();
        recordtRfidBinding.setBaseBasketId(baseBasketId);
        recordtRfidBinding.setBasketEpc(basketEpc);
        recordtRfidBinding.setBasketEpc2(basketEpc2);
        recordtRfidBinding.setCreatedBy(createdBy);
        recordtRfidBinding.setFilePath(stringBuilder.toString());
        int i = recordtRfidBindingService.insertRecordtRfidBinding(recordtRfidBinding);
        // 更新资产信息
        BaseBasketInfo baseBasketInfo = new BaseBasketInfo();
        baseBasketInfo.setBasketEpc(basketEpc);
        baseBasketInfo.setBasketEpc2(basketEpc2);
        baseBasketInfo.setUpdatedTime(new Date());
        baseBasketInfo.setUpdatedBy(createdBy);
        baseBasketInfo.setObjId(baseBasketId);
        baseBasketInfo.setLocalWeight(Double.parseDouble(localWeight));
        int i1 = baseBasketInfoService.updateBaseBasketInfo(baseBasketInfo);
        if (i > 0) return AjaxResult.success();
        return AjaxResult.error();
    }

    /**
     * 货物入筐-查询资产和资产使用情况
     *
     * @param epc
     * @return
     */
    @PostMapping("/binding/findBasketByEpc")
    public AjaxResult findBasketByEpc(String epc) {
        BaseBasketInfo baseBasketInfo = baseBasketInfoService.selectBaseBasketInfoByEpc(epc);
        if (baseBasketInfo == null) return AjaxResult.error("RFID查询失败，没有维护该资产");
        LedgerInstantBinding ledgerInstantBinding = new LedgerInstantBinding();
        ledgerInstantBinding.setBasketId(baseBasketInfo.getObjId());
        List<LedgerInstantBinding> ledgerInstantBindings = ledgerInstantBindingService.selectLedgerChildTablelist(ledgerInstantBinding);
        baseBasketInfo.setLedgerInstantBindings(ledgerInstantBindings);
        return AjaxResult.success(baseBasketInfo);
    }

    /**
     * 货物入筐-查询资产和资产使用情况
     *
     * @param code
     * @return
     */
    @PostMapping("/binding/findBasketByCode")
    public AjaxResult findBasketByCode(String code) {
        List<LedgerInstantBinding> ledgerInstantBindings = ledgerInstantBindingService.selectLedgerlistByCode(code);
        if (ledgerInstantBindings == null || ledgerInstantBindings.isEmpty())
            return AjaxResult.error("查询失败，条码查询为空");
        return AjaxResult.success(ledgerInstantBindings);
    }

    // 解绑货物和货框
    @PostMapping("/unbindingCargo")
    public AjaxResult unbindingCargo(Long basketId) {
        int i = ledgerInstantBindingService.unbindingCargoDeleteLedger(basketId);
        if (i > 0) return AjaxResult.success();
        return AjaxResult.error();
    }

    // 货物绑定货框
    @PostMapping("/bindingSubmit")
    public AjaxResult bindingSubmit(@RequestBody BindingSubmitBeen submitBeen) {
        List<String> watBills = submitBeen.getWatBills();
        String user = submitBeen.getUser();
        String epc1 = submitBeen.getEpc();
        Long basketId = submitBeen.getBasketId();
        watBills.forEach(code -> {
            String epc = service.selectEpcByWaybill(code, basketId);
            if (epc == null) {
                int i = service.insertLedgerBinding(epc1, code, user, basketId);
                RecordCargoBinding recordCargoBinding = new RecordCargoBinding();
                recordCargoBinding.setBasketId(basketId);
                recordCargoBinding.setCargoFrameEpc(epc1);
                recordCargoBinding.setWaybillNumber(code);
                recordCargoBinding.setCreateBy(user);
                recordCargoBinding.setLocationInfo(submitBeen.getLocationInfo());
                recordCargoBindingService.insertRecordCargoBinding(recordCargoBinding);
            }
        });

        return AjaxResult.success();
    }

    @PostMapping("/basketCheck/select")
    public AjaxResult selectBasketCheck() {
        List<BaseBasketInfo> baseBasketInfos = service.selectBasketCheckList();
        return AjaxResult.success(baseBasketInfos);
    }

    // 盘点任务查询
    @PostMapping("/selectCheckTaskList")
    public TableDataInfo selectCheckTaskList(RecordBasketCheckTask recordBasketCheckTask) {
        startPage();
        List<RecordBasketCheckTask> list = recordBasketCheckTaskService.selectRecordBasketCheckTaskList(recordBasketCheckTask);
        return getDataTable(list);
    }

    /**
     * 新增保存资产盘点任务
     */
    @PostMapping("/createCheckTask")
    @ResponseBody
    public AjaxResult createCheckTask(RecordBasketCheckTask recordBasketCheckTask) {
        return toAjax(recordBasketCheckTaskService.insertRecordBasketCheckTask(recordBasketCheckTask));
    }

    // 查询资产盘点情况
    @PostMapping("/selectCheckContent")
    public TableDataInfo selectCheckContent(RecordBasketCheckContent recordBasketCheckContent) {
        startPage();
        List<RecordBasketCheckContent> list = recordBasketCheckContentService.selectRecordBasketCheckContentList(recordBasketCheckContent);
        return getDataTable(list);
    }

    // 查询航司代码
    @PostMapping("/queryAirCode")
    public AjaxResult queryAirCode() {
        List<String> list = baseAirCodeService.queryAirCode();
        return AjaxResult.success(list);
    }


    @GetMapping("/getVersion")
    public String getVersion() {
        APKVersion apkVersion = service.getVersion();
        apkVersion.setCode(0);
        apkVersion.setMsg("");
        if (apkVersion == null) {
            apkVersion = new APKVersion();
            apkVersion.setUpdateStatus(0);
        } else {
            apkVersion.setUpdateStatus(1);
        }
        String s = JSONObject.toJSONString(apkVersion);
        System.out.println("请求版本信息" + s);
        return s;
    }


}