package com.topdraw.business.process.rest;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;

import com.alibaba.fastjson.JSONObject;
import com.topdraw.annotation.AnonymousAccess;
import com.topdraw.business.module.common.validated.CreateGroup;
import com.topdraw.business.module.common.validated.UpdateGroup;
import com.topdraw.business.module.member.domain.Member;
import com.topdraw.business.module.member.service.MemberService;
import com.topdraw.business.module.member.service.dto.MemberDTO;
import com.topdraw.business.module.user.iptv.domain.UserTv;
import com.topdraw.business.module.user.iptv.service.dto.UserTvDTO;
import com.topdraw.business.module.user.weixin.domain.UserWeixin;
import com.topdraw.business.module.user.weixin.service.dto.UserWeixinDTO;
import com.topdraw.business.process.domian.weixin.*;
import com.topdraw.business.process.service.UserOperationService;
import com.topdraw.business.process.service.member.MemberOperationService;
import com.topdraw.common.ResultInfo;
import com.topdraw.config.RedisKeyUtil;
import com.topdraw.exception.BadRequestException;
import com.topdraw.exception.EntityNotFoundException;
import com.topdraw.exception.GlobeExceptionMsg;
import com.topdraw.resttemplate.RestTemplateClient;
import com.topdraw.util.Base64Util;
import com.topdraw.util.JSONUtil;
import com.topdraw.utils.RedisUtils;
import com.topdraw.weixin.util.WeChatConstants;
import com.topdraw.weixin.util.WeixinUtil;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.Assert;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.validation.constraints.NotNull;
import java.io.IOException;
import java.net.URLDecoder;
import java.sql.Timestamp;
import java.util.*;

@Api("账户处理")
@RestController
@RequestMapping(value = "/uce/userOperation")
@Slf4j
@CrossOrigin
public class UserOperationController {

    @Autowired
    private MemberService memberService;
    @Autowired
    private UserOperationService userOperationService;
    @Autowired
    private MemberOperationService memberOperationService;

    @Autowired
    private RedisUtils redisUtils;

    private static final String SUBSCRIBE = "subscribe";
    private static final String UNSUBSCRIBE = "unsubscribe";
    private static final Integer SUBSCRIBE_STATUS = 1;

    @PutMapping(value = "/updateWeixin")
    @ApiOperation("修改UserWeixin")
    @AnonymousAccess
    public ResultInfo updateWeixin(@Validated @RequestBody UserWeixin resources) {
        userOperationService.updateWeixin(resources);
        return ResultInfo.success();
    }

    @RequestMapping(value = "/updateVipByUserId")
    @ApiOperation("通过账号id修改vip")
    @AnonymousAccess
    public ResultInfo updateVipByUserId(@Validated(value = {UpdateGroup.class}) @RequestBody
                                                    UserOperationBean resources) {
        log.info("userOperation ==>> updateVipByUserId ==>> param ==>> [{}]",resources);

        Integer vip = resources.getVip();
        Timestamp vipExpireTime = resources.getVipExpireTime();
        // 微信账号id
        Long userId = resources.getUserId();
        UserWeixinDTO userWeixinDTO = this.userOperationService.findById(userId);

        Long memberId = userWeixinDTO.getMemberId();
        MemberDTO memberDTO = this.memberService.findById(memberId);

        Member member = new Member();
        member.setId(memberDTO.getId());
        member.setCode(memberDTO.getCode());
        if (Objects.nonNull(vip)) {
            member.setVip(vip);
        }
        if (Objects.nonNull(vipExpireTime)) {
            member.setVipExpireTime(vipExpireTime);
        }

        this.memberOperationService.doUpdateMemberVipAndVipExpireTime(member);

        this.createVipHistory(userId, vip, vipExpireTime);

        return ResultInfo.success();
    }


    private void createVipHistory(Long weixinUserId, Integer vip , Timestamp vipExpireTime){
        BuyVipBean buyVipBean = new BuyVipBean();
        buyVipBean.setId(weixinUserId);
        buyVipBean.setVip(vip);
        buyVipBean.setVipExpireTime(vipExpireTime);
        this.memberOperationService.buyVipByUserId(buyVipBean);
    }

    @PostMapping(value = "/createWeixinUserAndCreateMember")
    @ApiOperation("新增小屏账户同时创建会员信息")
    @AnonymousAccess
    public ResultInfo createWeixinUserAndMember(@Validated(value = {CreateGroup.class}) @RequestBody UserWeixin resources) {
        log.info("UserOperationController ==> createWeixinUserAndMember ==> param  ==> [{}]",resources);

        UserWeixinDTO result = this.userOperationService.createWeixinUserAndMember(resources);
        return ResultInfo.success(result);
    }

    @PostMapping("/serviceLogin")
    @ApiOperation("微信服务号(H5)登录")
    @AnonymousAccess
    public ResultInfo serviceLogin(@Validated(value = {CreateGroup.class}) @RequestBody UserWeixin resources) {
        log.info("UserOperationController ==> serviceLogin ==>> param  ==> [{}]",resources);

        UserWeixinDTO result = this.userOperationService.serviceLogin(resources);
        return ResultInfo.success(result);
    }

    @PostMapping("/appletLogin")
    @ApiOperation("微信小程序登录")
    @AnonymousAccess
    public ResultInfo appletLogin(@Validated(value = {CreateGroup.class}) @RequestBody UserWeixin resources) {
        log.info("UserOperationController ==> appletLogin ==>> param  ==> [{}]",resources);

        UserWeixinDTO result = this.userOperationService.appletLogin(resources);
        return ResultInfo.success(result);
    }

    @PostMapping("/subscribe")
    @ApiOperation("微信公众号关注")
    @AnonymousAccess
    public ResultInfo subscribe(@Validated @RequestBody SubscribeBeanEvent data) throws IOException {
        log.info("UserOperationController ==> subscribe ==>> param  ==> [{}]",data);

        SubscribeBean subscribeBean = JSONUtil.parseMsg2Object(data.getContent(), SubscribeBean.class);
        // 解析参数
        this.parseSubscribe(subscribeBean);
        boolean subscribe = this.userOperationService.subscribe(subscribeBean);
        if (subscribe) {
            return ResultInfo.success("关注成功");
        } else {
            return ResultInfo.failure("关注失败");
        }
    }

    /**
     *
     * @param subscribeBean
     * @throws IOException
     */
    private void parseSubscribe(SubscribeBean subscribeBean) throws IOException {

        // appId
        String appId = subscribeBean.getAppid();
        Assert.notNull(appId, GlobeExceptionMsg.APP_ID_IS_NULL);
        // openId
        String openId = subscribeBean.getOpenid();
        Assert.notNull(openId, GlobeExceptionMsg.OPEN_ID_IS_NULL);
        // unionId
        String unionId = subscribeBean.getUnionid();
        Assert.notNull(openId, GlobeExceptionMsg.UNION_ID_IS_NULL);

        // 匹配配置文件中的微信列表信息
        Map<String, String> wxInfoMap = WeixinUtil.getWeixinInfoByAppid(appId);

        if (Objects.nonNull(wxInfoMap)) {
            // 程序类型
            String appType = wxInfoMap.get("appType");
            // 非订阅号，暂不处理。返回暂不支持
            if (ObjectUtil.notEqual(appType, WeChatConstants.WX_SUBSCRIPTION))
                throw new BadRequestException("非订阅号");

        }

        // 大屏账户信息
        JSONObject iptvUserInfo = null;
        // 缓存的大屏信息，使用unionid即可
        String content = (String) this.redisUtils.get(RedisKeyUtil.genSeSuSubscribeKey(unionId));
        if (StringUtils.isNotBlank(content)) {
            // 大屏信息
            iptvUserInfo = JSONObject.parseObject(content);
        }

        // 用户自己搜索关注就没有大屏信息，否则表示扫码关注
        if (Objects.nonNull(iptvUserInfo)) {

            subscribeBean.setIptvUserInfo(iptvUserInfo);
            Object sourceInfo1 = iptvUserInfo.get("sourceInfo");
            if (Objects.nonNull(sourceInfo1)) {
                String sourceInfo = sourceInfo1.toString();
                if (StringUtils.isNotBlank(sourceInfo))
                    subscribeBean.setSourceInfo(sourceInfo);
            }

            String nickname = iptvUserInfo.get("nickname").toString();
            if (StringUtils.isNotBlank(nickname)) {
                String nicknameDecode = URLDecoder.decode(nickname, "UTF-8");
                String nicknameEncode = Base64Util.encode(nicknameDecode);
                subscribeBean.setNickname(nicknameEncode);
            }

            String headimgurl = iptvUserInfo.get("headimgurl").toString();
            log.info("parseSubscribe ==>> headimgurl ==>> {}", headimgurl);
            if (StringUtils.isNotBlank(headimgurl)) {
                String headimgurlDecode = URLDecoder.decode(headimgurl, "UTF-8");
                if (StringUtils.isNotBlank(headimgurlDecode)) {
                    if (headimgurl.contains("https") || headimgurl.contains("http")) {
                        headimgurl = this.downloadWeixinImge(headimgurlDecode);
                    }
                    subscribeBean.setHeadimgurl(headimgurl);
                }
            }

        } else {

            // headimgurl
            String headimgurl = subscribeBean.getHeadimgurl();
            if (StringUtils.isNotBlank(headimgurl)) {
                if (headimgurl.contains("https") || headimgurl.contains("http")) {
                    String headImgUrl = this.downloadWeixinImge(headimgurl);
                    subscribeBean.setHeadimgurl(headImgUrl);
                }
            }

        }

    }

    @PostMapping("/unsubscribe")
    @ApiOperation("微信公众号取关")
    @AnonymousAccess
    public ResultInfo unsubscribe(@Validated @RequestBody SubscribeBeanEvent data) {
        log.info("UserOperationController ==> unsubscribe ==>> param  ==> [{}]",data);

        SubscribeBean subscribeBean = JSONUtil.parseMsg2Object(data.getContent(), SubscribeBean.class);

        String appId = subscribeBean.getAppid();
        Assert.notNull(appId, GlobeExceptionMsg.APP_ID_IS_NULL);
        // openId
        String openId = subscribeBean.getOpenid();
        Assert.notNull(openId, GlobeExceptionMsg.OPEN_ID_IS_NULL);

        subscribeBean.setAppid(appId);
        subscribeBean.setOpenid(openId);

        boolean result = this.userOperationService.unsubscribe(subscribeBean);
        return ResultInfo.success(result);
    }

    @PostMapping("/minaBind")
    @ApiOperation("微信小程序绑定大屏")
    @AnonymousAccess
    public ResultInfo minaBind(@Validated(value = {BindGroup.class}) @RequestBody BindBean resources) {
        log.info("UserOperationController ==> appletBind ==>> param  ==> [{}]",resources);

        Long memberId = resources.getMemberId();
        if (Objects.isNull(memberId)) {
            return ResultInfo.failure("参数错误，memberId 不存在");
        }

        String platformAccount = resources.getPlatformAccount();
        if (StringUtils.isBlank(platformAccount)) {
            return ResultInfo.failure("参数错误，大屏账号不存在");
        }

        boolean result = this.userOperationService.minaBind(resources);
        return ResultInfo.success(result);
    }

    @PostMapping("/minaUnbind")
    @ApiOperation("小屏解绑")
    @AnonymousAccess
    public ResultInfo minaUnbind(@Validated(value = {UnbindGroup.class}) @RequestBody WeixinUnBindBean weixinUnBindBean) {
        log.info("UserOperationController ==> minaUnbind ==>> param  ==> [{}]", weixinUnBindBean);

        Long memberId = weixinUnBindBean.getMemberId();
        if (Objects.isNull(memberId)) {
            log.error("小屏解绑失败，参数错误，memberId不存在");
            return ResultInfo.failure("参数错误，会员id不存在");
        }
        boolean b = this.userOperationService.minaUnbind(weixinUnBindBean);
        if (b) {
            return ResultInfo.success("解绑成功");
        } else {
            return ResultInfo.failure("解绑失败");
        }
    }

    /**
     * 1.未关注、未绑定
     * 2.已绑定、未关注
     * 3.已关注、未绑定
     * @param data
     * @return
     */
    @PostMapping(value = "/memberPreprocess")
    @ApiOperation("暂存大小屏信息并检查关注与绑定状态")
    @AnonymousAccess
    public ResultInfo memberPreprocess(@RequestBody String data) {

        log.info("UserOperationController ==> saveUserInfo ==>> param ==>> [{}]",data);
        if (StringUtils.isBlank(data)) {
            log.error("预存大小屏账号信息失败，无参数");
            return ResultInfo.failure("参数错误");
        }

        JSONObject json = JSONObject.parseObject(data);

        String unionid = json.getString("unionid");
        if (StringUtils.isBlank(unionid)) {
            log.error("预存大小屏账号信息失败，参数错误，unionid不存在");
            return ResultInfo.failure("参数错误，unionid不存在");
        }


        List<Object> resultList = new ArrayList<>();
        // 大屏侧通过返回值来展示对应的小程序页面
        String result = SUBSCRIBE;
        String platformAccount1 = "";

        // 保存大小屏信息到redis同时返回小屏信息
        UserWeixinDTO userWeixinDTO = this.userOperationService.saveUserInfo(data);

        // 小屏账号不存在
        if (Objects.isNull(userWeixinDTO) || Objects.isNull(userWeixinDTO.getId())) {

            result = UNSUBSCRIBE;
            resultList.add(result);
            resultList.add(platformAccount1);
            log.info("saveUserInfo ==>> result ==>> [{}]",resultList);
            return ResultInfo.success(resultList);

        } else {

            // 账号存在，未关注
            if (userWeixinDTO.getStatus() != SUBSCRIBE_STATUS) {
                result = UNSUBSCRIBE;
            }

            // 小屏会员
            MemberDTO memberDTO = this.memberService.findById(userWeixinDTO.getMemberId());

            if (Objects.nonNull(memberDTO)) {

                // 检查是否绑定，返回绑定的大屏账户
                UserTvDTO userTvDTO = this.userOperationService.checkBind(memberDTO);
                if (Objects.nonNull(userTvDTO)) {
                    // 绑定的大屏账号
                    platformAccount1 = userTvDTO.getPlatformAccount();
                }

            } else {

                // 数据异常，没有会员
                log.info("userWeixinDTO ==>> [{}]",userWeixinDTO);
                throw new EntityNotFoundException(MemberDTO.class,"code","member is null !!");

            }

            // 已关注
            if (result.equalsIgnoreCase(SUBSCRIBE)) {

                // 未绑定
                if (StringUtils.isBlank(platformAccount1)) {

                    // redis中的大小屏信息
                    String content = (String) this.redisUtils.get(RedisKeyUtil.genSeSuSubscribeKey(unionid));
                    JSONObject iptvUserInfo = JSONObject.parseObject(content);
                    // redis中的大小屏信息
                    log.info("saveUserInfo ==> redis content iptvUserInfo  ==> [{}]",iptvUserInfo);

                    // 大屏账户
                    String platformAccount = iptvUserInfo.getString("platformAccount");

                    if (StringUtils.isBlank(platformAccount)) {
                        log.warn("绑定失败，platformAccount is null ");
                        return ResultInfo.failure("绑定失败");
                    }


                    try {
                        String headimgurl = iptvUserInfo.get("headimgurl").toString();

                        log.info("headimgurl ==>> {}", headimgurl);

                        String nickname = iptvUserInfo.get("nickname").toString();
                        if (StringUtils.isNotBlank(nickname)) {
                            String nicknameDecode = URLDecoder.decode(nickname, "UTF-8");
                            String nicknameEncode = Base64Util.encode(nicknameDecode);
                            memberDTO.setNickname(nicknameEncode);
                        }

                        if (StringUtils.isNotBlank(headimgurl)) {

                            if(headimgurl.contains("https")||headimgurl.contains("http")) {
                                String headimgurlDecode = URLDecoder.decode(headimgurl, "UTF-8");
//                                String imageEncode = Base64Util.encode(headimgurlDecode);
                                String image = RestTemplateClient.netImage(headimgurlDecode);
                                memberDTO.setAvatarUrl(StringUtils.isNotBlank(image) == true ? image:headimgurlDecode);
                            }

                        }

                    } catch (Exception e) {
                        log.info("头像解析失败！！！");
                        e.printStackTrace();
                    }

                    // 大小屏绑定,如果已经绑定了别的大屏，则不进行处理，返回已绑定的大屏信息
                    UserTvDTO userTvDTO = this.userOperationService.bind(memberDTO, platformAccount);
                    if (userTvDTO != null) {
                        platformAccount1 = userTvDTO.getPlatformAccount();
                    }

                }

            }

        }

        resultList.add(result);
        resultList.add(platformAccount1);

        // return ["subscribe","platform_account"]
        ResultInfo<Object> success = ResultInfo.success(resultList);

        log.info("saveUserInfo ==> ResultInfo  ==> [{}]",success);
        return success;
    }

    private String downloadWeixinImge(String headimgurl){
        try {
            if (StringUtils.isNotBlank(headimgurl)) {
                String image = RestTemplateClient.netImage(headimgurl);
                return image;
            }
        } catch (Exception e) {
            log.info("头像解析失败！！！");
            e.printStackTrace();
        }

        return null;
    }


    /******************************************************* IPTV ************************************/

    @PostMapping(value = "/updateUserTv")
    @ApiOperation("修改大屏账号")
    @AnonymousAccess
    public ResultInfo updateUserTv(@Validated(value = {UpdateGroup.class}) @RequestBody UserTv resources) {
        log.info("UserOperationController ==> updateUserTv ==>> param  ==> [{}]",resources);

        UserTvDTO result = this.userOperationService.updateUserTv(resources);
        return ResultInfo.success(result);
    }

    @PostMapping(value = "/createTvUserAndMember")
    @ApiOperation("保存大屏账户同时创建会员信息")
    @AnonymousAccess
    public ResultInfo createTvUserAndMember(@Validated(value = {CreateGroup.class}) @RequestBody UserTv resources) {
        log.info("UserOperationController ==> createUserAndCreateMember ==>> param  ==> [{}]",resources);

        UserTvDTO result = this.userOperationService.createTvUserAndMember(resources);
        return ResultInfo.success(result);
    }

    @RequestMapping(value = "/tvUnbind")
    @ApiOperation("大屏解绑")
    @AnonymousAccess
    public ResultInfo tvUnbind(@Validated(value = {UpdateGroup.class}) @RequestBody TvUnBindBean resources) {
        log.info("UserOperationController ==> unbind ==>> param  ==> [{}]",resources);

        String memberCode = resources.getMemberCode();
        log.info("大屏解绑，前端参数，需要解绑的会员code，memberCode ==>> {}", memberCode);
        if (StringUtils.isBlank(memberCode)) {
            throw new BadRequestException(GlobeExceptionMsg.MEMBER_CODE_IS_NULL);
        }

        String platformAccount = resources.getPlatformAccount();
        log.info("大屏解绑，前端参数，大屏账号，platformAccount ==>> {}", platformAccount);
        if (StringUtils.isBlank(platformAccount)) {
            throw new BadRequestException(GlobeExceptionMsg.IPTV_PLATFORM_ACCOUNT_IS_NULL);
        }

        boolean b = this.userOperationService.tvUnbind(resources);
        if (b) {
            return ResultInfo.success("解绑成功");
        } else return ResultInfo.failure("解绑失败");
    }

    @RequestMapping(value = "/changeMainAccount")
    @ApiOperation("大屏更换主账号")
    @AnonymousAccess
    public ResultInfo changeMainAccount(@Validated(value = {UpdateGroup.class}) @RequestBody BindBean resources) {
        log.info("UserOperationController ==> changeMainAccount ==>> param  ==> [{}]",resources);

        Long memberId = resources.getMemberId();
        String memberCode = resources.getMemberCode();
        if (StringUtils.isBlank(memberCode) && Objects.nonNull(memberId)) {
            memberCode = this.memberService.findCodeById(memberId);
        }
        String platformAccount = resources.getPlatformAccount();
        if (StringUtils.isBlank(platformAccount))
            throw new BadRequestException(GlobeExceptionMsg.IPTV_PLATFORM_ACCOUNT_IS_NULL);

        UserTv userTv = new UserTv();
        userTv.setMemberCode(memberCode);
        userTv.setPlatformAccount(platformAccount);
        boolean b = this.userOperationService.changeMainAccount(userTv);

        return ResultInfo.success(b);
    }

    @PostMapping(value = "/deleteAllCollection")
    @ApiOperation("删除全部收藏")
    @AnonymousAccess
    public ResultInfo deleteAllCollection(@RequestBody String content) {
        log.info("UserOperationController ==> deleteAllCollection ==> param  ==> [{}]",content);

        boolean result = this.userOperationService.deleteAllCollection(content);
        return ResultInfo.success(result);
    }

    @PostMapping(value = "/deleteCollection")
    @ApiOperation("删除收藏")
    @AnonymousAccess
    public ResultInfo deleteCollection(@RequestBody String content) {
        log.info("UserOperationController ==> deleteCollection ==> param  ==> [{}]",content);

        boolean result = this.userOperationService.deleteCollection(content);
        return ResultInfo.success(result);
    }

    @PostMapping(value = "/addCollection")
    @ApiOperation("添加收藏")
    @AnonymousAccess
    public ResultInfo addCollection(@RequestBody String content) {
        log.info("UserOperationController ==> addCollection ==>> param  ==> [{}]",content);
        if (StringUtils.isNotBlank(content)) {
            boolean result = this.userOperationService.addCollection(content);
            return ResultInfo.success(result);
        }
        return ResultInfo.success();
    }

}