package com.ruoyi.inspect.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.domain.Result;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.common.utils.JackSonUtil;
import com.ruoyi.inspect.dto.*;
import com.ruoyi.inspect.pojo.InsOrder;
import com.ruoyi.inspect.pojo.InsOrderTemplate;
import com.ruoyi.inspect.pojo.InsProduct;
import com.ruoyi.inspect.service.InsOrderService;
import com.ruoyi.inspect.service.InsOrderTemplateService;
import com.ruoyi.inspect.service.InsProductService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.AllArgsConstructor;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletResponse;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.Map;

@RestController
@AllArgsConstructor
@RequestMapping("/insOrder")
@Api(tags="检验单模块")
public class InsOrderController {

    private InsOrderService insOrderService;

    private InsProductService insProductService;

    private InsOrderTemplateService insOrderTemplateService;

    //获取检验下单数据
    @ApiOperation(value = "查看所属单位检验单")
    @GetMapping("/selectInsOrderParameter")
    @PreAuthorize("@ss.hasPermi('business:order:queryAll')")
    public Result selectInsOrderParameter(Page page, SampleOrderDto sampleOrderDto) {
        return Result.success(insOrderService.selectInsOrderParameter(page, sampleOrderDto));
    }

    //用于检验下单区别查看所有订单和只查看同一个委托单位的订单
    @ApiOperation(value = "判断当前客户紧急额度是否用完")
    @GetMapping("/hasSendUrgentOrder")
    public Result hasSendUrgentOrder() {
        return Result.success(insOrderService.hasSendUrgentOrder());
    }

    //用于检验下单区别查看所有订单和只查看同一个委托单位的订单
//    @ApiOperation(value = "查看所有检验单")
//    @PostMapping("/selectAllInsOrderParameter")
//    public Result selectAllInsOrderParameter() {
//        return Result.success();
//    }


    @ApiOperation(value = "分配按钮")
    @PostMapping("/upInsOrder")
    @Log(title = "检验下单", businessType = BusinessType.UPDATE)
    public Result<?> upInsOrder(@RequestBody UpInsOrderDTO upInsOrderDTO) {
        return Result.success(insOrderService.upInsOrder(upInsOrderDTO));
    }

    @ApiOperation(value = "下单按钮")
    @PostMapping("/addInsOrder")
    @Log(title = "检验下单", businessType = BusinessType.INSERT)
    public Result<?> addInsOrder(String str) {
        Map<String, Object> map = JSON.parseObject(str, Map.class);
        JSONArray jsonArray = JSON.parseArray(map.get("list")+"");
        List<SampleProductDto> list = jsonArray.toJavaList(SampleProductDto.class);
        InsOrder insOrder = JSON.parseObject(JSON.toJSONString(map.get("insOrder")), InsOrder.class);
        List<List<Integer>> pairing = JSON.parseArray(map.get("pairing")+"");
        List<List<Integer>> fiberPairing = JSON.parseArray(map.get("fiberPairing")+"");//光纤配置里的熔接配对
        return Result.success(insOrderService.addInsOrder(list, insOrder, pairing,fiberPairing));
    }

    @ApiOperation(value = "查询订单最长预计时间")
    @GetMapping("/selectOrderManDay")
    public Result<?> selectOrderManDay(Integer id) {
        int day = insProductService.selectOrderManDay(id);
        return Result.success("成功", LocalDateTime.now().plusHours(day).format(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
    }

    @ApiOperation(value = "查询检验下单内容详情")
    @GetMapping("/getInsOrder")
    @Log(title = "检验下单", businessType = BusinessType.OTHER)
    public Result<?> getInsOrder(Integer orderId) {
        return Result.success(insOrderService.getInsOrder(orderId));
    }

    @ApiOperation(value = "审核按钮")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "检验单id", dataTypeClass = Integer.class),
            @ApiImplicitParam(name = "state", value = "审核结果 1:通过 2：不通过", dataTypeClass = Integer.class)
    })
    @PostMapping("/upInsOrderOfState")
    @Log(title = "检验下单", businessType = BusinessType.UPDATE)
    public Result<?> upInsOrderOfState(@RequestBody InsOrder insOrder) {
        return Result.success(insOrderService.upInsOrderOfState(insOrder));
    }

    @ApiOperation(value = "保存检验模板按钮")
    @PostMapping("/addInsOrderTemplate")
    @Log(title = "检验下单", businessType = BusinessType.INSERT)
    public Result<?> addInsOrderTemplate(@RequestBody InsOrderTemplate insOrderTemplate) {
        return Result.success(insOrderTemplateService.addInsOrderTemplate(insOrderTemplate));
    }

    @ApiOperation(value = "删除检验模板按钮")
    @PostMapping("/delInsOrderTemplate")
    @Log(title = "检验下单", businessType = BusinessType.DELETE)
    public Result<?> delInsOrderTemplate(Integer id) {
        return Result.success(insOrderTemplateService.delInsOrderTemplate(id));
    }

    @ApiOperation(value = "查询检验单模板")
    @GetMapping("/selectInsOrderTemplate")
    public Result<?> selectInsOrderTemplate(String company) {
        return Result.success(insOrderTemplateService.selectInsOrderTemplate(company));
    }

    @ApiOperation(value = "通过检验单模板id获取检验单模板内容")
    @GetMapping("/selectInsOrderTemplateById")
    public Result<?> selectInsOrderTemplateById(Integer id) {
        return Result.success( insOrderTemplateService.selectInsOrderTemplateById(id),"成功");
    }

    @ApiOperation(value = "通过检验单查询检验数据（数据查看）")
    @GetMapping("/selectSampleAndProductByOrderId")
    public Result<?> selectSampleAndProductByOrderId(SampleProductDto2 sampleProductDto) {
        return Result.success(insOrderService.selectSampleAndProductByOrderId(sampleProductDto));
    }
    //数据查看下的查看详情（单根垂直燃烧和松套管
    @PostMapping("/viewDetails")
    public Result<?> viewDetails(@RequestBody Map<String, Object> data)   {
        return Result.success(insOrderService.viewDetails(data));
    }

    @ApiOperation(value = "导出已检委托单")
    @PostMapping("/exportChecked")
    @Log(title = "检验下单", businessType = BusinessType.EXPORT)
    public void exportChecked(@RequestBody Map<String, Object> data, HttpServletResponse response) {
        insOrderService.exportChecked(data,response);
    }

    @ApiOperation(value = "费用统计获取总价")
    @GetMapping("/costStatistics2")
    public Result<?> costStatistics2(@RequestBody Map<String, Object> data) throws Exception {
        CostStatisticsDto costStatisticsDto = JackSonUtil.unmarshal(JackSonUtil.marshal(data.get("entity")), CostStatisticsDto.class);
        return Result.success(insOrderService.costStatistics2(costStatisticsDto));
    }

    @ApiOperation(value = "撤销按钮")
    @PutMapping("/updateStatus")
    @Log(title = "检验下单", businessType = BusinessType.UPDATE)
    public Result<?> updateStatus(Integer id) {
        insOrderService.updateStatus(id);
        return Result.success();
    }

    //待检的撤销的查询待检项目
    @GetMapping("/selectNoProducts")
    public Result<?> selectNoProducts(@RequestBody Map<String, Object> data,Integer orderId ,String ids) throws Exception {
        Page page = JackSonUtil.unmarshal(JackSonUtil.marshal(data.get("page")), Page.class);
        InsProduct insProduct = JackSonUtil.unmarshal(JackSonUtil.marshal(data.get("entity")), InsProduct.class);
        return Result.success(insProductService.selectNoProducts(page, insProduct,orderId,ids));
    }

    /**
     * 查询需要撤销的检验项目样品
     * @param orderId
     * @return Map<String, Object>
     */
    @GetMapping("/selectSampleByOrderId")
    public Result<?> selectSampleByOrderId(Integer orderId)   {
        return Result.success(insProductService.selectSampleByOrderId(orderId));
    }

    /**
     * 查询检验项目
     * @param sampleId
     * @return Map<String, Object>
     */
    @GetMapping("/selectProductsBySampleId")
    public Result<?> selectProductsBySampleId(Integer sampleId,Integer orderId)   {
        return Result.success(insProductService.selectProductsBySampleId(sampleId,orderId));
    }

    /**
     * 查询检验项目为温度循环的检验次数
     */
    @GetMapping("/selectTemperatureByProductId")
    public Result selectTemperatureByproductId(Integer productId) {
        return Result.success(insProductService.selectTemperatureByProductId(productId));
    }

    /**
     * 查询温度循环的次数一致的温度点
     */
    @GetMapping("/selectTemperatureNumberByProductId")
    public Result selectTemperatureNumberByproductId(Integer parentId,String inspectionItem) {
        return Result.success(insProductService.selectTemperatureNumberByProductId(parentId,inspectionItem));
    }

    /**
     * 撤销
     * @param data
     * @return
     */
    @Log(title = "检验下单", businessType = BusinessType.UPDATE)
    @PostMapping("/revoke")
    public Result<?> revoke(@RequestBody Map<String, Object> data)   {
        insProductService.revoke(data);
        return Result.success();
    }

    /**
     * 查询撤销审核的样品
     * @param orderId
     * @param
     * @return
     */
    @GetMapping("/revokeReviewSample")
    public Result<?> revokeReviewSample(Integer orderId)   {
        return Result.success(insProductService.revokeReviewSample(orderId));
    }


    /**
     * 撤销的循环次数一致的温度点
     * @return
     */
    @GetMapping("/revokeReviewConsistentByProductId")
    public Result<?> revokeReviewConsistentByProductId(Integer parentId,String inspectionItem){
        return Result.success(insProductService.revokeReviewConsistentByProductId(parentId,inspectionItem));
    }

    /**
     * 撤销的温度循环的循环次数
     * @return
     */
    @GetMapping("/revokeReviewTemperatureByProductId")
    public Result<?> revokeReviewTemperatureByProductId(Integer productId){
        return Result.success(insProductService.revokeReviewTemperatureByProductId(productId));
    }

    /**
     * 查询撤销审核  温度循环
     */
    @GetMapping("/revokeReviewProduct")
    public Result<?> revokeReviewProduct(Integer orderId,Integer sampleId){
        return Result.success(insProductService.revokeReviewProduct(orderId,sampleId));
    }

    /**
     * 撤销审核通过
     * @param orderId
     * @return
     */
    @Log(title = "检验下单", businessType = BusinessType.UPDATE)
    @GetMapping("/revocationPassed")
    public Result<?> revocationPassed(Integer orderId){
        insProductService.revocationPassed(orderId);
        return Result.success();
    }

    /**
     * 撤销审核取消
     * @param orderId
     * @return
     */
    @Log(title = "检验下单", businessType = BusinessType.UPDATE)
    @GetMapping("/revocationCancel")
    public Result<?> revocationCancel(Integer orderId){
        insProductService.revocationCancel(orderId);
        return Result.success();
    }


    @ApiOperation(value = "待检的撤销")
    @PutMapping("/updateInspected")
    @Log(title = "检验下单", businessType = BusinessType.UPDATE)
    public Result<?> updateInspected(Integer orderId,String ids){
        insProductService.updateInspected(orderId,ids);
        return Result.success();
    }

    @ApiOperation(value = "撤销审核按钮")
    @PostMapping("/checkUpdate")
    @Log(title = "检验下单", businessType = BusinessType.UPDATE)
    public Result<?> checkUpdate(Integer orderId,Integer state){
        insProductService.checkUpdate(orderId,state);
        return Result.success();
    }

    @ApiOperation(value = "标签打印按钮")
    @GetMapping("/labelPrinting")
    public Result<?> labelPrinting(String ids) {
        return Result.success(insOrderService.labelPrinting(ids));
    }

    @ApiOperation(value = "查看费用统计列表")
    @GetMapping("/costStatistics")
    public Result<?> costStatistics(@RequestBody Map<String, Object> data) throws Exception {
        Page page = JackSonUtil.unmarshal(JackSonUtil.marshal(data.get("page")), Page.class);
        CostStatisticsDto costStatisticsDto = JackSonUtil.unmarshal(JackSonUtil.marshal(data.get("entity")), CostStatisticsDto.class);
        return Result.success(insOrderService.costStatistics(page, costStatisticsDto));
    }

    @ApiOperation(value = "查看结果按钮(温度循环)")
    @GetMapping("/getInsOrderTemList")
    public Result getInsOrderTemList(@RequestBody Map<String, Object> data) {
        return Result.success(insOrderService.getInsOrderTemList(data));
    }

    /**
     * 获取熔接数量
     */
    @GetMapping("/permute")
    public Result permute(Integer num, Boolean isValue) {
        return Result.success(insOrderService.permute(num,isValue));
    }
}