package com.jiayue.passback.controller;

import cn.hutool.json.JSONObject;
import com.jiayue.passback.constants.CommonStant;
import com.jiayue.passback.mapper.ElectricFieldMapper;
import com.jiayue.passback.service.InApiService;
import com.jiayue.passback.util.CacheUtil;
import com.jiayue.passback.util.JsonResultUtil;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

/**
 * 对外接口
 * ApiController
 *
 * @author zcl
 * @date 2023-03-24 15:48:48
 */
@RestController
@RequiredArgsConstructor
@Slf4j
@RequestMapping("/pfserver")
public class InApiController {
    @Autowired
    InApiService apiService;
    @Resource
    public ElectricFieldMapper electricFieldMapper;

    /**
     * 获取token
     *
     * @param request
     * @return
     */
    @PostMapping("/token")
    public JSONObject getToken(HttpServletRequest request) {
        //校验授权信息并返回用户名及密码
        JSONObject checkResult = checkAuthorization(request);
        // 如果校验结果为失败
        if (JsonResultUtil.Type.failure.value().equals(checkResult.get(JsonResultUtil.CODE_TAG))) {
            log.info("获取用户信息失败");
            return checkResult;
        }
        // 根据用户名密码获取token
        JSONObject result = apiService.getToken(checkResult.getJSONObject(JsonResultUtil.DATA_TAG));
        return result;
    }

    /**
     * 获取短期原始数据
     *
     * @param request
     * @return
     */
    @PostMapping("/getShortWpfData")
    public JSONObject getShortWpfData(HttpServletRequest request, @RequestBody JSONObject data) {
        // 入参验证
        JSONObject checkResult = checkRequest(request,data);
        // 如果校验结果为失败
        if (JsonResultUtil.Type.failure.value().equals(checkResult.get(JsonResultUtil.CODE_TAG))) {
            return checkResult;
        }
        // 返回短期数据json格式
        JSONObject result = apiService.getShortWpfData(data);
        return result;
    }

    /**
     * 接收短期预测修正数据
     *
     * @param request
     * @return
     */
    @PostMapping("/putShortWpfData")
    public JSONObject putShortWpfData(HttpServletRequest request, @RequestBody JSONObject data) {
        // 入参验证
        JSONObject checkResult = checkRequest(request,data);
        // 如果校验结果为失败
        if (JsonResultUtil.Type.failure.value().equals(checkResult.get(JsonResultUtil.CODE_TAG))) {
            return checkResult;
        }
        JSONObject result = apiService.putShortWpfData(data);
        // 返回短期数据json格式
        return result;
    }

    /**
     * 获取超短期原始数据
     *
     * @param request
     * @return
     */
    @PostMapping("/getSShortWpfData")
    public JSONObject getSShortWpfData(HttpServletRequest request, @RequestBody JSONObject data) {
        //校验token
        JSONObject checkResult = checkRequest(request,data);
        // 如果校验结果为失败
        if (JsonResultUtil.Type.failure.value().equals(checkResult.get(JsonResultUtil.CODE_TAG))) {
            return checkResult;
        }
        // 返回超短期数据json格式
        return apiService.getSShortWpfData(data);
    }

    /**
     * 接收超短期预测修正数据
     *
     * @param request
     * @return
     */
    @PostMapping("/putSShortWpfData")
    public JSONObject putSShortWpfData(HttpServletRequest request, @RequestBody JSONObject data) {
        //校验token
        JSONObject checkResult = checkRequest(request,data);
        // 如果校验结果为失败
        if (JsonResultUtil.Type.failure.value().equals(checkResult.get(JsonResultUtil.CODE_TAG))) {
            return checkResult;
        }
        // 返回短期数据json格式
        return apiService.putSShortWpfData(data);
    }

    /**
     * 获取预测文件上次上报调度的状态
     *
     * @param request
     * @return
     */
    @PostMapping("/getUploadState")
    public JSONObject getUploadState(HttpServletRequest request, @RequestBody JSONObject data) {
        // 入参验证
        JSONObject checkResult = checkRequest(request,data);
        // 如果校验结果为失败
        if (JsonResultUtil.Type.failure.value().equals(checkResult.get(JsonResultUtil.CODE_TAG))) {
            return checkResult;
        }
        // 返回短期数据json格式
        JSONObject result = apiService.getUploadState(data);
        return result;
    }

    /**
     * 校验授权信息并返回用户名密码
     *
     * @return
     */
    public JSONObject checkAuthorization(HttpServletRequest request) {
        // 获取授权信息
        String authorization = request.getHeader(CommonStant.AUTHORIZATION);
        // 如果授权信息不存在，返回失败
        if (authorization == null) {
            return JsonResultUtil.failureDesc("授权信息不存在");
        }
        // 将"用户名:密码"格式的数据拆分
        String[] authorizationArr = authorization.split(CommonStant.CHARACTER_COLON);
        // 如果根据冒号拆分后的数据长度小于2，则返回失败
        if (authorizationArr.length < 2) {
            return JsonResultUtil.failureDesc("用户密码格式不正确");
        }
        // 放入用户信息
        JSONObject userInfo = new JSONObject();
        // 请求的用户名
        userInfo.set(CommonStant.REQUEST_USER_NAME, authorizationArr[0]);
        // 请求的密码
        userInfo.set(CommonStant.REQUEST_USER_PASS, authorizationArr[1]);
        return JsonResultUtil.success(userInfo);
    }

    /**
     * 校验授权信息并返回用户名密码
     *
     * @return
     */
    public JSONObject checkToken(HttpServletRequest request) {
        // 授权校验结果
        JSONObject checkResult = checkAuthorization(request);
        // 如果校验结果为失败
        if (JsonResultUtil.Type.failure.value().equals(checkResult.get(JsonResultUtil.CODE_TAG))) {
            return checkResult;
        }
        // 如果授权格式校验成功，获取用户名和token
        JSONObject userInfo = checkResult.getJSONObject(JsonResultUtil.DATA_TAG);
        // 用户传入的token
        String requestToken = userInfo.getStr(CommonStant.REQUEST_USER_PASS);
        // 校验token
        String requestUserName = userInfo.getStr(CommonStant.REQUEST_USER_NAME);
        // redis中存的token
        String token = CacheUtil.cacheMap.get(requestUserName);
        // 如果token不同，校验失败
        if (!requestToken.equals(token)) {
            log.error("====================token验证失败====================");
            return JsonResultUtil.failureDesc("token验证失败");
        }
        return JsonResultUtil.success();
    }

    /**
     * 入参校验
     *
     * @return
     */
    public JSONObject checkRequest(HttpServletRequest httpRequest,JSONObject requestJson) {
        // 验证token
//        JSONObject tokenResult = checkToken(httpRequest);
//        if (JsonResultUtil.Type.failure.value().equals(tokenResult.get(JsonResultUtil.CODE_TAG))) {
//            return tokenResult;
//        }
        // 如果入参为空
        if (requestJson == null) {
            log.info("接收到的数据为空");
            return JsonResultUtil.failureDesc("接收到的数据为空");
        }
        // 获取场站id
        String stationCode = requestJson.getStr("wfId");
        // 如果场站id为空
        if (stationCode == null || "".equals(stationCode)) {
            log.info("场站id为空");
            return JsonResultUtil.failureDesc("场站id为空");
        }
//        // 根据场站编号查询场站信息
////        QueryWrapper<ElectricField> wrapper = new QueryWrapper();
////        wrapper.eq("C_STATION_CODE",stationCode);
////        ElectricField electricField = electricFieldMapper.selectOne(wrapper);
////        // 如果场站信息为空
////        if (electricField == null) {
////            log.info("场站信息为空");
////            return JsonResultUtil.failureDesc("场站信息为空");
////        }
        return JsonResultUtil.success();
    }
}
