package com.kidgrow.order.controller;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.kidgrow.common.annotation.LoginUser;
import com.kidgrow.common.constant.SecurityConstants;
import com.kidgrow.common.context.DynamicTableContextHolder;
import com.kidgrow.common.model.ResultBody;
import com.kidgrow.common.model.SysUser;
import com.kidgrow.order.entity.OrderInfo;
import com.kidgrow.order.entity.OrderInfoDetail;
import com.kidgrow.order.feign.ProductService;
import com.kidgrow.order.mapper.OrderInfoDetailMapper;
import com.kidgrow.order.mapper.OrderInfoMapper;
import com.kidgrow.redis.template.RedisRepository;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import springfox.documentation.annotations.ApiIgnore;

import javax.servlet.http.HttpServletRequest;
import java.util.List;

/**
 * @author liuke
 * @description
 * @date 2019/11/23
 */

@Api(value="order",tags = "订单信息Controller")
@RestController
@Slf4j
@RequestMapping("order")
public class OrderInfoController {

    @Autowired
    private OrderInfoMapper orderInfoMapper;

    @Autowired
    private OrderInfoDetailMapper orderInfoDetailMapper;

    @Autowired
    private RedisRepository redisRepository;

    @Autowired
    private ProductService productService;

    @Autowired
    private HttpServletRequest request;

    @Value("${server.port}")
    private String serverPort;

    @RequestMapping("/orderinfo/{id}")
    @ApiIgnore
    @ApiOperation(value="根据ID进行订单信息查询", notes="根据ID进行订单OrderInfo")
    @ApiImplicitParam(name = "orderId", value = "OrderInfo对象ID", required = true, dataType = "String")
    public ResultBody<OrderInfo> getOrderInfo(@PathVariable("id") String orderId){

        //代码侵入式分表
        DynamicTableContextHolder.setDynamicTable("order_info_2020");

       OrderInfo orderInfo= orderInfoMapper.selectById(orderId);

        redisRepository.setExpire("111","1234567",180);

        log.info("server.port:"+serverPort);

        log.info("用户ID:"+request.getHeader(SecurityConstants.USER_ID_HEADER));

        log.info("ClientID:"+request.getHeader(SecurityConstants.CLIENT_HEADER));

        log.info("TenantID:"+request.getHeader(SecurityConstants.TENANT_HEADER));

       return ResultBody.ok().data(orderInfo);

    }


    @RequestMapping("/orderdetailinfo/{id}")
    @ApiIgnore
    public ResultBody<OrderInfoDetail> getOrderDetailInfo(@PathVariable("id") String orderId){

        //代码侵入式分表
        DynamicTableContextHolder.setDynamicTable("order_detail_2020");

        OrderInfoDetail orderInfo= orderInfoDetailMapper.selectById(orderId);


        return ResultBody.ok().data(orderInfo);

    }

    @RequestMapping("/hello")
    public ResultBody test(){
        return ResultBody.ok().msg("Hello World");
    }


    @RequestMapping("/orderinfo/add")
    @ApiIgnore
    public ResultBody<OrderInfo> addOrderInfo(@PathVariable("id") String orderId){

        //代码侵入式分表
        DynamicTableContextHolder.setDynamicTable("order_info_2020");

        OrderInfo orderInfo= new OrderInfo();
        orderInfo.setUserId("111");

        orderInfo.setDataFlag(0);

        orderInfoMapper.insert(orderInfo);

        return ResultBody.ok().data(orderInfo);

    }


    @RequestMapping("/initUserRedis")
    public ResultBody initUserRedis(){

        Wrapper<OrderInfo> wrapper = new QueryWrapper<OrderInfo>().eq("hospital_id",1);

        List<OrderInfo> orderInfos = orderInfoMapper.selectList(wrapper);

//        byte[] orderInfoListKey="orderInfo_List".getBytes("UTF-8");

        redisRepository.setExpire("orderInfoListKey", orderInfos,60*60*24);


//        orderInfos.forEach(item->{
//            log.info(item.toString());
//            redisRepository.in("orderinfo",item);
//        });


        List<Object> orderInfosRedis= redisRepository.getList("orderinfo",1,10);

        orderInfosRedis.forEach(item->{
            log.info(item.toString());
        });

        return ResultBody.ok();
    }

    @RequestMapping("/orderinfo/user")
    public ResultBody<SysUser> getSysUser(@LoginUser(isFull = true) SysUser user){
        return ResultBody.ok().data(user);
    }


    /**
     * Feign客户端远程调用传递参数测试
     * @return
     */
    @RequestMapping("/orderinfo/feign")
    public ResultBody getProductInfo(){
        log.info("用户ID"+request.getHeader(SecurityConstants.USER_ID_HEADER));
        return productService.getProductInfo();
    }


    /**
     * Feign客户端远程调用传递参数测试
     * @return
     */
    @RequestMapping("/info")
    public ResultBody getOrderInfo(){
        log.info("用户ID"+request.getHeader(SecurityConstants.USER_ID_HEADER));
        String userID=request.getHeader(SecurityConstants.USER_ID_HEADER);
        return ResultBody.ok().data("P->O调用参数传递测试成功,用户ID为："+userID);
    }


    @RequestMapping("/orderinfolist/{id}")
    public ResultBody<List<OrderInfo>> getOrderInfoList(@PathVariable("id") String orderId){

        List<OrderInfo> orderInfoList= orderInfoMapper.selectList(new QueryWrapper<OrderInfo>().eq("order_id",orderId));

        return ResultBody.ok().data(orderInfoList);

    }


}