package com.travel.controller;

import cn.hutool.core.date.DateUtil;
import com.travel.model.*;
import com.travel.service.PrivateOrderService;
import com.travel.util.ParsingToken;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 私人订制
 */
@RestController
@RequestMapping("privateOrder")
public class PrivateOrderController {
    @Autowired
    private PrivateOrderService privateOrderService;

    /**
     * 新增私人订制
     * @param privateOrder 参数
     * @param request 参数
     * @return 返回结果
     */
    @PostMapping("insertPrivate")
    public Map<String, Object> insertPrivate(@RequestBody PrivateOrder privateOrder, HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        //获取token
        Map<String, Object> userMap = ParsingToken.tokenParsing(request);
        privateOrder.setCode((String) userMap.get("code"));
        try{
            if(null == privateOrder.getSupplierCode()){
                privateOrder.setSupplierCode("000");
            }
            //生成uuid
            String id = UUID.randomUUID().toString().replace("-", "");
            privateOrder.setUuid(id);
            int length = privateOrder.getCode().length();//用户编号长度
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyyMMddHHmmssSSS");//时间
            //单号
            privateOrder.setOrderNo("RQ" + privateOrder.getCode().substring(length - 7, length) + simpleDateFormat.format(DateUtil.date()));
            privateOrderService.insertPrivate(privateOrder);//新增定制单
            privateOrderService.addPrivateType(privateOrder);//新增定制单状态
            map.put("msg", "200");
        }catch (Exception e){
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
            e.printStackTrace();
        }
        return map;
    }



    /**
     * 查询私人订制
     * @param privateOrder 参数
     * @param request 参数
     * @return 返回结果
     */
    @GetMapping("getPrivate")
    public Map<String, Object> getPrivate(PrivateOrder privateOrder, HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        try{
            //获取token
            Map<String, Object> userMap = ParsingToken.tokenParsing(request);
            privateOrder.setCode((String) userMap.get("code"));
            List<PrivateOrder> list = new ArrayList<>();
            String[] orderTypeString = privateOrder.getOrderTypeString().split(",");
            for(String orderType : orderTypeString){
                privateOrder.setOrderType(Integer.parseInt(orderType));
                if(orderType.equals("0")){
                    //查询
                    for(PrivateOrder privateOrder2 : privateOrderService.getPrivateZeroCode(privateOrder)){
                        list.add(privateOrder2);
                    }
                } else {
                    //查询
                    for(PrivateOrder privateOrder1 : privateOrderService.getPrivate(privateOrder)){
                        list.add(privateOrder1);
                        //查询每日信息
                        privateOrder1.setReleaseDay(privateOrderService.getSupplierReleaseDay(privateOrder1.getUuidRele()));
                        //查询游玩游戏
                        privateOrder1.setReleasePlay(privateOrderService.getSupplierReleasePlay(privateOrder1.getUuidRele()));
                    }
                }
            }
            map.put("data", list);
            map.put("msg", "200");
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }


    /**
     * 查询私人订制列表
     * @param privateOrder 参数
     * @param request 参数
     * @return 返回结果
     */
    @GetMapping("getPrivateAll")
    public Map<String, Object> getPrivateAll(PrivateOrder privateOrder, HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        try{
            List<PrivateOrder> list = new ArrayList<>();
            String[] orderTypeString = {"0","1","2","3","4","5","6","9"};
            for(String orderType : orderTypeString){
                privateOrder.setOrderType(Integer.parseInt(orderType));
                if(orderType.equals("0")){
                    //查询
                    for(PrivateOrder privateOrder2 : privateOrderService.getPrivateZero(privateOrder)){
                        list.add(privateOrder2);
                    }
                } else {
                    //查询
                    for(PrivateOrder privateOrder1 : privateOrderService.getPrivateAll(privateOrder)){
                        list.add(privateOrder1);
                    }
                }
            }
            map.put("data", list);
            map.put("msg", "200");
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    /**
     * 查询热门报价单
     * @param release 参数
     * @param request 参数
     * @return 返回结果
     */
    @GetMapping("getReleaseHot")
    public Map<String, Object> getReleaseHot(Release release, HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        //获取token
        Map<String, Object> userMap = ParsingToken.tokenParsing(request);
        release.setCode((String) userMap.get("code"));
        try{
            List<Release> list = privateOrderService.getReleaseHot(release);
            for(int i = 0; i < list.size(); i++){
                //查询每日信息
                list.get(i).setReleaseDay(privateOrderService.getSupplierReleaseDay(list.get(i).getUuid()));
                //查询游玩游戏
                list.get(i).setReleasePlay(privateOrderService.getSupplierReleasePlay(list.get(i).getUuid()));
            }
            map.put("data", list);
            map.put("msg", "200");
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    /**
     * 查询指定报价单内容
     * @param release 参数
     * @return 返回结果
     */
    @GetMapping("getPrivateId")
    public Map<String, Object> interestedPrivate(Release release, HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        try{
            //获取token
            Map<String, Object> userMap = ParsingToken.tokenParsing(request);
            release.setCode((String) userMap.get("code"));

            List<Release> list = privateOrderService.getReleaseHot(release);
            for(int i = 0; i < list.size(); i++){
                //查询每日信息
                list.get(i).setReleaseDay(privateOrderService.getSupplierReleaseDay(list.get(i).getUuid()));
                //查询游玩游戏
                list.get(i).setReleasePlay(privateOrderService.getSupplierReleasePlay(list.get(i).getUuid()));
            }
            map.put("data", list);
            map.put("msg", "200");
        } catch (Exception e){
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    /**
     * 删除私人定制
     * @param release 参数
     * @param request 参数
     * @return 返回结果
     */
    @DeleteMapping("delPrivate")
    public Map<String, Object> delPrivate(@RequestBody Release release, HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        try{
            PrivateOrder privateOrder1 = new PrivateOrder().setUuid(release.getDemandUuid()).setOrderType(9);
            //查询该定制单是否报价
            int count = privateOrderService.getPrivateType(privateOrder1);
            if(count == 0){
                privateOrderService.addPrivateType(privateOrder1);
            } else {
                privateOrderService.updatePrivateType(privateOrder1);
            }

            //返还供应商次数
            List<Release> list = privateOrderService.getPrivateTypeVal(privateOrder1);
            for(Release release1 : list){
                privateOrderService.updateSupplierOffer(release1);
            }

//            privateOrderService.notInterested(release);//修改定制单状态
            //获取token
//            Map<String, Object> userMap = ParsingToken.tokenParsing(request);
//            privateOrder.setCode((String) userMap.get("code"));
//            privateOrderService.delPrivate(privateOrder);//删除定制单
//            privateOrderService.delPrivateType(privateOrder);//删除定制单状态
//
//            List<Map<String, Object>> list = privateOrderService.getPrivateRelase(privateOrder);//查询指定定制单的报价单
//            for(Map mapVal : list){
//                privateOrderService.delPrivateRelase(mapVal.get("uuid").toString());//删除报价单
//                privateOrderService.delPrivateReleDay(mapVal.get("uuid").toString());//删除报价单天信息
//                privateOrderService.delPrivateRelePlay(mapVal.get("uuid").toString());//删除报价单游玩信息
//            }

            map.put("msg", "200");
        }catch (Exception e){
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
            e.printStackTrace();
        }
        return map;
    }

    /**
     * 新增收藏
     * @param orderingConllection 参数
     * @return 返回结果
     */
    @PostMapping("addCollection")
    public Map<String, Object> addCollection(@RequestBody OrderingConllection orderingConllection, HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        try {
            //获取token
            Map<String, Object> userMap = ParsingToken.tokenParsing(request);
            orderingConllection.setCode((String) userMap.get("code"));
            //生成uuid
            String id = UUID.randomUUID().toString().replace("-", "");
            orderingConllection.setUuid(id);

            privateOrderService.addCollection(orderingConllection);
            map.put("msg", "200");
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    /**
     * 取消收藏
     * @param orderingConllection 参数
     * @param request 参数
     * @return 返回结果
     */
    @DeleteMapping("delCollection")
    public Map<String, Object> delCollection(@RequestBody OrderingConllection orderingConllection, HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        try {
            //获取token
            Map<String, Object> userMap = ParsingToken.tokenParsing(request);
            orderingConllection.setCode((String) userMap.get("code"));
            //生成uuid
            String id = UUID.randomUUID().toString().replace("-", "");
            orderingConllection.setUuid(id);

            privateOrderService.delCollection(orderingConllection);
            map.put("msg", "200");
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    /**
     * 不感兴趣
     * release 参数
     * @return 返回结果
     */
    @PutMapping ("notInterested")
    public Map<String, Object> notInterested(@RequestBody Release release){
        Map<String, Object> map = new HashMap<>();
        try{
            release.setUuid(release.getDemandUuid());
            Release release1 = privateOrderService.getReleaseOrderType(release);//获取该定制单报价单的状态
            if(release1.getOrderType() != 1){ //如果是已付费的状态 则不能进行不感兴趣的操作
                if(release1.getOrderType() == 6){ //如果是不感兴趣的话  取消不感兴趣回到1
                    privateOrderService.notInterested(release);
                    map.put("msg", "200");
                } else {
                    map.put("msg", "500");
                    map.put("errMsg", "该定制单无法进行该操作");
                }
            } else {
                privateOrderService.notInterested(release);
                map.put("msg", "200");
            }
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    /**
     * 帮我改改
     * supplierReleasePlay 参数
     * @return 返回结果
     */
    @PutMapping("helpChangeRelease")
    public Map<String, Object> helpChangeRelease(@RequestBody SupplierReleasePlay supplierReleasePlay){
        Map<String, Object> map = new HashMap<>();
        try {
            privateOrderService.helpChangeRelease(supplierReleasePlay);
            map.put("msg", "200");
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    /**
     * 满意
     * @param supplierReleasePlay 参数
     * @return 返回结果
     */
    @PutMapping("satisfiedRelease")
    public Map<String, Object> satisfiedRelease(@RequestBody SupplierReleasePlay supplierReleasePlay){
        return privateOrderService.satisfiedRelease(supplierReleasePlay);
    }

    /**
     * 我的收藏
     * @param orderingConllection 参数
     * @return 返回结果
     */
    @GetMapping("userCollection")
    public Map<String, Object> userCollection(OrderingConllection orderingConllection, HttpServletRequest request){
        Map<String, Object> map = new HashMap<>();
        try{
            //获取token
            Map<String, Object> userMap = ParsingToken.tokenParsing(request);
            orderingConllection.setCode((String) userMap.get("code"));
            System.out.println(orderingConllection.getType());
            System.out.println(orderingConllection.getType().equals("0"));
            if(orderingConllection.getType().equals("0")){ //查询定制单
                List<Travel> list = privateOrderService.userCollectionRele(orderingConllection);
                Map<String, Object> mapVal = new HashMap<>();
                mapVal.put("list", list);
                mapVal.put("count", privateOrderService.userCollectionReleCount(orderingConllection));
                mapVal.put("page", orderingConllection.getPage());
                map.put("data", mapVal);
            } else { //查询收藏的个人游记跟供应商路线
                List<Travel> list = privateOrderService.userCollectionTravel(orderingConllection);
                Map<String, Object> mapVal = new HashMap<>();
                mapVal.put("list", list);
                mapVal.put("count", privateOrderService.userCollectionTravelCount(orderingConllection));
                mapVal.put("page", orderingConllection.getPage());
                map.put("data", mapVal);
            }
            map.put("msg", "200");
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }

    /**
     * 点评
     * release 参数
     * @return 返回结果
     */
    @PutMapping("reviewRelese")
    public Map<String, Object> reviewRelese(@RequestBody Release release){
        Map<String, Object> map = new HashMap<>();
        try{
            privateOrderService.reviewRelese(release);
            List<Release> list = privateOrderService.getReleaseHot(release);
            //将所有该定制单的状态改为完成
            Release release2 = new Release().setOrderType(13).setDemandUuid(release.getDemandUuid()).setCode(list.get(0).getCode());
            privateOrderService.notInterested(release2);
            map.put("msg", "200");
        }catch (Exception e){
            e.printStackTrace();
            map.put("msg", "500");
            map.put("errMsg", "服务器请求异常，请稍后再试");
        }
        return map;
    }
}