package com.platform.yijia.controller;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.platform.yijia.config.YiJiaRequest;
import com.platform.yijia.param.request.AppUserInfoRequest;
import com.platform.yijia.pojo.*;
import com.platform.yijia.service.AppUserInfoService;
import com.platform.yijia.service.CouponService;
import com.platform.yijia.service.StationService;
import com.platform.yijia.service.SysUserService;
import com.platform.yijia.utils.CodeMsg;
import com.platform.yijia.utils.CryptUtil;
import com.platform.yijia.utils.ResultData;
import com.sun.corba.se.spi.ior.ObjectKey;
import com.sun.org.apache.bcel.internal.classfile.Code;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import io.swagger.models.auth.In;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;

/*
 * <Title> CouponController </Title>
 * <Description> 优惠券 </Description>
 */
@Controller
@YiJiaRequest()
@CrossOrigin
@Api(tags = "优惠券")
public class CouponController {
    private static Logger logger =(Logger) LoggerFactory.getLogger(CouponController.class);

    @Resource
    private CouponService couponService;
    @Resource
    private StationService stationService;
    @Autowired
    private AppUserInfoService appUserInfoService;
    @Autowired
    private SysUserService sysUserService;

    /**
     * 获取油站分发优惠券
     * @param stationId  油站ID
     * @param couponIssueId    发放方式ID
     * @return
     */
    @RequestMapping(value = "/selectStaGrantCouponList", method = RequestMethod.GET)
    @Transactional
    @ResponseBody
    @ApiOperation(value = "获取油站已发放的优惠券信息", httpMethod = "GET", notes = "获取油站已发放的优惠券信息")
    public String selectStaGrantCouponList(@ApiParam(value = "油站ID", required = true) @RequestParam Integer stationId,
                                           @ApiParam(value = "用户unionId", required = true) @RequestParam String unionId,
                                           @ApiParam(value = "发放方式ID", required = true) @RequestParam String couponIssueId){
        Gson gson =new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
        ResultData resultData = null;
        try {
            if(unionId !=null && stationId !=null && couponIssueId !=null){
                //返回前端结果
                Map<String, Object> resultMap = new HashMap<>();
                StationInfo stationInfo = new StationInfo();
                stationInfo.setStationId(stationId);
                StationInfo stationInfos = stationService.selectStationInfo(stationInfo);
                if(stationInfos !=null && stationInfos.getCouponEnabledFlag().equals("1")){
                    CouponIssue couponIssue = new CouponIssue();
                    couponIssue.setStationId(stationId);
                    couponIssue.setCouponIssueId(couponIssueId);
                    //获取该领取方式的状态是否启用 1启用 0未启用
                    List<CouponIssue> couponIssuesList = couponService.selectCouponIssueList(couponIssue);
                    if(couponIssuesList !=null && couponIssuesList.size() >0 && couponIssuesList.get(0).getStatus().equals("1")){
                        resultMap.put("giveLimit", couponIssuesList.get(0).getGiveLimit());
                        CouponUserGiveCount couponUserGiveCount = new CouponUserGiveCount();
                        couponUserGiveCount.setStationId(stationId);
                        couponUserGiveCount.setUnionId(unionId);
                        couponUserGiveCount.setCouponIssueId(couponIssueId);
                        //用户能进入领取界面的次数
                        CouponUserGiveCount cgcInfo = couponService.selectCouponUserGiveCount(couponUserGiveCount);
                        if(cgcInfo !=null && cgcInfo.getIssueGiveCount() >=  cgcInfo.getGiveCount()){
                            resultData = ResultData.error(CodeMsg.COUPON_GIVE_COUNT_MAX);
                        }else {
                            if(cgcInfo !=null){
                                //更新次数
                                Integer issueGiveCount = cgcInfo.getIssueGiveCount();
                                int i = issueGiveCount + 1;
                                couponUserGiveCount.setIssueGiveCount(i);
                                couponUserGiveCount.setUpdateTime(new Date());
                                couponService.updateCouponUserGiveCount(couponUserGiveCount);
                            }else {
                                //新增次数
                                couponUserGiveCount.setIssueGiveCount(1);
                                couponUserGiveCount.setCreteTime(new Date());
                                couponService.addCouponUserGiveCount(couponUserGiveCount);
                            }
                            //该领取方式能领取优惠券的时间类型
                            String availableControl = couponIssuesList.get(0).getAvailableControl();
                            switch (availableControl){
                                case "0":
                                    List<Coupon> couponsList = this.selectCouponIssue(stationId, couponIssueId);
                                    resultMap.put("couponsList", couponsList);
                                    resultData = ResultData.success(resultMap);
                                    break;
                                case "1":
                                    String cycleDays_1 = couponIssuesList.get(0).getCycleDays();
                                    if(!this.isActivityDay(availableControl, cycleDays_1)){
                                        resultData = ResultData.error(CodeMsg.NOT_GIVE_COUPON_TIME);
                                    }else {
                                        List<Coupon> couponsList_1 = this.selectCouponIssue(stationId, couponIssueId);
                                        resultMap.put("couponsList", couponsList_1);
                                        resultData = ResultData.success(resultMap);
                                    }
                                    break;
                                case "2":
                                    //String cycleDays_2 = couponIssuesList.get(0).getCycleDays();
                                    if(!this.isActivityDay(availableControl, couponIssuesList.get(0).getCycleDays())){
                                        resultData = ResultData.error(CodeMsg.NOT_GIVE_COUPON_TIME);
                                    }else {
                                        List<Coupon> couponsList_2 = this.selectCouponIssue(stationId, couponIssueId);
                                        resultMap.put("couponsList", couponsList_2);
                                        resultData = ResultData.success(resultMap);
                                    }
                                    break;
                                case "3":
                                    String appointedDays_3 = couponIssuesList.get(0).getAppointedDays();
                                    if(!this.isActivityDay(availableControl, appointedDays_3)){
                                        resultData = ResultData.error(CodeMsg.NOT_GIVE_COUPON_TIME);
                                    }else {
                                        List<Coupon> couponsList_3 = this.selectCouponIssue(stationId, couponIssueId);
                                        resultMap.put("couponsList", couponsList_3);
                                        resultData = ResultData.success(resultMap);
                                    }
                                    break;
                            }
                        }
                    }else {
                        // -7
                        resultData = ResultData.error(CodeMsg.ISSUE_CLOSE);
                    }
                }else {
                    resultData = ResultData.error(CodeMsg.NO_ENABLE_COUPON);
                }
            }else {
                resultData = ResultData.error(CodeMsg.PARAMS_NUll);
            }
        }catch (Exception e){
            e.printStackTrace();
            logger.error("获取油站已发放的优惠券错误信息：" + e.getMessage());
            resultData = ResultData.error(CodeMsg.SEARCH_FAIL);
        }
        return  gson.toJson(resultData);
    }

    //油站所分发的优惠券
    public List<Coupon> selectCouponIssue(Integer stationId, String couponIssueId){
        //用户能进入领取界面的次数
        Coupon coupon = new Coupon();
        coupon.setStationId(stationId);
        coupon.setCouponIssueId(couponIssueId);
        //领取油站所分发的优惠券
        List<Coupon> couponsList = couponService.selectStaGrantCouponList(coupon);
        return couponsList;
    }


    //获取优惠券信息
    @RequestMapping(value = "/selectCouponInfo", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation(value = "获取优惠券信息", httpMethod = "GET", notes = "获取优惠券信息")
    public String selectCouponInfo(@ApiParam(value = "优惠券ID", required = true) @RequestParam Integer id){
        Gson gson =new Gson();
        ResultData resultData = null;
        try {
            UserCoupon coupon = new UserCoupon();
            coupon.setId(id);
            UserCoupon couponInfo = couponService.selectUserCouponInfo(coupon);
            resultData = ResultData.success(couponInfo);
        }catch (Exception e){
            e.printStackTrace();
        }
        return  gson.toJson(resultData);
    }

    /***
     * 获取核销优惠券信息
     * @param couponNo
     * @return
     */
    @RequestMapping(value = "/selectCouponVerificationInfo", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation(value = "获取核销优惠券信息", httpMethod = "GET", notes = "获取核销优惠券信息")
    public String selectCouponVerificationInfo(@ApiParam(value = "核销优惠券码", required = true) @RequestParam String couponNo,
                                               @ApiParam(value = "用户unionId", required = true) @RequestParam String unionId){
        Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
        ResultData resultData = null;
        try {
            if(StringUtils.isNotBlank(couponNo) && StringUtils.isNotBlank(unionId)){
                CouponVerificationUser couponVerificationUser = new CouponVerificationUser();
                couponVerificationUser.setUnionId(unionId);
                CouponVerificationUser cu = couponService.selectCouponVerificationUserInfo(couponVerificationUser);
                if(cu !=null && cu.getStationId() !=null){
                    Integer stationId = cu.getStationId();
                    UserCoupon coupon = new UserCoupon();
                    coupon.setCouponNo(couponNo);
                    coupon.setUnionId(unionId);
                    UserCoupon couponInfo = couponService.selectUserCouponInfo(coupon);
                    if(couponInfo !=null){
                        String verification = couponInfo.getVerification();
                        StationInfo stationInfo = new StationInfo();
                        stationInfo.setStationId(cu.getStationId());
                        StationInfo stationInfos = stationService.selectStationInfo(stationInfo);
                        if(StringUtils.isNotBlank(stationInfos.getCouponFlag()) && stationInfos.getCouponFlag().equals("1")){
                            stationId = stationInfos.getGroupId();
                        }
                        boolean contains = verification.contains(stationId.toString());
                        if(contains){
                            //如果当前登录用户是异业端核销人员非加油站异业券核销
                            resultData = ResultData.success(couponInfo);
                        }else {
                            Integer stationIdCoupon = couponInfo.getStationId();
                            Integer stationIdVer = cu.getStationId();
                            if(stationIdVer.toString().equals(stationIdCoupon.toString())){
                                resultData = ResultData.success(couponInfo);
                            }else {
                                resultData = ResultData.error(CodeMsg.ERROR_VERIFICATION);
                            }
                        }
                    }else {
                        resultData = ResultData.error(CodeMsg.NO_COUPON);
                    }
                }else {
                    resultData = ResultData.error(CodeMsg.NOT_COUPON_VERIFICATION_USER);
                }
            }else {
                resultData = ResultData.error(CodeMsg.PARAMS_NUll);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return  gson.toJson(resultData);
    }

    //获取客户所拥有的优惠券
    @RequestMapping(value = "/selectUserCoupons", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation(value = "获取客户所拥有的优惠券", httpMethod = "GET", notes = "获取客户所拥有的优惠券")
    public String selectUserCoupons(@ApiParam(value = "油站ID", required = true) @RequestParam Integer stationId,
                                    @ApiParam(value = "用户unionId", required = true) @RequestParam String unionId,
                                    @ApiParam(value = "优惠券状态couponIsUsed", required = true) @RequestParam String couponIsUsed,
                                    @RequestParam int pageNum, @RequestParam int pageSize){
        Gson gson =new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
        ResultData resultData = null;
        try {
            if(stationId !=null && StringUtils.isNotBlank(unionId) && StringUtils.isNotBlank(couponIsUsed)){
                StationInfo stationInfo = new StationInfo();
                stationInfo.setStationId(stationId);
                StationInfo stationInfos = stationService.selectStationInfo(stationInfo);
                if(stationInfos !=null && stationInfos.getCouponEnabledFlag().equals("1") && Integer.valueOf(pageNum) !=null && Integer.valueOf(pageSize) !=null){
                    PageHelper.startPage(pageNum, pageSize);
                    UserCoupon userCoupon = new UserCoupon();
                    userCoupon.setStationId(stationId);
                    userCoupon.setCouponIsUsed(couponIsUsed);
                    userCoupon.setExpireFlag("0");
                    userCoupon.setCurrentTime(new Date());
                    //已过期
                    if(couponIsUsed.equals("2")){
                        userCoupon.setCouponIsUsed("0");
                        userCoupon.setExpireFlag("1");
                    }
                    if(stationInfos.getCouponFlag() !=null && stationInfos.getCouponFlag().equals("1")){
                        userCoupon.setStationId(stationInfos.getGroupId());
                    }
                    userCoupon.setUnionId(unionId);
                    List<UserCoupon> userCoupons = couponService.selectUserCoupons(userCoupon);
                    PageInfo pageInfo = new PageInfo(userCoupons);
                    resultData = ResultData.success(pageInfo);
                }else {
                    resultData = ResultData.error(CodeMsg.NO_ENABLE_COUPON);
                }
            }else {
                resultData = ResultData.error(CodeMsg.PARAMS_NUll);
            }
        }catch (Exception e){
            e.printStackTrace();
            //logger.error("获取客户所拥有的优惠券错误信息：" + e.getMessage());
        }
        return  gson.toJson(resultData);
    }

    //用户领取优惠券
    @RequestMapping(value = "/addUserCoupon", consumes = "application/json", method = RequestMethod.POST)
    @ResponseBody
    @Transactional
    //@ApiOperation(value = "用户领取优惠券", httpMethod = "POST", notes = "用户领取优惠券")
    public String addUserCoupon(@RequestBody CouponUserRequest couponUserRequest){
        Gson gson = new Gson();
        ResultData resultData = null;
        try{
            String unionId =  couponUserRequest.getUnionId();
            String couponIds = couponUserRequest.getCouponIds();
            String couponIssueId =  couponUserRequest.getCouponIssueId();
            Integer stationId = couponUserRequest.getStationId();
            logger.info("用户领取优惠券所需参数： unionId: "+ unionId+ "; 油站ID：" +stationId + "; 优惠券IDS：" + couponIds + "; 领取方式ID: " + couponIssueId);
            StationInfo stationInfo = new StationInfo();
            stationInfo.setStationId(stationId);
            StationInfo stationInfos = stationService.selectStationInfo(stationInfo);
            //油站是否开启优惠券功能
            if(stationInfos !=null && stationInfos.getCouponEnabledFlag().equals("1")){
                if(StringUtils.isNotBlank(couponIds)){
                    String str[] = couponIds.split(",");
                    List<String> ids = Arrays.asList(str);
                    Coupon couponParam = new Coupon();                   //查询优惠券参数
                    UserCoupon userCouponParam = new UserCoupon();       //用户优惠券新增参数

                    //返回前端参数
                    List<String> successCouponList= new ArrayList<>();          //领取成功的优惠券
                    List<String> couponNumNEList= new ArrayList<>();            //优惠券数量不足
                    List<String> couponHoldNumMaxList= new ArrayList<>();       //用户持有优惠券数量达到最大值
                    List<String> notClaimedCouponList= new ArrayList<>();       //用户未领取的优惠券
                    List<String> couponReceiveNumList= new ArrayList<>();       //用户累计的优惠券

                    //获取领取方式信息
                    CouponIssue couponIssue = new CouponIssue();
                    couponIssue.setStationId(stationId);
                    if(stationInfos.getCouponFlag() !=null && stationInfos.getCouponFlag().equals("1")){
                        couponIssue.setStationId(stationInfos.getGroupId());
                    }
                    couponIssue.setCouponIssueId(couponIssueId);
                    List<CouponIssue> couponIssueList = couponService.selectCouponIssueList(couponIssue);
                    if(couponIssueList !=null && couponIssueList.size() ==1){
                        int couponSuccessNum =0;                                           //用户优惠券领取成功张数 couponSuccess
                        for(int i=0; i<ids.size(); i++){
                            Integer couponId = Integer.valueOf(ids.get(i));
                            couponParam.setCouponId(couponId);
                            //领取成功的张数与该领取方式在当前页最多领取的张数
                            if(couponSuccessNum <= couponIssueList.get(0).getGiveLimit()) {
                                Coupon coupon = couponService.selectCouponTemplateInfo(couponParam);
                                //该优惠券是否存在
                                if(coupon != null) {
                                    Integer couponCumulativeNum = coupon.getCouponCumulativeNum();
                                    //该优惠券是否已被领完
                                    if(coupon.getCouponNum() != null && coupon.getCouponNum() > 0) {
                                        UserCoupon uc = new UserCoupon();
                                        uc.setIssueId(couponIssueId);
                                        uc.setStationId(stationId);
                                        uc.setUnionId(unionId);
                                        uc.setCouponId(coupon.getCouponId());
                                        //获取该用户优惠券累计的张数
                                        int userCouponCountSum = couponService.selectUserCouponCount(uc);
                                        uc.setCouponIsUsed("0");
                                        //获取该用户所持有此优惠券的张数，即未使用的优惠券
                                        int userCouponCountNoUsed = couponService.selectUserCouponCount(uc);
                                        //获取该用户
                                        if(userCouponCountNoUsed < coupon.getCouponHoldNum()){
                                            if(userCouponCountSum < coupon.getCouponReceiveNum()){
                                                userCouponParam.setCouponIsUsed("0");           //是否使用：0、未使用；1、已使用；
                                                long currentTimeMillis = System.currentTimeMillis();
                                                String s = stationId + Long.toString(currentTimeMillis) + Math.round((Math.random() + 1) * 1000);
                                                String s1 = CryptUtil.useMD5(s);
                                                userCouponParam.setCouponNo(s1);                //优惠券编码
                                                userCouponParam.setUnionId(unionId);            //用户unionId
                                                userCouponParam.setIssueId(couponIssueId);      //领取方式ID
                                                userCouponParam.setCouponId(coupon.getCouponId());    //优惠券模板ID
                                                userCouponParam.setStationId(stationId);        //油站ID
                                                userCouponParam.setCouponIsEffective("1");      //优惠券是否有效
                                                userCouponParam.setGetCouponTime(new Date());   //优惠券领取时间
                                                String effectiveTimeType = coupon.getEffectiveTimeType();
                                                //'有效时间类型： 1，固定时间；2，领取后x天内有效'
                                                switch (effectiveTimeType) {
                                                    case "1":
                                                        userCouponParam.setCouponEffectiveTime(coupon.getEffectiveTimeEnd());  //优惠券有效期截止时间
                                                        break;
                                                    case "2":
                                                        Calendar calendar = Calendar.getInstance();
                                                        calendar.setTime(userCouponParam.getGetCouponTime());
                                                        calendar.add(Calendar.DATE, coupon.getEffectiveDayNum());     //领取后多少天有效
                                                        userCouponParam.setCouponEffectiveTime(calendar.getTime());   //优惠券有效期截止时间
                                                        break;
                                                }
                                                if(couponService.addUserCoupon(userCouponParam) == 1) {
                                                    //更新该优惠券的领取数量
                                                    Coupon coupon_up = new Coupon();
                                                    coupon_up.setCouponId(couponId);
                                                    couponCumulativeNum = couponCumulativeNum + 1;
                                                    coupon_up.setCouponCumulativeNum(couponCumulativeNum);
                                                    couponService.updateCouponInfo(coupon_up);
                                                    //领取成功
                                                    successCouponList.add(couponId.toString());
                                                    //领取成功后次数 +1
                                                    couponSuccessNum++;
                                                }
                                            }else {
                                                //用户累计领取已达到最大值
                                                couponReceiveNumList.add(couponId.toString());
                                            }
                                        }else {
                                            //用户持有数量超出
                                            couponHoldNumMaxList.add(couponId.toString());
                                        }
                                    }else {
                                        //优惠券数量不足
                                        couponNumNEList.add(couponId.toString());
                                    }
                                }
                            }else {
                                //未领取的优惠券
                                notClaimedCouponList.add(couponId.toString());
                            }
                        }
                        //领取成功
                        Map<String, Object> resultMap = new HashMap<>();
                        resultMap.put("successCouponList", successCouponList);
                        resultMap.put("couponNumNEList", couponNumNEList);
                        resultMap.put("couponHoldNumMaxList", couponHoldNumMaxList);
                        resultMap.put("notClaimedCouponList", notClaimedCouponList);
                        resultMap.put("couponReceiveNumList", couponReceiveNumList);
                        logger.info("用户领取到的优惠券：" + resultMap.toString());
                        //记录用户在该领取方式操作
                        CouponUserGiveCount couponUserGiveCount = new CouponUserGiveCount();
                        couponUserGiveCount.setStationId(stationId);
                        couponUserGiveCount.setUnionId(unionId);
                        couponUserGiveCount.setCouponIssueId(couponIssueId);
                        //用户能进入领取界面的次数
                        CouponUserGiveCount cgcInfo = couponService.selectCouponUserGiveCount(couponUserGiveCount);
                        if(cgcInfo !=null){
                            //更新次数
                            Integer issueGiveCount = cgcInfo.getIssueGiveCount();
                            int i = issueGiveCount + 1;
                            couponUserGiveCount.setIssueGiveCount(i);
                            couponUserGiveCount.setUpdateTime(new Date());
                            couponService.updateCouponUserGiveCount(couponUserGiveCount);
                        }else {
                            //新增次数
                            couponUserGiveCount.setIssueGiveCount(1);
                            couponUserGiveCount.setCreteTime(new Date());
                            couponService.addCouponUserGiveCount(couponUserGiveCount);
                        }
                        resultData = ResultData.success(resultMap);
                    }else {
                        resultData = ResultData.error(CodeMsg.NO_COUPON_ISSUE);
                    }
                }else {
                    resultData = ResultData.success(CodeMsg.SUCCESS);
                }
            }else {
                resultData = ResultData.error(CodeMsg.NO_ENABLE_COUPON);
            }
        }catch (Exception e){
            e.printStackTrace();
            //logger.error("用户领取优惠券错误信息：" + e.getMessage());
            //resultData = ResultData.error(CodeMsg.INSERT_FAIL);
        }
        return gson.toJson(resultData);
    }

    //异业端核销优惠券，兑换券
    @RequestMapping(value = "/findCouponVerificationUser", consumes = "application/json", method = RequestMethod.POST)
    @ResponseBody
    @Transactional
    public String findCouponVerificationUser(@RequestBody CouponVerificationUser couponVerificationUser){
        Gson gson =new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
        ResultData resultData = null;
        if(StringUtils.isNotBlank(couponVerificationUser.getMobilePhone()) && StringUtils.isNotBlank(couponVerificationUser.getUnionId())){
            //手机号
            String mobilePhone = couponVerificationUser.getMobilePhone();
            SysUser sysUser = new SysUser();
            sysUser.setPhonenumber(mobilePhone);
            sysUser.setStatus("0");
            sysUser.setDelFlag("0");
            SysUser su = sysUserService.selectSysUser(sysUser);
            if(su !=null){
                if(su.getDelFlag().equals("0")){
                    if(su.getStatus().equals("0")){
                        CouponVerificationUser cu = couponService.selectCouponVerificationUserInfo(couponVerificationUser);
                        if(cu !=null){
                            //更新
                            couponService.updateCouponVerificationUser(couponVerificationUser);
                        }else {
                            //新增
                            couponVerificationUser.setCreateTime(new Date());
                            couponService.addCouponVerificationUser(couponVerificationUser);
                        }
                        resultData = ResultData.success("登陆成功");
                    }else {
                        resultData = ResultData.error(CodeMsg.USER_NOT_STATUS);
                    }
                }else {
                    resultData = ResultData.error(CodeMsg.USER_NOT_EXSIST);
                }
            }else {
                resultData = ResultData.error(CodeMsg.USER_NOT_EXSIST);
            }
        }else {
            resultData = ResultData.error(CodeMsg.PARAMS_NUll);
        }
        return gson.toJson(resultData);
    }


    //异业端核销优惠券，兑换券
    @RequestMapping(value = "/writeOffCoupon", consumes = "application/json", method = RequestMethod.POST)
    @ResponseBody
    @Transactional
    public String writeOffCoupon(@RequestBody CouponVerification couponVerification){
        Gson gson =new Gson();
        ResultData resultData = null;
        try {
            if(couponVerification !=null && StringUtils.isNoneBlank(couponVerification.getCouponNo()) && StringUtils.isNoneBlank(couponVerification.getUnionId())){
                String unionId = couponVerification.getUnionId();
                //核销码
                String couponNo = couponVerification.getCouponNo();
                UserCoupon userCoupon = new UserCoupon();
                userCoupon.setCouponNo(couponNo);
                //查询当前兑换券是否存在
                UserCoupon userCouponInfo = couponService.selectUserCouponInfo(userCoupon);
                if(userCouponInfo !=null){
                    if(userCouponInfo.getCouponIsUsed().equals("0")){
                        //判断当前优惠券是否是异业券
                        if(userCouponInfo.getCouponType().equals("3")){
                            //核销人信息
                            CouponVerificationUser couponVerificationUser = new CouponVerificationUser();
                            couponVerificationUser.setUnionId(unionId);
                            CouponVerificationUser cu = couponService.selectCouponVerificationUserInfo(couponVerificationUser);
                            if(cu !=null && cu.getStationId() !=null){
                                //核销人员手机号
                                String mobilePhone = cu.getMobilePhone();
                                userCoupon.setMobilePhone(mobilePhone);
                                //当前核销人员的核销点
                                String verificationId = cu.getStationId().toString();
                                //异业券核销，使用sys_user中账户核销
                                StationInfo stationInfo = new StationInfo();
                                stationInfo.setStationId(cu.getStationId());
                                StationInfo stationInfos = stationService.selectStationInfo(stationInfo);
                                //当前异业券的核销站点
                                String verification = userCouponInfo.getVerification();
                                userCoupon.setVerificationTime(new Date());                     //核销时间
                                Integer stationIdCoupon = userCouponInfo.getStationId();        //当前优惠券所在发放站点
                                //如果当前异业券有核销站点
                                if(StringUtils.isNotBlank(verification)){
                                    //当前优惠券是否共享
                                    if(cu.getJiBie()!=null){
                                        String jiBie = cu.getJiBie();
                                        //核销人员所在站点的级别
                                        switch (jiBie){
                                            case "1":
                                                if(StringUtils.isNotBlank(stationInfos.getCouponFlag()) && stationInfos.getCouponFlag().equals("1")){
                                                    verificationId = stationInfos.getGroupId().toString();
                                                }
                                                break;
                                            case "2":
                                                if(StringUtils.isNotBlank(stationInfos.getCouponFlag()) && stationInfos.getCouponFlag().equals("1")){
                                                    //表示为集团下优惠券共享
                                                    verificationId = stationInfos.getStationId().toString();
                                                }
                                                break;
                                        }
                                    }
                                    //是否能在该核销点核销
                                    Integer stationIdVerification = cu.getStationId();              //核销人员所在核销点
                                    if(verification.contains(verificationId) || stationIdVerification.toString().equals(stationIdCoupon.toString())){
                                        userCoupon.setCouponIsUsed("1");
                                        couponService.updateCouponUserInfo(userCoupon);
                                        resultData = ResultData.success("核销成功！");
                                    }else {
                                        resultData = ResultData.error(CodeMsg.ERROR_VERIFICATION);
                                    }
                                }else if(verificationId.equals(stationIdCoupon.toString())){
                                    //如果当前异业券没有核销站点，则为油站设置自己兑换券
                                    userCoupon.setCouponIsUsed("1");
                                    couponService.updateCouponUserInfo(userCoupon);
                                    resultData = ResultData.success("核销成功！");
                                }else {
                                    //当前异业券不能在此异业端核销
                                    resultData = ResultData.error(CodeMsg.ERROR_VERIFICATION);
                                }
                            }else {
                                //此人不是核销人员
                                resultData = ResultData.error(CodeMsg.NOT_COUPON_VERIFICATION_USER);
                            }
                        }else{
                            //不是兑换券
                            resultData = ResultData.error(CodeMsg.NOT_COUPON_VERIFICATION);
                        }
                    }else {
                        //该兑换券已被使用
                        resultData = ResultData.error(CodeMsg.COUPON_VERIFICATION_USED);
                    }
                }else {
                    //没有此兑换券
                    resultData = ResultData.error(CodeMsg.NO_COUPON);
                }
            }else {
                resultData = ResultData.error(CodeMsg.PARAMS_NUll);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return  gson.toJson(resultData);
    }


    /***
     * 获取已核销优惠券信息列表
     * @param unionId
     * @return
     */
    @RequestMapping(value = "/selectCouponVerificationList", method = RequestMethod.GET)
    @ResponseBody
    @ApiOperation(value = "获取核销优惠券信息", httpMethod = "GET", notes = "获取核销优惠券信息")
    public String selectCouponVerificationList(@ApiParam(value = "用户unionId", required = true) @RequestParam String unionId,
                                               @RequestParam int pageNum, @RequestParam int pageSize) {
        Gson gson = new GsonBuilder().setDateFormat("yyyy-MM-dd HH:mm:ss").create();
        ResultData resultData = null;
        if(StringUtils.isNotBlank(unionId)){
            CouponVerificationUser couponVerificationUser = new CouponVerificationUser();
            couponVerificationUser.setUnionId(unionId);
            CouponVerificationUser cu = couponService.selectCouponVerificationUserInfo(couponVerificationUser);
            if(cu !=null && cu.getStationId() !=null){
                UserCoupon userCoupon = new UserCoupon();
                String jiBie = cu.getJiBie();               //核销用的级别
                Integer stationId = cu.getStationId();      //核销人员所属站点
                if(StringUtils.isNoneBlank(jiBie) && jiBie.equals("1")){
                    //级别为1的时候表示该登录人集团账号核销
                    StationInfo stationInfo = new StationInfo();
                    stationInfo.setStationId(stationId);
                    StationInfo stationInfos = stationService.selectStationInfo(stationInfo);
                    if(StringUtils.isNotBlank(stationInfos.getCouponFlag()) && stationInfos.getCouponFlag().equals("1")){
                        //表示集团下优惠券共享：如果为集团账号且共享优惠券 则判断当前核销人员所在站点的集团是否是该兑换券的集团
                        userCoupon.setGroupId(stationInfos.getGroupId());
                    }
                }else {
                    //否则为2时，则表示为站点核销人员登录
                    userCoupon.setStationId(stationId);
                }
                userCoupon.setCouponType("3");
                userCoupon.setCouponIsUsed("1");
                PageHelper.startPage(pageNum, pageSize);
                List<UserCoupon> userCoupons = couponService.selectCouponVerificationList(userCoupon);
                PageInfo pageInfo = new PageInfo(userCoupons);
                resultData = ResultData.success(pageInfo);
            }else {
                resultData = ResultData.error(CodeMsg.NOT_COUPON_VERIFICATION_USER);
            }
        }else {
            resultData = ResultData.error(CodeMsg.PARAMS_NUll);
        }
        return  gson.toJson(resultData);
    }

    /***
     * //营销方案活动日优惠
     * @param discountType              活动日时间类型
     * @param discountDate              活动日时间字符串，格式：1,2,3,4,5
     * @return
     */
    public boolean isActivityDay(String discountType, String discountDate){
        boolean boo= false;
        if(discountDate !=null && discountDate !=""){
            String currentTime = null;          //当前时间
            String[] discountDateArray = discountDate.split(",");
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(new Date());   //获取当前时间
            switch (discountType){
                case "1":   //  1.按周来
                    int day_Week = calendar.get(Calendar.DAY_OF_WEEK);
                    day_Week= day_Week-1;     //减一原因：数据库存的下标从零开始
                    currentTime = String.valueOf(day_Week);
                    break;
                case "2":   //  2.每月的 多少号
                    int day_month = calendar.get(Calendar.DAY_OF_MONTH);
                    day_month = day_month-1;        //减一原因：数据库存的下标从零开始
                    currentTime = String.valueOf(day_month); //当前时间
                    break;
                case "3":   //  3.固定日期
                    currentTime =new SimpleDateFormat("yyyy-MM-dd").format(new Date()); //当前时间
                    break;
            }
            //活动日优惠金额
            for (String s : discountDateArray){
                if(s.equals(currentTime)){
                    boo = true;
                    break;
                }
            }
        }
        return boo;
    }

}